523 lines
20 KiB
Python
523 lines
20 KiB
Python
#-*- coding: UTF-8 -*-
|
|
|
|
"""
|
|
All ASSIMP C-structures. See the Assimp-headers for all formats.
|
|
"""
|
|
|
|
from ctypes import POINTER, c_int, c_uint, c_char, c_float, Structure, c_char_p, c_double, c_ubyte
|
|
|
|
|
|
|
|
class STRING(Structure):
|
|
"""
|
|
Represents a String in ASSIMP.
|
|
"""
|
|
|
|
#Maximum length of a string. See "MAXLEN" in "aiTypes.h"
|
|
MAXLEN = 1024
|
|
|
|
_fields_ = [
|
|
#length of the string
|
|
("length", c_uint), #OK
|
|
|
|
#string data
|
|
("data", c_char*MAXLEN) #OK
|
|
]
|
|
|
|
|
|
|
|
class MATRIX4X4(Structure):
|
|
"""
|
|
ASSIMP's 4x4-matrix
|
|
"""
|
|
|
|
_fields_ = [
|
|
#all the fields
|
|
("a1", c_float), ("a2", c_float), ("a3", c_float), ("a4", c_float), #OK
|
|
("b1", c_float), ("b2", c_float), ("b3", c_float), ("b4", c_float), #OK
|
|
("c1", c_float), ("c2", c_float), ("c3", c_float), ("c4", c_float), #OK
|
|
("d1", c_float), ("d2", c_float), ("d3", c_float), ("d4", c_float), #OK
|
|
]
|
|
|
|
|
|
|
|
class NODE(Structure):
|
|
"""
|
|
A node in the imported hierarchy.
|
|
|
|
Each node has name, a parent node (except for the root node),
|
|
a transformation relative to its parent and possibly several child nodes.
|
|
Simple file formats don't support hierarchical structures, for these formats
|
|
the imported scene does consist of only a single root node with no childs.
|
|
"""
|
|
pass
|
|
|
|
NODE._fields_ = [
|
|
#The name of the node
|
|
("mName", STRING),
|
|
|
|
#The transformation relative to the node's parent.
|
|
("aiMatrix4x4", MATRIX4X4),
|
|
|
|
#Parent node. NULL if this node is the root node.
|
|
("mParent", POINTER(NODE)),
|
|
|
|
#The number of child nodes of this node.
|
|
("mNumChildren", c_uint),
|
|
|
|
#The child nodes of this node. NULL if mNumChildren is 0.
|
|
("mChildren", POINTER(POINTER(NODE))),
|
|
|
|
#The number of meshes of this node.
|
|
("mNumMeshes", c_uint),
|
|
|
|
#The meshes of this node. Each entry is an index into the mesh.
|
|
("mMeshes", POINTER(c_int))
|
|
]
|
|
|
|
|
|
class VECTOR3D(Structure):
|
|
"""
|
|
Represents a three-dimensional vector.
|
|
"""
|
|
|
|
_fields_ = [
|
|
("x", c_float),
|
|
("y", c_float),
|
|
("z", c_float)
|
|
]
|
|
|
|
|
|
class COLOR4D(Structure):
|
|
"""
|
|
Represents a color in Red-Green-Blue space including an alpha component.
|
|
"""
|
|
|
|
_fields_ = [
|
|
("r", c_float),
|
|
("g", c_float),
|
|
("b", c_float),
|
|
("a", c_float)
|
|
]
|
|
|
|
|
|
class FACE(Structure):
|
|
"""
|
|
A single face in a mesh, referring to multiple vertices.
|
|
If mNumIndices is 3, the face is a triangle,
|
|
for mNumIndices > 3 it's a polygon.
|
|
Point and line primitives are rarely used and are NOT supported. However,
|
|
a load could pass them as degenerated triangles.
|
|
"""
|
|
|
|
_fields_ = [
|
|
#Number of indices defining this face. 3 for a triangle, >3 for polygon
|
|
("mNumIndices", c_uint), #OK
|
|
|
|
#Pointer to the indices array. Size of the array is given in numIndices.
|
|
("mIndices", POINTER(c_uint)) #OK
|
|
]
|
|
|
|
|
|
class VERTEXWEIGHT(Structure):
|
|
"""
|
|
A single influence of a bone on a vertex.
|
|
"""
|
|
|
|
_fields_ = [
|
|
#Index of the vertex which is influenced by the bone.
|
|
("mVertexId", c_uint), #OK
|
|
|
|
#The strength of the influence in the range (0...1).
|
|
#The influence from all bones at one vertex amounts to 1.
|
|
("mWeight", c_float) #OK
|
|
]
|
|
|
|
|
|
class BONE(Structure):
|
|
"""
|
|
A single bone of a mesh. A bone has a name by which it can be found
|
|
in the frame hierarchy and by which it can be addressed by animations.
|
|
In addition it has a number of influences on vertices.
|
|
"""
|
|
|
|
_fields_ = [
|
|
#The name of the bone.
|
|
("mName", STRING), #OK
|
|
|
|
#The number of vertices affected by this bone
|
|
("mNumWeights", c_uint), #OK
|
|
|
|
#The vertices affected by this bone
|
|
("mWeights", POINTER(VERTEXWEIGHT)), #OK
|
|
|
|
#Matrix that transforms from mesh space to bone space in bind pose
|
|
("mOffsetMatrix", MATRIX4X4) #OK
|
|
]
|
|
|
|
|
|
class MESH(Structure):
|
|
"""
|
|
A mesh represents a geometry or model with a single material.
|
|
It usually consists of a number of vertices and a series of primitives/faces
|
|
referencing the vertices. In addition there might be a series of bones, each
|
|
of them addressing a number of vertices with a certain weight. Vertex data
|
|
is presented in channels with each channel containing a single per-vertex
|
|
information such as a set of texture coords or a normal vector.
|
|
If a data pointer is non-null, the corresponding data stream is present.
|
|
|
|
A Mesh uses only a single material which is referenced by a material ID.
|
|
"""
|
|
|
|
#Maximum number of texture coord sets (UV(W) channels) per mesh.
|
|
#See "AI_MAX_NUMBER_OF_TEXTURECOORDS" in "aiMesh.h" for further
|
|
#information.
|
|
AI_MAX_NUMBER_OF_TEXTURECOORDS = 4
|
|
|
|
|
|
#Maximum number of vertex color sets per mesh.
|
|
#Normally: Diffuse, specular, ambient and emissive
|
|
#However one could use the vertex color sets for any other purpose, too.
|
|
AI_MAX_NUMBER_OF_COLOR_SETS = 4
|
|
|
|
|
|
_fields_ = [
|
|
#The number of vertices in this mesh.
|
|
#This is also the size of all of the per-vertex data arrays
|
|
("mNumVertices", c_uint), #OK
|
|
|
|
#The number of primitives (triangles, polygones, lines) in this mesh.
|
|
#This is also the size of the mFaces array
|
|
("mNumFaces", c_uint), #OK
|
|
|
|
#Vertex positions.
|
|
#This array is always present in a mesh. The array is
|
|
#mNumVertices in size.
|
|
("mVertices", POINTER(VECTOR3D)), #OK
|
|
|
|
#Vertex normals.
|
|
#The array contains normalized vectors, NULL if not present.
|
|
#The array is mNumVertices in size.
|
|
("mNormals", POINTER(VECTOR3D)), #OK
|
|
|
|
#Vertex tangents.
|
|
#The tangent of a vertex points in the direction of the positive
|
|
#X texture axis. The array contains normalized vectors, NULL if
|
|
#not present. The array is mNumVertices in size.
|
|
#@note If the mesh contains tangents, it automatically also
|
|
#contains bitangents.
|
|
("mTangents", POINTER(VECTOR3D)), #OK
|
|
|
|
#Vertex bitangents.
|
|
#The bitangent of a vertex points in the direction of the positive
|
|
#Y texture axis. The array contains normalized vectors, NULL if not
|
|
#present. The array is mNumVertices in size.
|
|
#@note If the mesh contains tangents, it automatically also contains
|
|
#bitangents.
|
|
("mBitangents", POINTER(VECTOR3D)), #OK
|
|
|
|
#Vertex color sets.
|
|
#A mesh may contain 0 to #AI_MAX_NUMBER_OF_COLOR_SETS vertex
|
|
#colors per vertex. NULL if not present. Each array is
|
|
#mNumVertices in size if present.
|
|
("mColors", POINTER(COLOR4D)*AI_MAX_NUMBER_OF_COLOR_SETS), #OK
|
|
|
|
#Vertex texture coords, also known as UV channels.
|
|
#A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS per
|
|
#vertex. NULL if not present. The array is mNumVertices in size.
|
|
("mTextureCoords", POINTER(VECTOR3D)*AI_MAX_NUMBER_OF_TEXTURECOORDS),#OK
|
|
|
|
#Specifies the number of components for a given UV channel.
|
|
#Up to three channels are supported (UVW, for accessing volume
|
|
#or cube maps). If the value is 2 for a given channel n, the
|
|
#component p.z of mTextureCoords[n][p] is set to 0.0f.
|
|
#If the value is 1 for a given channel, p.y is set to 0.0f, too.
|
|
#@note 4D coords are not supported
|
|
("mNumUVComponents", c_uint*AI_MAX_NUMBER_OF_TEXTURECOORDS), #OK
|
|
|
|
#The faces the mesh is contstructed from.
|
|
#Each face referres to a number of vertices by their indices.
|
|
#This array is always present in a mesh, its size is given
|
|
#in mNumFaces.
|
|
("mFaces", POINTER(FACE)), #OK
|
|
|
|
#The number of bones this mesh contains.
|
|
#Can be 0, in which case the mBones array is NULL.
|
|
("mNumBones", c_uint), #OK
|
|
|
|
#The bones of this mesh.
|
|
#A bone consists of a name by which it can be found in the
|
|
#frame hierarchy and a set of vertex weights.
|
|
("mBones", POINTER(POINTER(BONE))), #OK
|
|
|
|
#The material used by this mesh.
|
|
#A mesh does use only a single material. If an imported model uses
|
|
#multiple materials, the import splits up the mesh. Use this value
|
|
#as index into the scene's material list.
|
|
("mMaterialIndex", c_uint) #OK
|
|
]
|
|
|
|
|
|
class MATERIALPROPERTY(Structure):
|
|
"""
|
|
Data structure for a single property inside a material.
|
|
"""
|
|
|
|
_fields_ = [
|
|
#Specifies the name of the property (key)
|
|
#Keys are case insensitive.
|
|
("mKey", STRING), #OK
|
|
|
|
#Size of the buffer mData is pointing to, in bytes
|
|
#This value may not be 0.
|
|
("mDataLength", c_uint), #OK
|
|
|
|
#Type information for the property.
|
|
#Defines the data layout inside the
|
|
#data buffer. This is used by the library
|
|
#internally to perform debug checks.
|
|
#THIS IS AN ENUM!
|
|
("mType", c_int), #IGNORED
|
|
|
|
#Binary buffer to hold the property's value
|
|
#The buffer has no terminal character. However,
|
|
#if a string is stored inside it may use 0 as terminal,
|
|
#but it would be contained in mDataLength. This member
|
|
#is never 0
|
|
("mData", c_char_p) #OK
|
|
]
|
|
|
|
|
|
class MATERIAL(Structure):
|
|
"""
|
|
Data structure for a material.
|
|
|
|
Material data is stored using a key-value structure, called property
|
|
(to guarant that the system is maximally flexible).
|
|
The library defines a set of standard keys (AI_MATKEY) which should be
|
|
enough for nearly all purposes.
|
|
"""
|
|
|
|
_fields_ = [
|
|
#List of all material properties loaded.
|
|
("mProperties", POINTER(POINTER(MATERIALPROPERTY))), #OK
|
|
|
|
#Number of properties loaded
|
|
("mNumProperties", c_uint), #OK
|
|
("mNumAllocated", c_uint) #IGNORED
|
|
]
|
|
|
|
|
|
class VECTORKEY(Structure):
|
|
"""
|
|
A time-value pair specifying a certain 3D vector for the given time.
|
|
"""
|
|
|
|
_fields_ = [
|
|
#The time of this key
|
|
("mTime", c_double),
|
|
|
|
#The value of this key
|
|
("mValue", VECTOR3D)
|
|
]
|
|
|
|
|
|
class QUATERNION(Structure):
|
|
"""
|
|
Represents a quaternion in a 4D vector.
|
|
"""
|
|
|
|
_fields = [
|
|
#the components
|
|
("w", c_float),
|
|
("x", c_float),
|
|
("y", c_float),
|
|
("z", c_float)
|
|
]
|
|
|
|
|
|
class QUATKEY(Structure):
|
|
"""
|
|
A time-value pair specifying a rotation for the given time. For joint
|
|
animations the rotation is usually expressed using a quaternion.
|
|
"""
|
|
|
|
_fields_ = [
|
|
#The time of this key
|
|
("mTime", c_double),
|
|
|
|
#The value of this key
|
|
("mValue", QUATERNION)
|
|
]
|
|
|
|
|
|
class BONEANIM(Structure):
|
|
"""
|
|
Describes the animation of a single node. The name specifies the bone/node
|
|
which is affected by this animation channel. The keyframes are given in
|
|
three separate series of values, one each for position, rotation and
|
|
scaling.
|
|
|
|
NOTE: The name "BoneAnim" is misleading. This structure is also used to
|
|
describe the animation of regular nodes on the node graph. They needn't be
|
|
nodes.
|
|
"""
|
|
|
|
_fields_ = [
|
|
#The name of the bone affected by this animation.
|
|
("mBoneName", STRING),
|
|
|
|
#The number of position keys
|
|
("mNumPositionKeys", c_uint),
|
|
|
|
#The position keys of this animation channel. Positions are
|
|
#specified as 3D vector. The array is mNumPositionKeys in size.
|
|
("mPositionKeys", POINTER(VECTORKEY)),
|
|
|
|
#The number of rotation keys
|
|
("mNumRotationKeys", c_uint),
|
|
|
|
#The rotation keys of this animation channel. Rotations are given as
|
|
#quaternions, which are 4D vectors. The array is mNumRotationKeys in
|
|
#size.
|
|
("mRotationKeys", POINTER(QUATKEY)),
|
|
|
|
#The number of scaling keys
|
|
("mNumScalingKeys", c_uint),
|
|
|
|
#The scaling keys of this animation channel. Scalings are specified
|
|
#as 3D vector. The array is mNumScalingKeys in size.
|
|
("mScalingKeys", POINTER(VECTORKEY))
|
|
]
|
|
|
|
|
|
class ANIMATION(Structure):
|
|
"""
|
|
An animation consists of keyframe data for a number of bones.
|
|
For each bone affected by the animation a separate series of data is given.
|
|
"""
|
|
|
|
_fields_ = [
|
|
#The name of the animation. If the modelling package this data was
|
|
#exported from does support only a single animation channel, this
|
|
#name is usually empty (length is zero).
|
|
("mName", STRING),
|
|
|
|
#Duration of the animation in ticks.
|
|
("mDuration", c_double),
|
|
|
|
#Ticks per second. 0 if not specified in the imported file
|
|
("mTicksPerSecond", c_double),
|
|
|
|
#The number of bone animation channels. Each channel affects a
|
|
#single bone.
|
|
("mNumBones", c_uint),
|
|
|
|
#The bone animation channels. Each channel affects a single bone.
|
|
#The array is mNumBones in size.
|
|
("mBones", POINTER(POINTER(BONEANIM)))
|
|
]
|
|
|
|
|
|
class TEXEL(Structure):
|
|
"""
|
|
Helper structure to represent a texel in ARGB8888 format
|
|
"""
|
|
|
|
_fields_ = [
|
|
("b", c_ubyte),
|
|
("g", c_ubyte),
|
|
("r", c_ubyte),
|
|
("a", c_ubyte)
|
|
]
|
|
|
|
|
|
class TEXTURE(Structure):
|
|
"""
|
|
Helper structure to describe an embedded texture
|
|
|
|
Normally textures are contained in external files but some file formats
|
|
do embedd them.
|
|
"""
|
|
|
|
_fields_ = [
|
|
#Width of the texture, in pixels
|
|
#If mHeight is zero the texture is compressed in a format
|
|
#like JPEG. In this case mWidth specifies the size of the
|
|
#memory area pcData is pointing to, in bytes.
|
|
("mWidth", c_uint), #OK
|
|
|
|
#Height of the texture, in pixels
|
|
#If this value is zero, pcData points to an compressed texture
|
|
#in an unknown format (e.g. JPEG).
|
|
("mHeight", c_uint), #OK
|
|
|
|
#A hint from the loader to make it easier for applications
|
|
#to determine the type of embedded compressed textures.
|
|
#If mHeight != 0 this member is undefined. Otherwise it
|
|
#will be set to '\0\0\0\0' if the loader has no additional
|
|
#information about the texture file format used OR the
|
|
#file extension of the format without a leading dot.
|
|
#E.g. 'dds\0', 'pcx\0'. All characters are lower-case.
|
|
("achFormatHint", c_char*4), #OK
|
|
|
|
#Data of the texture.
|
|
#Points to an array of mWidth * mHeight aiTexel's.
|
|
#The format of the texture data is always ARGB8888 to
|
|
#make the implementation for user of the library as easy
|
|
#as possible. If mHeight = 0 this is a pointer to a memory
|
|
#buffer of size mWidth containing the compressed texture
|
|
#data. Good luck, have fun!
|
|
("pcData", POINTER(TEXEL)) #OK
|
|
]
|
|
|
|
|
|
class SCENE(Structure):
|
|
"""
|
|
The root structure of the imported data.
|
|
Everything that was imported from the given file can be accessed from here.
|
|
"""
|
|
|
|
_fields_ = [
|
|
#Any combination of the AI_SCENE_FLAGS_XXX flags
|
|
("flags", c_uint), #OK
|
|
|
|
#The root node of the hierarchy.
|
|
#There will always be at least the root node if the import
|
|
#was successful. Presence of further nodes depends on the
|
|
#format and content of the imported file.
|
|
("mRootNode", POINTER(NODE)),
|
|
|
|
#The number of meshes in the scene.
|
|
("mNumMeshes", c_uint), #OK
|
|
|
|
#The array of meshes.
|
|
#Use the indices given in the aiNode structure to access
|
|
#this array. The array is mNumMeshes in size.
|
|
("mMeshes", POINTER(POINTER(MESH))), #OK
|
|
|
|
#The number of materials in the scene.
|
|
("mNumMaterials", c_uint), #OK
|
|
|
|
#The array of materials.
|
|
#Use the index given in each aiMesh structure to access this
|
|
#array. The array is mNumMaterials in size.
|
|
("mMaterials", POINTER(POINTER(MATERIAL))), #OK
|
|
|
|
#The number of animations in the scene.
|
|
("mNumAnimations", c_uint),
|
|
|
|
#The array of animations.
|
|
#All animations imported from the given file are listed here.
|
|
#The array is mNumAnimations in size.
|
|
("mAnimations", POINTER(POINTER(ANIMATION))),
|
|
|
|
#The number of textures embedded into the file
|
|
("mNumTextures", c_uint), #OK
|
|
|
|
#The array of embedded textures.
|
|
#Not many file formats embedd their textures into the file.
|
|
#An example is Quake's MDL format (which is also used by
|
|
#some GameStudio(TM) versions)
|
|
("mTextures", POINTER(POINTER(TEXTURE))) #OK
|
|
] |