- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

# src/Object3D/Object3D.hpp

Go to the documentation of this file.

    00001 #ifndef OBJECT_3D_HPP
    00002 #define OBJECT_3D_HPP
    00003
    00004 // Détection du système cible...
    00005 #include "usgeDetectSystem.h"
    00006
    00007 // Les types "USpeed Game Engine"
    00008 #include "Core/CoreTypes.hpp"
    00009 #include "Material/Texture.hpp"
    00010 #include "Physic/PhysicState.hpp"
    00011
    00012 // Les vecteurs
    00013 #include <vector>
    00014
    00015 namespace USpeedGameEngine
    00016 {
    00017
    00018 class Object3D;
    00019
    00023 typedef struct StructObject3DParentAttach
    00024 {
    00025     Object3D    *parent;
    00026     USGE_Float3 point;
    00027 } Object3DParentAttach;
    00028
    00029
    00030 class Object3D
    00031 {
    00032     /****************
    00033     * Les attributs *
    00034     ****************/
    00035     public :
    00036         Object3DParentAttach parentAttach;
    00037         USGE_Vertex *vertices;
    00038         unsigned long int verticesCount;
    00039
    00040         Material *material;
    00041         bool smooth;
    00042         USGE_Float3 translation;
    00043         USGE_Float3 rotation;
    00044         USGE_Float3 scale;
    00045         Physic::PhysicState *physicState;
    00046         //Skeleton *skeleton;                 //!< Le squelette de l'objet en vue d'une animation
    00047
    00049         struct StructBoundinBox
    00050         {
    00051             USGE_Float3 min;
    00052             USGE_Float3 max;
    00053         } boundingBox;
    00054
    00056         struct StructBoundinSphere
    00057         {
    00058             USGE_Float3 center;
    00059             float radius;
    00060         } boundingSphere;
    00061
    00062     protected :
    00063     private :
    00065         typedef struct PlaneStruct
    00066         {
    00067             float a;
    00068             float b;
    00069             float c;
    00070             float d;
    00071             bool visible;
    00072         } USGE_Plane;
    00073         USGE_Plane *planes;
    00074         unsigned long int planesCount;
    00075     /***************
    00076     * Les méthodes *
    00077     ***************/
    00078     public :
    00079         // Destructeur par défaut
    00080         ~Object3D();
    00081         // Constructeur par défaut
    00082         Object3D();
    00083
    00084         // Affectation d'une liste de Vertex (par copie ou non)
    00085         bool setVertices(USGE_Vertex *vList, unsigned long int vCount);
    00086         bool setVertices(USGE_Vertex *vList, unsigned long int vCount, bool copy);
    00087         // Affectation d'une texture à appliquer au modèle 3D
    00088         void setMaterial(Material *pMat);
    00089         // Remise à zéro de l'instance de la classe
    00090         void clear();
    00091         // Effectue le rendu de l'objet
    00092         void render();
    00093         void render(bool noCamera);
    00094         // Effectue le rendu de l'ombre de l'objet en fonction de la position de la lumière spécifiée.
    00095         void renderShadow(USGE_Float3 const &lightPosition);
    00096         // Retourne le nombre de "Vertex" que contient l'objet 3D.
    00097         unsigned long int getVerticesCount();
    00098         // Retourne le "Vertex" demandé.
    00099         USGE_Vertex *getVertex(unsigned long int num);
    00100         // Modifie la géométrie du modèle actuellement en mémoire qu'il tienne dans une boîte de "1 x 1 x 1".
    00101         void scaleToUnit();
    00102         // Modifie la géométrie du modèle actuellement en mémoire qu'il tienne dans une boîte de "A x A x A".
    00103         void scaleTo(float scale);
    00104         // Modifie la géométrie du modèle actuellement en mémoire qu'il tienne dans une boîte de "X x Y x Z".
    00105         void scaleTo(USGE_Float3 const &scale);
    00106
    00108         // Chargements //
    00110         // Chargement de la géométrie depuis un fichier.
    00111         bool load3D(const char *filename);
    00112         // Chargement de la géométrie depuis un tampon mémoire.
    00113         bool load3DFromBuffer(const char *data, unsigned long int dataSize);
    00114         // Chargement d'un cube
    00115         bool loadCube();
    00116         // Chargement d'un parallèlépipède rectangle
    00117         bool loadBox(USGE_Float3 const &min, USGE_Float3 const &max, std::vector<float*> *uvMap);
    00118         bool loadBox(USGE_Float3 const &min, USGE_Float3 const &max);
    00119         bool loadBox(USGE_Float3 const &dim);
    00120         // Calcul de la Bounding Box (boîte d'encadrement).
    00121         void computeBB();
    00122
    00124         // Rendu doux ? //
    00126         // Choix d'un rendu doux ou brut par défaut.
    00127         static void setDefaultSmooth(bool activate);
    00128         // État du choix d'un rendu doux ou brut par défaut.
    00129         static bool getDefaultSmooth();
    00130         // Choix d'un rendu doux ou brut.
    00131         void setSmooth(bool activate);
    00132         // État du choix d'un rendu doux ou brut.
    00133         bool getSmooth();
    00134
    00136         // Les ombres //
    00138         // Permet d'activer/désactiver la génération de l'ombre de ce modèle lors du rendu par rapport à la lumière concernée
    00139         //void setShadowState(unsigned long int num, bool active);
    00140         // Permet de d'activer/désactiver toutes les ombres
    00141         //void setShadowState(bool active);
    00142
    00144         // Dépendance //
    00146         // Définition de la dépendance à un parent
    00147         void attachTo(Object3D *parent, USGE_Float3 const &translate);
    00148         // Suppression du lien d'ancrage à un parent
    00149         void detach();
    00150
    00152         // Informations sur l'état physique //
    00154         // Permet de savoir si l'objet a un état physique défini
    00155         bool hasPhysicState();
    00156         // Affectation d'un état physique à l'objet.
    00157         void setPhysicState(Physic::PhysicState *phyState);
    00158         // Accès à l'état physique de l'objet
    00159         Physic::PhysicState *getPhysicState();
    00160
    00162         // Transformations //
    00164         // Permet de définir la translation à effectuer sur modèle avant le rendu
    00165         void setTranslation(USGE_Float3 const &trans, bool add);
    00166         void setTranslation(USGE_Float3 const &trans);
    00167         // Permet de définir la rotation à effectuer sur modèle avant le rendu
    00168         void setRotation(USGE_Float3 const &rot, bool add);
    00169         void setRotation(USGE_Float3 const &rot);
    00170         // Définit l'échelle d'affichage du modèle
    00171         void setScale(float scale);
    00172         void setScale(USGE_Float3 const &scale);
    00173
    00175         // Accesseurs //
    00177         // Accès à la translation actuelle du modèle
    00178         void getTranslation(USGE_Float3 &pTranslation);
    00179         USGE_Float3 getTranslation();
    00180         // Accès à la rotation actuelle du modèle
    00181         void getRotation(USGE_Float3 &pRotation);
    00182         USGE_Float3 getRotation();
    00183         // Accès à l'échelle dynamique du modèle
    00184         void getScale(USGE_Float3 &pScale);
    00185         USGE_Float3 getScale();
    00186
    00187     protected :
    00188     private :
    00189         // Effectue les transformations directes de l'objet courant en tant que parent lors du rendu d'un enfant
    00190         void processParentTransform(Object3DParentAttach *anchor);
    00191 };
    00192
    00193 }        // Fin "namespace USpeedGameEngine"
    00194
    00195 #endif