1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
|
/* Project nGenEx
Destroyer Studios LLC
Copyright © 1997-2004. All Rights Reserved.
SUBSYSTEM: nGenEx.lib
FILE: M3DS.h
AUTHOR: John DiCamillo
OVERVIEW
========
Window class
*/
// parts copyright (c) 2001-2002 Lev Povalahev
#ifndef M3DS_H
#define M3DS_H
#include "List.h"
// +--------------------------------------------------------------------+
struct Chunk
{
WORD id;
DWORD len;
BYTE* start;
List<Chunk> chunks;
};
// +--------------------------------------------------------------------+
struct LTriangle
{
WORD a,b,c;
};
struct LTriangle2
{
Point vertices[3];
Vec3 vertexNormals[3];
LVector2 textureCoords[3];
Vec3 faceNormal;
DWORD materialId;
};
struct TextureMap
{
char fname[256];
float strength;
float u_scale;
float v_scale;
float u_offset;
float v_offset;
float angle;
};
// +--------------------------------------------------------------------+
class LObject
{
public:
LObject();
virtual ~LObject();
virtual const char* GetName();
virtual bool IsObject(const const char* name);
protected:
Text name;
};
// +--------------------------------------------------------------------+
class LMaterial : public LObject
{
public:
LMaterial();
virtual ~LMaterial();
DWORD GetID();
TextureMap& GetTextureMap1();
TextureMap& GetTextureMap2();
TextureMap& GetOpacityMap();
TextureMap& GetSpecularMap();
TextureMap& GetBumpMap();
TextureMap& GetReflectionMap();
ColorValue GetAmbientColor();
ColorValue GetDiffuseColor();
ColorValue GetSpecularColor();
float GetShininess();
float GetTransparency();
DWORD GetShadingType();
// this methods should not be used by the "user", they're used internally to fill the class
// with valid data when reading from file. If you're about to add an importer for another format you'LL
// have to use these methods
void SetID(DWORD value);
void SetAmbientColor(const ColorValue &color);
void SetDiffuseColor(const ColorValue &color);
void SetSpecularColor(const ColorValue &color);
void SetShininess(float value);
void SetTransparency(float value);
void SetShadingType(DWORD shading);
protected:
int id;
TextureMap texMap1;
TextureMap texMap2;
TextureMap opacMap;
TextureMap refTextureMap;
TextureMap bumpMap;
TextureMap specMap;
ColorValue ambient;
ColorValue diffuse;
ColorValue specular;
float shininess;
float transparency;
DWORD shading;
};
// +--------------------------------------------------------------------+
class LMesh : public LObject
{
public:
LMesh();
virtual ~LMesh();
void Clear();
DWORD GetVertexCount();
void SetVertexArraySize(DWORD value);
DWORD GetTriangleCount();
void SetTriangleArraySize(DWORD value);
// returns given vertex
const LVector4& GetVertex(DWORD index);
// returns the given normal
const LVector3& GetNormal(DWORD index);
// returns the given texture coordinates vector
const LVector2& GetUV(DWORD index);
// returns the pointer to the array of tangents
const LVector3& GetTangent(DWORD index);
// returns the pointer to the array of binormals
const LVector3& GetBinormal(DWORD index);
// sets the vertex at a given index to "vec" - for internal use
void SetVertex(const LVector4 &vec, DWORD index);
// sets the normal at a given index to "vec" - for internal use
void SetNormal(const LVector3 &vec, DWORD index);
// sets the texture coordinates vector at a given index to "vec" - for internal use
void SetUV(const LVector2 &vec, DWORD index);
// sets the tangent at a given index to "vec" - for internal use
void SetTangent(const LVector3 &vec, DWORD index);
// sets the binormal at a given index to "vec" - for internal use
void SetBinormal(const LVector3 &vec, DWORD index);
// returns the triangle with a given index
const LTriangle& GetTriangle(DWORD index);
// returns the triangle with a given index, see LTriangle2 structure description
LTriangle2 GetTriangle2(DWORD index);
// returns the mesh matrix, should be identity matrix after loading
LMatrix4 GetMatrix();
// sets the mesh matrix to a given matrix - for internal use
void SetMatrix(LMatrix4 m);
// optimizises the mesh using a given optimization level
void Optimize(LOptimizationLevel value);
// sets an internal triangle structure with index "index" - for internal use only
void SetTri(const LTri &tri, DWORD index);
// returns the pointer to the internal triangle structure - for internal use only
LTri& GetTri(DWORD index);
// returns the material id with a given index for the mesh
DWORD GetMaterial(DWORD index);
// adds a material to the mesh and returns its index - for internal use
DWORD AddMaterial(DWORD id);
// returns the number of materials used in the mesh
DWORD GetMaterialCount();
protected:
// the vertices, normals, etc.
List<LVector4> vertices;
List<LVector3> normals;
List<LVector3> binormals;
List<LVector3> tangents;
List<LVector2> uv;
// triangles
List<LTriangle> triangles;
//used internally
List<LTri> tris;
// the transformation matrix.
Matrix matrix;
// the material ID array
List<DWORD> materials;
// calculates the normals, either using the smoothing groups information or not
void CalcNormals(bool useSmoothingGroups);
// calculates the texture(tangent) space for each vertex
void CalcTextureSpace();
// transforms the vertices by the mesh matrix
void TransformVertices();
};
//------------------------------------------------
class LImporter
{
public:
// the default constructor
LImporter();
// the destructor
virtual ~LImporter();
// reads the model from a file, must be overriden by the child classes
virtual bool LoadFile(const char *filename) = 0;
// returns the number of meshes in the scene
DWORD GetMeshCount();
// returns the number of lights in the scene
DWORD GetLightCount();
// returns the number of materials in the scene
DWORD GetMaterialCount();
// returns a pointer to a mesh
LMesh& GetMesh(DWORD index);
// returns a pointer to a light at a given index
LLight& GetLight(DWORD index);
// returns the pointer to the material
LMaterial& GetMaterial(DWORD index);
// returns the pointer to the material with a given name, or NULL if the material was not found
LMaterial* FindMaterial(const Text &name);
// returns the pointer to the mesh with a given name, or NULL if the mesh with such name
// is not present in the scene
LMesh* FindMesh(const Text &name);
// returns the pointer to the light with a given name, or NULL if not found
LLight* FindLight(const Text &name);
// sets the optimization level to a given value
void SetOptimizationLevel(LOptimizationLevel value);
// returns the current optimization level
LOptimizationLevel GetOptimizationLevel();
protected:
// the lights found in the scene
List<LLight> lights;
// triangular meshes
List<LMesh> meshes;
// the materials in the scene
List<LMaterial> materials;
// level of optimization to perform on the meshes
LOptimizationLevel optLevel;
// clears all data.
virtual void Clear();
};
//------------------------------------------------
class L3DS : public LImporter
{
public:
// the default contructor
L3DS();
// constructs the object and loads the file
L3DS(const char *filename);
// destructor
virtual ~L3DS();
// load 3ds file
virtual bool LoadFile(const char *filename);
protected:
// used internally for reading
char objName[100];
// true if end of file is reached
bool eof;
// buffer for loading, used for speedup
unsigned char *buffer;
// the size of the buffer
DWORD bufferSize;
// the current cursor position in the buffer
DWORD pos;
// reads a short value from the buffer
short ReadShort();
// reads an int value from the buffer
int ReadInt();
// reads a char from the buffer
char ReadChar();
//reada a floatvalue from the buffer
float ReadFloat();
//reads an unsigned byte from the buffer
byte ReadByte();
//reads an asciiz string
int ReadASCIIZ(char *buf, int max_count);
// seek wihtin the buffer
void Seek(int offset, int origin);
// returns the position of the cursor
DWORD Pos();
// read the chunk and return it.
LChunk ReadChunk();
// read until given chunk is found
bool FindChunk(LChunk &target, const LChunk &parent);
// skip to the end of chunk "chunk"
void SkipChunk(const LChunk &chunk);
// goes to the beginning of the data in teh given chunk
void GotoChunk(const LChunk &chunk);
// the function read the color chunk (any of the color chunks)
ColorValue ReadColor(const LChunk &chunk);
// the function that read the percentage chunk and returns a float from 0 to 1
float ReadPercentage(const LChunk &chunk);
// this is where 3ds file is being read
bool Read3DS();
// read a light chunk
void ReadLight(const LChunk &parent);
// read a trimesh chunk
void ReadMesh(const LChunk &parent);
// reads the face list, face materials, smoothing groups... and fill rthe information into the mesh
void ReadFaceList(const LChunk &chunk, LMesh &mesh);
// reads the material
void ReadMaterial(const LChunk &parent);
// reads the map info and fills the given map with this information
void ReadMap(const LChunk &chunk, TextureMap& map);
// reads keyframer data of the OBJECT_NODE_TAG chunk
void ReadKeyframeData(const LChunk &parent);
// reads the keyheader structure from the current offset and returns the frame number
long ReadKeyheader();
};
//---------------------------------------------------------
#endif
|