CscWorldElement.h

Go to the documentation of this file.

//
//  CscEnvironnement.hpp
//  ConscienceRobotManager
//
//  Created by Conscience_Hazar on 05/03/2019.
//  Copyright © 2019 IliesZaoui. All rights reserved.
//
 
#ifndef CscWorldElement_h
#define CscWorldElement_h
 
#include "CscCommon.h"
#include <limits>
#include "Axiomes/Csc3dTypes.h"
#include "CoreObjects/CscPhysicsType.h"
#include "CoreObjects/CscWorldElementParts.h"
 
using std::stringstream, std::istringstream, std::endl, std::ios, std::numeric_limits;
using namespace conscience_core::axiomes;
 
typedef string CscWorldElementId;
 
class CscWorldElement{
 
public:
    
    CscWorldElement(const CscWorldElementId & id,
                    const string & name,
                    CscPoint3d * positionIn,
                    CscPoint3d * rotationEulerIn,
                    CscPhysicsType physicsType = CscPhysicsType::BOUNDING_BOX,
                    float mass = 5.0,
                    vector<CscWorldElementPart *> * parts = nullptr,
                    vector<CscPoint3d *> * positions = nullptr,
                    vector<CscPoint3d *> * normals = nullptr,
                    vector<CscPolygon *> * polygons = nullptr,
                    vector<const CscLocationTag *> * locationTags = nullptr,
                    float minX = 0,
                    float minY = 0,
                    float minZ = 0,
                    float depth = 0,
                    float height = 0,
                    float width = 0);
    
    virtual ~CscWorldElement();
 
    virtual CscPoint3d getMinPositionInWorldCoordinates() const;
 
    const CscPoint3d * getPosition() const;
    
    void setPosition(float x, float y, float z);
 
    const CscPoint3d * getRotationEulerAsPoint() const;
    
    void setRotationEuler(double x, double y, double z);
 
    void setRotationQuaternion(double w, double x, double y, double z);
    
    bool isIn3DArea(const CscArea3d *area) const;
    
    const string & getName() const;
 
    virtual CscWorldElementId getId() const;
    
    float getMass();
 
    virtual CscSize3d getDimensions() const;
 
    float depth = 0;
    float height = 0;
    float width = 0;
    float minX, minY, minZ;
    float mass = 1.0;
    float restitution = 0.3;
    float dampingLinear = 0.3;
    float dampingAngular = 0.3;
    float friction = 1.0;
    bool collideWithOthers = true;
 
    float certitude = 0.0; // TMP
    
    float * getVerticesArray() const;
    float * getPolygonsArray() const;
    int getVerticesCount() const;
    int getPolygonsCount() const;
 
    void repositionateToZeroOriginPositions();
    void repositionateToZeroOriginPolygons();
 
    vector<CscPoint3d *> * getPositions() const;
 
    vector<CscPolygon *> * getPolygons() const;
 
    vector<CscPolygon *> getPolygonsInWorldCoordinates() const;
 
    vector<CscPoint3d *> getYPlanSlicePoints(double sliceY, double precisionCm = 5.0) const;
 
    vector<CscPoint3d *> * getNormals() const;
    
    const vector<CscWorldElementPart *> * getParts() const;
    
    vector<CscPoint3d *> * getReconstructedVerticesFromPolygons(const int stepInCm = 10) const;
 
    static CscWorldElementId nextId() {
        unsigned long long numericId;
        if (lastNumericId >= MAX_NUMERIC_ID - 2) {
            LOG_WARN("Csc objects counter reached max and starts over at min value");
            numericId = MIN_NUMERIC_ID;
        } else {
            numericId = ++lastNumericId;
        }
        
        return to_string(numericId);
    }
    
    CscPhysicsType getPhysicsType() const;
    
    const CscLocationTag* getLocationTagByName(const string & name) const;
    
    void forcePolygons(const vector<CscPolygon *> & newPolygons);
    
    void addTag(const string &tag);
    void removeTag(const string &tag);
    bool hasTag(const string &tag) const;
 
    const double *const getRotationQuaternionArray() const;
 
    CscQuaternion getRotationQuaternion() const;
    CscRotation3dEuler getRotationEuler() const;
 
private:
    inline static const unsigned long long MIN_NUMERIC_ID = numeric_limits<unsigned long long>::min();
    inline static const unsigned long long MAX_NUMERIC_ID = numeric_limits<unsigned long long>::max();
    inline static unsigned long long lastNumericId = CscWorldElement::MIN_NUMERIC_ID;
    
    const string name;
    CscPoint3d * position;
    CscPoint3d * rotationEuler;
    
    double rotationQuaternion[4];
    
    vector<CscPoint3d *> * positions;
    
    const CscPhysicsType physicsType;
    vector<CscPoint3d *> * normals;
    vector<CscPolygon *> * polygons;
    
    vector<CscWorldElementPart *> * parts;
    
    vector<string> tags;
    
protected:
    const CscWorldElementId id;
    vector<const CscLocationTag*> * locationTags;
 
    virtual const CscPoint3d &getBaseRotation() const;
};
 
#endif