assimp/code/M3Importer.h

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