726 lines
16 KiB
C++
726 lines
16 KiB
C++
/*
|
|
Open Asset Import Library (ASSIMP)
|
|
----------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2010, ASSIMP Development Team
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the
|
|
following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the ASSIMP team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the ASSIMP Development Team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
----------------------------------------------------------------------
|
|
*/
|
|
#ifndef AI_M3LOADER_H_INCLUDED
|
|
#define AI_M3LOADER_H_INCLUDED
|
|
|
|
#include <vector>
|
|
|
|
namespace Assimp {
|
|
|
|
namespace M3 {
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// The following data definitions are from http://code.google.com/p/libm3/, many thanks for that
|
|
// help.
|
|
// ------------------------------------------------------------------------------------------------
|
|
typedef unsigned char uint8;
|
|
typedef char int8;
|
|
typedef unsigned short uint16;
|
|
typedef short int16;
|
|
typedef unsigned int uint32;
|
|
typedef int int32;
|
|
|
|
class Vec3D
|
|
{
|
|
public:
|
|
float x,y,z;
|
|
|
|
Vec3D(float x0 = 0.0f, float y0 = 0.0f, float z0 = 0.0f) : x(x0), y(y0), z(z0) {}
|
|
|
|
Vec3D(const Vec3D& v) : x(v.x), y(v.y), z(v.z) {}
|
|
|
|
void reset()
|
|
{
|
|
x = y = z = 0.0f;
|
|
}
|
|
|
|
Vec3D& operator= (const Vec3D &v)
|
|
{
|
|
x = v.x;
|
|
y = v.y;
|
|
z = v.z;
|
|
return *this;
|
|
}
|
|
|
|
Vec3D operator+ (const Vec3D &v) const
|
|
{
|
|
Vec3D r(x+v.x,y+v.y,z+v.z);
|
|
return r;
|
|
}
|
|
|
|
Vec3D operator- (const Vec3D &v) const
|
|
{
|
|
Vec3D r(x-v.x,y-v.y,z-v.z);
|
|
return r;
|
|
}
|
|
|
|
float operator* (const Vec3D &v) const
|
|
{
|
|
return x*v.x + y*v.y + z*v.z;
|
|
}
|
|
|
|
Vec3D operator* (float d) const
|
|
{
|
|
Vec3D r(x*d,y*d,z*d);
|
|
return r;
|
|
}
|
|
|
|
Vec3D operator/ (float d) const
|
|
{
|
|
Vec3D r(x/d,y/d,z/d);
|
|
return r;
|
|
}
|
|
|
|
friend Vec3D operator* (float d, const Vec3D& v)
|
|
{
|
|
return v * d;
|
|
}
|
|
|
|
// Cross Product
|
|
Vec3D operator% (const Vec3D &v) const
|
|
{
|
|
Vec3D r(y*v.z-z*v.y, z*v.x-x*v.z, x*v.y-y*v.x);
|
|
return r;
|
|
}
|
|
|
|
Vec3D& operator+= (const Vec3D &v)
|
|
{
|
|
x += v.x;
|
|
y += v.y;
|
|
z += v.z;
|
|
return *this;
|
|
}
|
|
|
|
Vec3D& operator-= (const Vec3D &v)
|
|
{
|
|
x -= v.x;
|
|
y -= v.y;
|
|
z -= v.z;
|
|
return *this;
|
|
}
|
|
|
|
Vec3D& operator*= (float d)
|
|
{
|
|
x *= d;
|
|
y *= d;
|
|
z *= d;
|
|
return *this;
|
|
}
|
|
|
|
float lengthSquared() const
|
|
{
|
|
return x*x+y*y+z*z;
|
|
}
|
|
|
|
float length() const
|
|
{
|
|
return sqrtf(x*x+y*y+z*z);
|
|
}
|
|
|
|
Vec3D& normalize()
|
|
{
|
|
this->operator*= (1.0f/length());
|
|
return *this;
|
|
}
|
|
|
|
Vec3D operator~ () const
|
|
{
|
|
Vec3D r(*this);
|
|
r.normalize();
|
|
return r;
|
|
}
|
|
|
|
operator float*()
|
|
{
|
|
return (float*)this;
|
|
}
|
|
};
|
|
|
|
|
|
class Vec2D
|
|
{
|
|
public:
|
|
float x,y;
|
|
|
|
Vec2D(float x0 = 0.0f, float y0 = 0.0f) : x(x0), y(y0) {}
|
|
|
|
Vec2D(const Vec2D& v) : x(v.x), y(v.y) {}
|
|
|
|
Vec2D& operator= (const Vec2D &v)
|
|
{
|
|
x = v.x;
|
|
y = v.y;
|
|
return *this;
|
|
}
|
|
|
|
Vec2D operator+ (const Vec2D &v) const
|
|
{
|
|
Vec2D r(x+v.x,y+v.y);
|
|
return r;
|
|
}
|
|
|
|
Vec2D operator- (const Vec2D &v) const
|
|
{
|
|
Vec2D r(x-v.x,y-v.y);
|
|
return r;
|
|
}
|
|
|
|
float operator* (const Vec2D &v) const
|
|
{
|
|
return x*v.x + y*v.y;
|
|
}
|
|
|
|
Vec2D operator* (float d) const
|
|
{
|
|
Vec2D r(x*d,y*d);
|
|
return r;
|
|
}
|
|
|
|
friend Vec2D operator* (float d, const Vec2D& v)
|
|
{
|
|
return v * d;
|
|
}
|
|
|
|
Vec2D& operator+= (const Vec2D &v)
|
|
{
|
|
x += v.x;
|
|
y += v.y;
|
|
return *this;
|
|
}
|
|
|
|
Vec2D& operator-= (const Vec2D &v)
|
|
{
|
|
x -= v.x;
|
|
y -= v.y;
|
|
return *this;
|
|
}
|
|
|
|
Vec2D& operator*= (float d)
|
|
{
|
|
x *= d;
|
|
y *= d;
|
|
return *this;
|
|
}
|
|
|
|
float lengthSquared() const
|
|
{
|
|
return x*x+y*y;
|
|
}
|
|
|
|
float length() const
|
|
{
|
|
return sqrtf(x*x+y*y);
|
|
}
|
|
|
|
Vec2D& normalize()
|
|
{
|
|
this->operator*= (1.0f/length());
|
|
return *this;
|
|
}
|
|
|
|
Vec2D operator~ () const
|
|
{
|
|
Vec2D r(*this);
|
|
r.normalize();
|
|
return r;
|
|
}
|
|
|
|
operator float*()
|
|
{
|
|
return (float*)this;
|
|
}
|
|
};
|
|
|
|
inline
|
|
void rotate(float x0, float y0, float *x, float *y, float angle)
|
|
{
|
|
float xa = *x - x0, ya = *y - y0;
|
|
*x = xa*cosf(angle) - ya*sinf(angle) + x0;
|
|
*y = xa*sinf(angle) + ya*cosf(angle) + y0;
|
|
}
|
|
|
|
struct Reference
|
|
{
|
|
uint32 nEntries; // Code 0x00
|
|
uint32 ref; // Code 0x04
|
|
};
|
|
|
|
struct ReferenceEntry
|
|
{
|
|
char id[ 4 ]; // Code 0x00
|
|
uint32 offset; // Code 0x04
|
|
uint32 nEntries; // Code 0x08
|
|
uint32 type; // Code 0x0C
|
|
};
|
|
|
|
struct MD33
|
|
{
|
|
char id[4]; // Code 0x00
|
|
uint32 ofsRefs; // Code 0x04
|
|
uint32 nRefs; // Code 0x08
|
|
Reference MODL; // Code 0x0C
|
|
};
|
|
|
|
enum ModelType
|
|
{
|
|
Type1 = 20,
|
|
Type2 = 23
|
|
};
|
|
|
|
enum VertexFormat
|
|
{
|
|
Vertex_Standard,
|
|
Vertex_Extended
|
|
};
|
|
|
|
struct MODL23
|
|
{
|
|
Reference name; // Code 0x00
|
|
uint32 version; // Code 0x08
|
|
Reference sequenceHeader; // Code 0x0C
|
|
Reference sequenceData; // Code 0x14
|
|
Reference sequenceLookup; // Code 0x1C
|
|
uint32 d2; // Code 0x24
|
|
uint32 d3; // Code 0x28
|
|
uint32 d4; // Code 0x2C
|
|
Reference STS; // Code 0x30
|
|
Reference bones; // Code 0x38
|
|
uint32 d5; // Code 0x40
|
|
uint32 flags; // Code 0x44
|
|
Reference vertexData; // Code 0x48
|
|
Reference views; // Code 0x50
|
|
Reference B; // Code 0x58
|
|
|
|
Vec3D extents[2]; // Code 0x60
|
|
float radius; // Code 0x78
|
|
|
|
uint32 d7; // Code 0x7C
|
|
uint32 d8; // Code 0x80
|
|
uint32 d9; // Code 0x84
|
|
uint32 d10; // Code 0x88
|
|
uint32 d11; // Code 0x8C
|
|
uint32 d12; // Code 0x90
|
|
uint32 d13; // Code 0x94
|
|
uint32 d14; // Code 0x98
|
|
uint32 d15; // Code 0x9C
|
|
uint32 d16; // Code 0xA0
|
|
uint32 d17; // Code 0xA4
|
|
uint32 d18; // Code 0xA8
|
|
uint32 d19; // Code 0xAC
|
|
|
|
Reference attachments; // Code 0xB0
|
|
Reference attachmentLookup; // Code 0xB8
|
|
Reference lights; // Code 0xC0
|
|
Reference SHBX; // Code 0xC8
|
|
Reference cameras; // Code 0xD0
|
|
Reference D; // Code 0xD8
|
|
Reference materialLookup; // Code 0xE0
|
|
Reference materials; // Code 0xE8
|
|
Reference DIS; // Code 0xF0
|
|
Reference CMP; // Code 0xF8
|
|
|
|
Reference TER; // Code 0x10
|
|
Reference VOL; // Code 0x10
|
|
uint32 d21; // Code 0x11
|
|
uint32 d22; // Code 0x11
|
|
Reference CREP; // Code 0x11
|
|
Reference PAR; // Code 0x12
|
|
Reference PARC; // Code 0x12
|
|
Reference RIB; // Code 0x13
|
|
Reference PROJ; // Code 0x13
|
|
Reference FOR; // Code 0x14
|
|
Reference WRP; // Code 0x14
|
|
uint32 d24; // Code 0x15
|
|
uint32 d25; // Code 0x15
|
|
Reference PHRB; // Code 0x15
|
|
uint32 d27; // Code 0x16
|
|
uint32 d28; // Code 0x16
|
|
uint32 d29; // Code 0x16
|
|
uint32 d30; // Code 0x16
|
|
uint32 d32; // Code 0x17
|
|
uint32 d33; // Code 0x17
|
|
Reference IKJT; // Code 0x17
|
|
uint32 d35; // Code 0x18
|
|
uint32 d36; // Code 0x18
|
|
Reference PATU; // Code 0x18
|
|
Reference TRGD; // Code 0x19
|
|
Reference IREF; // Code 0x19
|
|
Reference E; // Code 0x1A
|
|
float matrix[4][4]; // Code 0x1A
|
|
Vec3D extent[2]; // Code 0x1E
|
|
float rad; // Code 0x20
|
|
Reference SSGS; // Code 0x20
|
|
Reference ATVL; // Code 0x20
|
|
uint32 d61; // Code 0x21
|
|
Reference F; // uint16, Code6 0x21
|
|
Reference G; // uint16, Code 0x21
|
|
Reference BBSC; // Code 0x22
|
|
Reference TMD; // Code 0x22
|
|
uint32 d62; // Code 0x23
|
|
uint32 d63; // Code 0x23
|
|
uint32 d64; // Code 0x23
|
|
};
|
|
|
|
struct MODL20
|
|
{
|
|
Reference name; // Code 0x00
|
|
uint32 version; // Code 0x08
|
|
Reference sequenceHeader; // Code 0x0C
|
|
Reference sequenceData; // Code 0x14
|
|
Reference sequenceLookup; // Code 0x1C
|
|
uint32 d2; // Code 0x24
|
|
uint32 d3; // Code 0x28
|
|
uint32 d4; // Code 0x2C
|
|
Reference STS; // Code 0x30
|
|
Reference bones; // Code 0x38
|
|
uint32 d5; // Code 0x44
|
|
uint32 flags; // Code 0x44
|
|
Reference vertexData; // uint8, Code 0x48
|
|
Reference views; // Code 0x50
|
|
Reference B; // uint16, Code 0x58
|
|
|
|
Vec3D extents[2]; // Code 0x60
|
|
float radius; // Code 0x78
|
|
|
|
uint32 d7; // Code 0x7C
|
|
uint32 d8; // Code 0x80
|
|
uint32 d9; // Code 0x84
|
|
uint32 d10; // Code 0x88
|
|
uint32 d11; // Code 0x8C
|
|
uint32 d12; // Code 0x90
|
|
uint32 d13; // Code 0x94
|
|
uint32 d14; // Code 0x98
|
|
uint32 d15; // Code 0x9C
|
|
uint32 d16; // Code 0xA0
|
|
uint32 d17; // Code 0xA4
|
|
uint32 d18; // Code 0xA8
|
|
uint32 d19; // Code 0xAC
|
|
|
|
Reference attachments; // Code 0xB0
|
|
Reference attachmentLookup; // uint16, Code 0xB8
|
|
Reference lights; // Code 0xC0
|
|
Reference cameras; // Code 0xC8
|
|
Reference D; // uint16, Code 0xD0
|
|
Reference materialLookup; // Code 0xD8
|
|
Reference materials; // Code 0xE0
|
|
Reference DIS; // Code 0xE8
|
|
Reference CMP; // Code 0xF0
|
|
Reference TER; // Code 0xF8
|
|
|
|
uint32 d20; // Code 0x10
|
|
uint32 d21; // Code 0x10
|
|
uint32 d22; // Code 0x10
|
|
uint32 d23; // Code 0x10
|
|
Reference CREP; // Code 0x11
|
|
Reference PAR; // Code 0x11
|
|
Reference PARC; // Code 0x12
|
|
Reference RIB; // Code 0x12
|
|
Reference PROJ; // Code 0x13
|
|
Reference FOR; // Code 0x13
|
|
uint32 d25; // Code 0x14
|
|
uint32 d26; // Code 0x14
|
|
uint32 d27; // Code 0x14
|
|
uint32 d28; // Code 0x14
|
|
Reference PHRB; // Code 0x15
|
|
uint32 d30; // Code 0x15
|
|
uint32 d31; // Code 0x15
|
|
uint32 d32; // Code 0x16
|
|
uint32 d33; // Code 0x16
|
|
uint32 d34; // Code 0x16
|
|
uint32 d35; // Code 0x16
|
|
Reference IKJT; // Code 0x17
|
|
uint32 d36; // Code 0x17
|
|
uint32 d37; // Code 0x17
|
|
Reference PATU; // Code 0x18
|
|
Reference TRGD; // Code 0x18
|
|
Reference IREF; // Code 0x19
|
|
Reference E; // int32, Code 0x19
|
|
|
|
float matrix[4][4]; // Code 0x1A
|
|
Vec3D extent[2]; // Code 0x1E
|
|
float rad; // Code 0x1F
|
|
|
|
Reference SSGS; // Code 0x1F
|
|
uint32 d38; // Code 0x20
|
|
uint32 d39; // Code 0x20
|
|
Reference BBSC; // Code 0x20
|
|
|
|
uint32 d40; // Code 0x21
|
|
uint32 d41; // Code 0x21
|
|
uint32 d42; // Code 0x21
|
|
uint32 d43; // Code 0x22
|
|
uint32 d44; // Code 0x22
|
|
};
|
|
|
|
struct BONE
|
|
{
|
|
int32 d1; // Keybone?
|
|
Reference name;
|
|
uint32 flags;
|
|
int16 parent;
|
|
int16 s1;
|
|
|
|
float floats[ 34 ];
|
|
};
|
|
|
|
struct VertexExt // 36 byte
|
|
{
|
|
Vec3D pos;
|
|
uint8 boneWeight[ 4 ];
|
|
uint8 boneIndex[ 4 ];
|
|
uint8 normal[ 4 ]; //normal_x = (float)normal[0]/255.0f...
|
|
int16 uv[ 2 ];
|
|
uint32 d1;
|
|
uint8 tangent[ 4 ];
|
|
};
|
|
|
|
struct Vertex // 32 byte
|
|
{
|
|
Vec3D pos;
|
|
uint8 boneWeight[4];
|
|
uint8 boneIndex[4];
|
|
uint8 normal[4]; //normal_x = (float)normal[0]/255.0f...
|
|
int16 uv[2];
|
|
uint8 tangent[4];
|
|
};
|
|
|
|
struct MATM
|
|
{
|
|
uint32 d1;
|
|
uint32 d2; // Index into MAT-table?
|
|
};
|
|
|
|
struct MAT
|
|
{
|
|
Reference name;
|
|
int ukn1[ 8 ];
|
|
float x, y; //always 1.0f
|
|
Reference layers[13];
|
|
int ukn2[15];
|
|
};
|
|
|
|
struct LAYR
|
|
{
|
|
int unk;
|
|
Reference name;
|
|
float unk2[85];
|
|
};
|
|
|
|
struct DIV
|
|
{
|
|
Reference faces; // Code 0x00
|
|
Reference regions; // Code 0x08
|
|
Reference BAT; // Code 0x10
|
|
Reference MSEC; // Code 0x18
|
|
};
|
|
|
|
struct Region
|
|
{
|
|
uint32 unk;
|
|
uint16 ofsVertices;
|
|
uint16 nVertices;
|
|
uint32 ofsIndices;
|
|
uint32 nIndices; // reference into DIV.faces
|
|
uint8 unknown[12];
|
|
};
|
|
|
|
struct CAM
|
|
{
|
|
int32 d1; // Code 0x00
|
|
Reference name; // Code 0x04
|
|
uint16 flags1; // Code 0x0C
|
|
uint16 flags2; // Code 0x0E
|
|
};
|
|
|
|
struct EVNT
|
|
{
|
|
Reference name; // Code 0x00
|
|
int16 unk1[4]; // Code 0x08
|
|
float matrix[4][4]; // Code 0x10
|
|
int32 unk2[4]; // Code 0x50
|
|
};
|
|
|
|
struct ATT
|
|
{
|
|
int32 unk; // Code 0x00
|
|
Reference name; // Code 0x04
|
|
int32 bone; // Code 0x0C
|
|
};
|
|
|
|
struct PHSH
|
|
{
|
|
float m[ 4 ][ 4 ];
|
|
float f1;
|
|
float f2;
|
|
Reference refs[ 5 ];
|
|
float f3;
|
|
};
|
|
|
|
struct SEQS
|
|
{
|
|
int32 d1; // Code 0x00
|
|
int32 d2; // Code 0x04
|
|
Reference name; // Code 0x08
|
|
int32 d3; // Code 0x10
|
|
uint32 length; // Code 0x14
|
|
int32 d4; // Code 0x18
|
|
uint32 flags; // Code 0x1C
|
|
int32 unk[5]; // Code 0x20
|
|
Vec3D extents[2]; // Code 0x34
|
|
float radius; // Code 0x4C
|
|
int32 d5; // Code 0x50
|
|
int32 d6; // Code 0x54
|
|
};
|
|
|
|
struct STC
|
|
{
|
|
Reference name; // Code 0x00
|
|
uint16 s1; // Code 0x08
|
|
uint16 s2; // Code 0x0A
|
|
uint16 s3; // Code 0x0C
|
|
uint16 s4; // Code 0x0E
|
|
Reference unk2; // uint32 // Code 0x12
|
|
Reference unk3; // uint32 // Code 0x1A
|
|
uint32 d3; // Code 0x22
|
|
Reference evt; // Code 0x24
|
|
Reference unk4[11]; // Seems to be transformation data // Code 0x2C
|
|
Reference bnds; // Code 0x84
|
|
};
|
|
|
|
struct STS
|
|
{
|
|
Reference unk1; // uint32 // Code 0x00
|
|
int32 unk[3]; // Code 0x08
|
|
int16 s1; // Code 0x14
|
|
int16 s2; // Code 0x16
|
|
};
|
|
|
|
struct STG
|
|
{
|
|
Reference name; // Code 0x00
|
|
Reference stcID; // Code 0x08
|
|
};
|
|
|
|
struct SD
|
|
{
|
|
Reference timeline; // Code 0x00
|
|
uint32 flags; // Code 0x08
|
|
uint32 length; // Code 0x0C
|
|
Reference data; // Code 0x10
|
|
};
|
|
|
|
struct BNDS
|
|
{
|
|
Vec3D extents1[2]; // Code 0x00
|
|
float radius1; // Code 0x18
|
|
Vec3D extents2[2]; // Code 0x1C
|
|
float radius2; // Code 0x34
|
|
};
|
|
|
|
struct VEC2
|
|
{
|
|
float x, y;
|
|
};
|
|
|
|
struct VEC3
|
|
{
|
|
float x, y, z;
|
|
};
|
|
|
|
struct VEC4
|
|
{
|
|
float x, y, z, w;
|
|
};
|
|
|
|
struct QUAT
|
|
{
|
|
float x, y, z, w;
|
|
};
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
/** Loader to import M3-models.
|
|
*/
|
|
// ------------------------------------------------------------------------------------------------
|
|
class M3Importer : public BaseImporter
|
|
{
|
|
friend class Importer;
|
|
|
|
public:
|
|
/// @brief The default constructor.
|
|
M3Importer();
|
|
|
|
/// @brief The destructor.
|
|
~M3Importer();
|
|
|
|
/// @brief Returns whether the class can handle the format of the given file.
|
|
/// @remark See BaseImporter::CanRead() for details.
|
|
bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig ) const;
|
|
|
|
private:
|
|
void GetExtensionList( std::set<std::string>& extensions );
|
|
void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler );
|
|
void convertToAssimp( const std::string& pFile, aiScene* pScene, DIV *pViews, Region *pRegions, uint16 *pFaces,
|
|
const std::vector<aiVector3D> &vertices, const std::vector<aiVector3D> &normals );
|
|
void createVertexData( aiMesh *pMesh, const std::vector<aiVector3D> &vertices, const std::vector<aiVector3D> &normals );
|
|
aiNode *createNode( aiNode *pParent );
|
|
template<typename T>
|
|
T* GetEntries( Reference ref );
|
|
|
|
private:
|
|
MD33 *m_pHead;
|
|
ReferenceEntry *m_pRefs;
|
|
std::vector<unsigned char> m_Buffer;
|
|
};
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
template<typename T>
|
|
inline
|
|
T* M3Importer::GetEntries( Reference ref )
|
|
{
|
|
return (T*) ( &m_Buffer[ 0 ] + m_pRefs[ ref.ref ].offset );
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
} // Namespace M3
|
|
} // Namespace Assimp
|
|
|
|
#endif // AI_M3LOADER_H_INCLUDED
|