Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/graphics/importer/model.h @ 5957

Last change on this file since 5957 was 5790, checked in by bensch, 19 years ago

orxonox/trunk: rescale of the screen-size should reload Models too on windows

File size: 7.2 KB
Line 
1/*!
2  \file model.h
3  \brief Contains the Model Class that handles 3D-Models
4*/
5
6#ifndef _MODEL_H
7#define _MODEL_H
8
9#include "abstract_model.h"
10
11#include "material.h"
12#include "glincl.h"
13#include "array.h"
14#include <list>
15
16// FORWARD DECLARATION //
17template<class T> class tArray;
18
19
20//! an enumerator fot the different Model Types.
21/**
22   MODEL_DISPLAY_LIST means, that a DisplayList will be built out of the model. This model will be STATIC, meaning it cannot be changed after initialisation.
23   MODEL_VERTEX_ARRAY means, that a VertexArray will be built out of the model. This moel will be DYNAMIX, meaning that one can change the properties from outside of the model.
24 * @todo implement this stuff
25*/
26typedef enum MODEL_TYPE {
27  MODEL_DISPLAY_LIST,
28  MODEL_VERTEX_ARRAY
29};
30
31
32// definition of different modes for setting up Faces
33#define VERTEX 0       //!< If Faces are created WITH Vertex-Coordinate
34#define NORMAL 1       //!< If Faces are created WITH Normals (otherwise autocalculate)
35#define TEXCOORD 2     //!< If Faces are created WITH TextureCoordinate
36
37//! an enumerator for VERTEX_FORMAT
38typedef enum VERTEX_FORMAT {
39  VERTEX_ONLY = VERTEX,
40  VERTEX_NORMAL = NORMAL,
41  VERTEX_TEXCOORD = TEXCOORD,
42  VERTEX_TEXCOORD_NORMAL = NORMAL | TEXCOORD
43};
44
45////////////////////
46/// SUB-ELEMENTS ///
47////////////////////
48//! This is the placeholder of one Vertex beloning to a Face.
49class ModelFaceElement
50{
51 public:
52  ModelFaceElement();
53  ~ModelFaceElement();
54
55  int                 vertexNumber;         //!< The number of the Vertex out of the Array* vertices, this vertex points to.
56  int                 normalNumber;         //!< The number of the Normal out of the Array* normals, this vertex points to.
57  int                 texCoordNumber;       //!< The number of the textureCoordinate out of the Array* vTexture, this vertex points to.
58
59  ModelFaceElement*   next;                 //!< Point to the next FaceElement in this List.
60};
61
62//! This is the placeholder of a Face belonging to a Group of Faces.
63class ModelFace
64{
65 public:
66  ModelFace();
67  ~ModelFace();
68
69  unsigned int        vertexCount;     //!< The Count of vertices this Face has.
70  ModelFaceElement*   firstElem;       //!< Points to the first Vertex (FaceElement) of this Face.
71  Material*           material;        //!< The Material to use.
72
73  ModelFace*          next;            //!< Pointer to the next Face.
74};
75
76//! Group to handle multiple Models per obj-file.
77class ModelGroup
78{
79 public:
80  ModelGroup();
81  ~ModelGroup();
82
83  void cleanup();
84
85  char*        name;           //!< the Name of the Group. this is an identifier, that can be accessed via the draw (char* name) function.
86  GLubyte*     indices;        //!< The indices of the Groups. Needed for vertex-arrays
87  GLuint       listNumber;     //!< The number of the GL-List this Group gets.
88  ModelFace*   firstFace;      //!< The first Face in this group.
89  ModelFace*   currentFace;    //!< The current Face in this Group (the one we are currently working with.)
90  int          faceMode;       //!< The Mode the Face is in: initially -1, 0 for FaceList opened, 1 for Material,  3 for triangle, 4 for Quad, 5+ for Poly @todo ENUM...
91  int          faceCount;      //!< The Number of Faces this Group holds.
92
93  ModelGroup*  next;           //!< Pointer to the next Group.
94};
95
96struct ModelMaterial
97{
98  Material* material;
99  bool external;
100};
101
102/////////////
103/// MODEL ///
104/////////////
105//! Class that handles 3D-Models. it can also read them in and display them.
106class Model : public AbstractModel
107{
108 public:
109  Model(const char* modelName = NULL, MODEL_TYPE type = MODEL_DISPLAY_LIST);
110  virtual ~Model();
111
112  void draw() const;
113  void draw(int groupNumber) const;
114  void draw(char* groupName) const;
115
116  void rebuild();
117
118  /** @returns Count of the Models (Groups) in this File */
119  inline int getGroupCount() const { return this->groupCount; };
120
121  /** @returns a Pointer to the Vertex-Array, if it was deleted it returns NULL */
122  inline const GLfloat* getVertexArray() const { return this->vertices->getArray(); };
123  /** @returns the VertexCount of this Model */
124  inline unsigned int getVertexCount() const { return this->vertexCount; };
125
126  /** @returns a Pointer to the Normals-Array, if it was deleted it returns NULL */
127  inline const GLfloat* getNormalsArray() const { return this->normals->getArray(); };
128  /** @returns the NormalsCount of this Model */
129  inline unsigned int getNormalsCount() const { return this->normalCount; };
130
131  /** @returns a Pointer to the TexCoord-Array, if it was deleted it returns NULL */
132  inline const GLfloat* getTexCoordArray() const { return this->vTexture->getArray(); };
133  /** @returns the TexCoord-Count of this Model */
134  inline unsigned int getTexCoordCount() const { return this->texCoordCount; };
135
136  /** @returns the Count of Faces of this Model */
137  inline unsigned int getFaceCount() const { return this->faceCount; };
138
139
140  Material* addMaterial(Material* material);
141  Material* addMaterial(const char* materialName);
142
143  bool addGroup(const char* groupString);
144  bool addVertex(const char* vertexString);
145  bool addVertex(float x, float y, float z);
146  bool addFace(const char* faceString);
147  bool addFace(int faceElemCount, VERTEX_FORMAT type, ...);
148  bool addVertexNormal(const char* normalString);
149  bool addVertexNormal(float x, float y, float z);
150  bool addVertexTexture(const char* vTextureString);
151  bool addVertexTexture(float u, float v);
152  bool setMaterial(const char* mtlString);
153  bool setMaterial(Material* mtl);
154  void finalize();
155
156
157 protected:
158  void cubeModel();
159
160  Material* findMaterialByName(const char* materialName);
161
162
163 protected:
164  float            scaleFactor;     //!< The Factor with which the Model should be scaled. @todo maybe one wants to scale the Model after Initialisation
165
166 private:
167  bool buildVertexNormals();
168
169  bool importToDisplayList();
170  bool buildTriangleList();
171  bool addGLElement(ModelFaceElement* elem);
172
173  bool importToVertexArray();
174
175  bool deleteArrays();
176  bool cleanup();
177
178 private:
179  MODEL_TYPE                 type;            //!< A type for the Model
180  bool                       finalized;       //!< Sets the Object to be finalized.
181
182  unsigned int               vertexCount;     //!< A modelwide Counter for vertices.
183  unsigned int               normalCount;     //!< A modelwide Counter for the normals.
184  unsigned int               texCoordCount;   //!< A modelwide Counter for the texCoord.
185  unsigned int               faceCount;       //!< A modelwide Counter for the faces
186  unsigned int               triangleCount;   //!< Number of triangles >= faceCount
187  tArray<GLfloat>*           vertices;        //!< The Array that handles the Vertices.
188  tArray<GLfloat>*           normals;         //!< The Array that handles the Normals.
189  tArray<GLfloat>*           vTexture;        //!< The Array that handles the VertexTextureCoordinates.
190  sTriangleExt*              triangles;       //!< The Array of triangles in the abstract_model.h style
191
192  ModelGroup*                firstGroup;      //!< The first of all groups.
193  ModelGroup*                currentGroup;    //!< The currentGroup. this is the one we will work with.
194  int                        groupCount;      //!< The Count of Groups.
195
196  std::list<ModelMaterial*>  materialList;    //!< A list for all the Materials in this Model
197};
198
199#endif
Note: See TracBrowser for help on using the repository browser.