v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

+ add rudimentary Python3 version of PyAssimp. Conversion using 2to3 plus some manual tweaks. 

git-svn-id: https://assimp.svn.sourceforge.net/svnroot/assimp/trunk@1057 67173fc5-114c-0410-ac8e-9d2fd5bffc1f
pull/2/head
aramis_acg 2011-07-20 00:36:26 +00:00
parent c58480d608
commit dc2bf5d6bd
8 changed files with 1014 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
port/PyAssimp3/README 100644
View File

@ -0,0 +1,65 @@
PyAssimp3 Readme
---------------
-- a simple Python3 wrapper for Assimp using ctypes to access
the library. Works with Python 3 upwards.
Note that pyassimp is by no means considered mature. It works,
but it is far away from wrapping Assimp perfectly.
USAGE
=====
To get started with pyAssimp, examine the sample.py script, which
illustrates the basic usage. All Assimp data structures are
wrapped using ctypes. All the data+length fields in Assimp's
data structures (such as 'aiMesh::mNumVertices','aiMesh::mVertices')
are replaced by simple python lists, so you can call len() on
them to get their respective size and access members using
[].
For example, to load a file named 'hello.3ds' and print the first
vertex of the first mesh, you would do (proper error handling
substituted by assertions ...):
> from pyassimp import pyassimp, errors
>
> try:
> scene = pyassimp.load('hello.3ds')
> except AssimpError, msg:
> print(msg)
> return
> assert len(scene.meshes)
> mesh = scene.meshes[0]
> assert len(mesh.vertices)
> print(mesh.vertices[0])
> # don't forget this one, or you will leak!
> pyassimp.release(scene)
INSTALL
=======
PyAssimp requires a assimp dynamic library (DLL on windows,
so on linux :-) in order to work. The default search directories
are:
- the current directory
- on linux additionally: /usr/local/lib
To build that library, refer to the Assimp master INSTALL
instructions. To look in more places, edit ./pyassimp/helper.py.
There's an 'additional_dirs' list waiting for your entries.

1
port/PyAssimp3/pyassimp/__init__.py 100644
View File

@ -0,0 +1 @@
#-*- coding: UTF-8 -*-

11
port/PyAssimp3/pyassimp/errors.py 100644
View File

@ -0,0 +1,11 @@
#-*- coding: UTF-8 -*-
"""
All possible errors.
"""
class AssimpError(BaseException):
"""
If an internal error occures.
"""
pass

116
port/PyAssimp3/pyassimp/helper.py 100644
View File

@ -0,0 +1,116 @@
#-*- coding: UTF-8 -*-
"""
Some fancy helper functions.
"""
import os
import ctypes
from . import structs
import operator
from .errors import AssimpError
from ctypes import POINTER
additional_dirs, ext_whitelist = [],[]
# populate search directories and lists of allowed file extensions
# depending on the platform we're running on.
if os.name=='posix':
additional_dirs.append('/usr/local/lib/')
# note - this won't catch libassimp.so.N.n, but
# currently there's always a symlink called
# libassimp.so in /usr/local/lib.
ext_whitelist.append('.so')
elif os.name=='nt':
ext_whitelist.append('.dll')
def vec2tuple(x):
""" Converts a VECTOR3D to a Tuple """
return (x.x, x.y, x.z)
def try_load_functions(library,dll,candidates):
"""try to functbind to aiImportFile and aiReleaseImport
library - path to current lib
dll - ctypes handle to it
candidates - receives matching candidates
They serve as signal functions to detect assimp,
also they're currently the only functions we need.
insert (library,aiImportFile,aiReleaseImport,dll)
into 'candidates' if successful.
"""
try:
load = dll.aiImportFile
release = dll.aiReleaseImport
except AttributeError:
#OK, this is a library, but it has not the functions we need
pass
else:
#Library found!
load.restype = POINTER(structs.Scene)
candidates.append((library, load, release, dll))
def search_library():
"""Loads the assimp-Library.
result (load-function, release-function)
exception AssimpError if no library is found
"""
#this path
folder = os.path.dirname(__file__)
# silence 'DLL not found' message boxes on win
try:
ctypes.windll.kernel32.SetErrorMode(0x8007)
except AttributeError:
pass
candidates = []
# test every file
for curfolder in [folder]+additional_dirs:
for filename in os.listdir(curfolder):
# our minimum requirement for candidates is that
# they should contain 'assimp' somewhere in
# their name
if filename.lower().find('assimp')==-1 or\
os.path.splitext(filename)[-1].lower() not in ext_whitelist:
continue
library = os.path.join(curfolder, filename)
print('PyAssimp3: trying ',library)
try:
dll = ctypes.cdll.LoadLibrary(library)
except:
# OK, this except is evil. But different OSs will throw different
# errors. So just ignore any errors.
continue
try_load_functions(library,dll,candidates)
if not candidates:
# no library found
raise AssimpError("assimp library not found")
else:
# get the newest library
candidates = [(os.lstat(x[0])[-2], x) for x in candidates]
res = max(candidates, key=operator.itemgetter(0))[1]
print('PyAssimp3: taking ',res[0])
# XXX: if there are 1000 dll/so files containing 'assimp'
# in their name, do we have all of them in our address
# space now until gc kicks in?
# XXX: take version postfix of the .so on linux?
return res[1:]

281
port/PyAssimp3/pyassimp/pyassimp.py 100644
View File

@ -0,0 +1,281 @@
#-*- coding: UTF-8 -*-
"""
PyAssimp
This is the main-module of PyAssimp.
"""
import sys
if sys.version_info < (3,0):
raise Exception('pyassimp: need python 3.0 or newer')
from . import structs
import ctypes
import os
from . import helper
from .errors import AssimpError
class aiArray:
"""
A python class to 'safely' access C arrays.
For m<Name> and mNum<Name> assimp class members.
"""
def __init__(self, instance, dataName, sizeName, i=None):
self.instance = instance
self.dataName = dataName
self.sizeName = sizeName
self.i = i
self.count = 0
def _GetSize(self):
return getattr(self.instance, self.sizeName)
def _GetData(self, index):
if self.i != None:
if not bool(getattr(self.instance, self.dataName)[self.i]):
return None
item = getattr(self.instance, self.dataName)[self.i][index]
else:
item = getattr(self.instance, self.dataName)[index]
if hasattr(item, 'contents'):
return item.contents._init()
elif hasattr(item, '_init'):
return item._init()
else:
return item
def __next__(self):
if self.count >= self._GetSize():
self.count = 0
raise StopIteration
else:
c = self.count
self.count += 1
return self._GetData(c)
def __getitem__(self, index):
if isinstance(index, slice):
indices = index.indices(len(self))
return [self.__getitem__(i) for i in range(*indices)]
if index < 0 or index >= self._GetSize():
raise IndexError("aiArray index out of range")
return self._GetData(index)
def __iter__(self):
return self
def __len__(self):
return int(self._GetSize())
def __str__(self):
return str([x for x in self])
def __repr__(self):
return str([x for x in self])
class aiTuple:
"""
A python class to 'safely' access C structs in a python tuple fashion.
For C structs like vectors, matrices, colors, ...
"""
def __init__(self, instance):
self.instance = instance
self.count = 0
def _GetSize(self):
return len(self.instance._fields_)
def _GetData(self, index):
return getattr(self.instance, self.instance._fields_[index][0])
def __next__(self):
if self.count >= self._GetSize():
self.count = 0
raise StopIteration
else:
c = self.count
self.count += 1
return self._GetData(c)
def __getitem__(self, index):
if isinstance(index, slice):
indices = index.indices(len(self))
return [self.__getitem__(i) for i in range(*indices)]
if index < 0 or index >= self._GetSize():
raise IndexError("aiTuple index out of range")
return self._GetData(index)
def __iter__(self):
return self
def __len__(self):
return int(self._GetSize())
def __str__(self):
return str([x for x in self])
def __repr__(self):
return str([x for x in self])
def _init(self):
"""
Custom initialize() for C structs, adds safely accessable member functionality.
"""
if hasattr(self, '_is_init'):
return self
self._is_init = True
if str(self.__class__.__name__) == "MaterialProperty":
self.mKey._init()
for m in list(self.__class__.__dict__.keys()):
if m.startswith('mNum'):
name = m.split('mNum')[1]
if 'm'+name in list(self.__class__.__dict__.keys()):
setattr(self.__class__, name.lower(), aiArray(self, 'm'+name , m))
if name.lower() == "vertices":
setattr(self.__class__, "normals", aiArray(self, 'mNormals' , m))
setattr(self.__class__, "tangents", aiArray(self, 'mTangents' , m))
setattr(self.__class__, "bitangets", aiArray(self, 'mBitangents' , m))
setattr(self.__class__, "colors", [aiArray(self, 'mColors' , m, o) for o in range(len(self.mColors))])
setattr(self.__class__, "texcoords", [aiArray(self, 'mTextureCoords' , m, o) for o in range(len(self.mColors))])
elif m == "x" or m == "a1" or m == "b": # Vector, matrix, quat, color
self._tuple = aiTuple(self)
setattr(self.__class__, '__getitem__', lambda x, y: x._tuple.__getitem__(y))
setattr(self.__class__, '__iter__', lambda x: x._tuple)
setattr(self.__class__, 'next', lambda x: x._tuple.__next__)
setattr(self.__class__, '__repr__', lambda x: str([c for c in x]))
break
elif m == "data": #String
setattr(self.__class__, '__repr__', lambda x: str(x.data))
setattr(self.__class__, '__str__', lambda x: str(x.data))
break
if hasattr(getattr(self, m), '_init'):
getattr(self, m)._init()
return self
"""
Python magic to add the _init() function to all C struct classes.
"""
for struct in dir(structs):
if not (struct.startswith('_') or struct.startswith('c_') or struct == "Structure" or struct == "POINTER") and not isinstance(getattr(structs, struct),int):
setattr(getattr(structs, struct), '_init', _init)
class AssimpLib(object):
"""
Assimp-Singleton
"""
load, release, dll = helper.search_library()
#the loader as singleton
_assimp_lib = AssimpLib()
def load(filename, processing=0):
"""
Loads the model with some specific processing parameters.
filename - file to load model from
processing - processing parameters
result Scene-object with model-data
throws AssimpError - could not open file
"""
#read pure data
from ctypes import c_char_p, c_uint
model = _assimp_lib.load(c_char_p(filename), c_uint(processing))
if not model:
#Uhhh, something went wrong!
raise AssimpError("could not import file: %s" % filename)
return model.contents._init()
def release(scene):
from ctypes import pointer
_assimp_lib.release(pointer(scene))
def aiGetMaterialFloatArray(material, key):
AI_SUCCESS = 0
from ctypes import byref, pointer, cast, c_float, POINTER, sizeof, c_uint
out = structs.Color4D()
max = c_uint(sizeof(structs.Color4D))
r=_assimp_lib.dll.aiGetMaterialFloatArray(pointer(material),
key[0],
key[1],
key[2],
byref(out),
byref(max))
if (r != AI_SUCCESS):
raise AssimpError("aiGetMaterialFloatArray failed!")
out._init()
return [out[i] for i in range(max.value)]
def aiGetMaterialString(material, key):
AI_SUCCESS = 0
from ctypes import byref, pointer, cast, c_float, POINTER, sizeof, c_uint
out = structs.String()
r=_assimp_lib.dll.aiGetMaterialString(pointer(material),
key[0],
key[1],
key[2],
byref(out))
if (r != AI_SUCCESS):
raise AssimpError("aiGetMaterialString failed!")
return str(out.data)
def GetMaterialProperties(material):
"""
Convenience Function to get the material properties as a dict
and values in a python format.
"""
result = {}
#read all properties
for p in material.properties:
#the name
key = p.mKey.data
#the data
from ctypes import POINTER, cast, c_int, c_float, sizeof
if p.mType == 1:
arr = cast(p.mData, POINTER(c_float*(p.mDataLength//sizeof(c_float)) )).contents
value = [x for x in arr]
elif p.mType == 3: #string can't be an array
try:
value = cast(p.mData, POINTER(structs.String)).contents.data
except UnicodeDecodeError:
print('UnicodeDecodeError reading material property, ignoring.')
continue
elif p.mType == 4:
arr = cast(p.mData, POINTER(c_int*(p.mDataLength//sizeof(c_int)) )).contents
value = [x for x in arr]
else:
value = p.mData[:p.mDataLength]
result[key] = value
return result
def aiDecomposeMatrix(matrix):
if not isinstance(matrix, structs.Matrix4x4):
raise AssimpError("aiDecomposeMatrix failed: Not a aiMatrix4x4!")
scaling = structs.Vector3D()
rotation = structs.Quaternion()
position = structs.Vector3D()
from ctypes import byref, pointer
_assimp_lib.dll.aiDecomposeMatrix(pointer(matrix), byref(scaling), byref(rotation), byref(position))
return scaling._init(), rotation._init(), position._init()

424
port/PyAssimp3/pyassimp/structs.py 100644
View File

@ -0,0 +1,424 @@
#-*- coding: UTF-8 -*-
from ctypes import POINTER, c_int, c_uint, c_char, c_float, Structure, c_char_p, c_double, c_ubyte
class Vector2D(Structure):
"""
See 'aiVector2D.h' for details.
"""
_fields_ = [
("x", c_float),("y", c_float),
]
class Texel(Structure):
"""
See 'aiTexture.h' for details.
"""
_fields_ = [
("b", c_ubyte),("g", c_ubyte),("r", c_ubyte),("a", c_ubyte),
]
class Plane(Structure):
"""
See 'aiTypes.h' for details.
"""
_fields_ = [
# Plane equation
("a", c_float),("b", c_float),("c", c_float),("d", c_float),
]
class Color3D(Structure):
"""
See 'aiTypes.h' for details.
"""
_fields_ = [
# Red, green and blue color values
("r", c_float),("g", c_float),("b", c_float),
]
class String(Structure):
"""
See 'aiTypes.h' for details.
"""
MAXLEN = 1024
_fields_ = [
#Binary length of the string excluding the terminal 0. This is NOT the# logical length of strings containing UTF-8 multibyte sequences! It's# the number of bytes from the beginning of the string to its end.#
("length", c_uint),#String buffer. Size limit is MAXLEN#
("data", c_char*MAXLEN),
]
class MemoryInfo(Structure):
"""
See 'aiTypes.h' for details.
"""
_fields_ = [
#Storage allocated for texture data#
("textures", c_uint),#Storage allocated for material data#
("materials", c_uint),#Storage allocated for mesh data#
("meshes", c_uint),#Storage allocated for node data#
("nodes", c_uint),#Storage allocated for animation data#
("animations", c_uint),#Storage allocated for camera data#
("cameras", c_uint),#Storage allocated for light data#
("lights", c_uint),#Total storage allocated for the full import.#
("total", c_uint),
]
class Matrix3x3(Structure):
"""
See 'aiMatrix3x3.h' for details.
"""
_fields_ = [
("a1", c_float),("a2", c_float),("a3", c_float),
("b1", c_float),("b2", c_float),("b3", c_float),
("c1", c_float),("c2", c_float),("c3", c_float),
]
class Color4D(Structure):
"""
See 'aiColor4D.h' for details.
"""
_fields_ = [
# Red, green, blue and alpha color values
("r", c_float),("g", c_float),("b", c_float),("a", c_float),
]
class ExportFormatDesc(Structure):
"""
See 'export.h' for details.
"""
_fields_ = [
# a short string ID to uniquely identify the export format. Use this ID string to# specify which file format you want to export to when calling aiExportScene().# Example: "dae" or "obj"
("id", POINTER(c_char)),# A short description of the file format to present to users. Useful if you want# to allow the user to select an export format.
("description", POINTER(c_char)),# Recommended file extension for the exported file in lower case.
("fileExtension", POINTER(c_char)),
]
class Quaternion(Structure):
"""
See 'aiQuaternion.h' for details.
"""
_fields_ = [
# w,x,y,z components of the quaternion
("w", c_float),("x", c_float),("y", c_float),("z", c_float),
]
class Vector3D(Structure):
"""
See 'aiVector3D.h' for details.
"""
_fields_ = [
("x", c_float),("y", c_float),("z", c_float),
]
class Face(Structure):
"""
See 'aiMesh.h' for details.
"""
_fields_ = [
# Number of indices defining this face.# The maximum value for this member is #AI_MAX_FACE_INDICES.
("mNumIndices", c_uint),# Pointer to the indices array. Size of the array is given in numIndices.
("mIndices", POINTER(c_uint)),
]
class VertexWeight(Structure):
"""
See 'aiMesh.h' for details.
"""
_fields_ = [
# Index of the vertex which is influenced by the bone.
("mVertexId", c_uint),# The strength of the influence in the range (0...1).# The influence from all bones at one vertex amounts to 1.
("mWeight", c_float),
]
class MeshKey(Structure):
"""
See 'aiAnim.h' for details.
"""
_fields_ = [
#The time of this key#
("mTime", c_double),#Index into the aiMesh::mAnimMeshes array of the# mesh coresponding to the #aiMeshAnim hosting this# key frame. The referenced anim mesh is evaluated# according to the rules defined in the docs for #aiAnimMesh.#
("mValue", c_uint),
]
class Matrix4x4(Structure):
"""
See 'aiMatrix4x4.h' for details.
"""
_fields_ = [
("a1", c_float),("a2", c_float),("a3", c_float),("a4", c_float),
("b1", c_float),("b2", c_float),("b3", c_float),("b4", c_float),
("c1", c_float),("c2", c_float),("c3", c_float),("c4", c_float),
("d1", c_float),("d2", c_float),("d3", c_float),("d4", c_float),
]
class Node(Structure):
"""
See 'aiScene.h' for details.
"""
Node._fields_ = [
#The name of the node.##The name might be empty (length of zero) but all nodes which#need to be accessed afterwards by bones or anims are usually named.#Multiple nodes may have the same name, but nodes which are accessed#by bones (see #aiBone and #aiMesh::mBones) *must* be unique.##Cameras and lights are assigned to a specific node name - if there#are multiple nodes with this name, they're assigned to each of them.#<br>#There are no limitations regarding the characters contained in#this text. You should be able to handle stuff like whitespace, tabs,#linefeeds, quotation marks, ampersands, ... .#
("mName", String),#The transformation relative to the node's parent.#
("mTransformation", 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_uint)),
]
class Camera(Structure):
"""
See 'aiCamera.h' for details.
"""
_fields_ = [
#The name of the camera.## There must be a node in the scenegraph with the same name.# This node specifies the position of the camera in the scene# hierarchy and can be animated.#
("mName", String),#Position of the camera relative to the coordinate space# defined by the corresponding node.## The default value is 0|0|0.#
("mPosition", Vector3D),#'Up' - vector of the camera coordinate system relative to# the coordinate space defined by the corresponding node.## The 'right' vector of the camera coordinate system is# the cross product of the up and lookAt vectors.# The default value is 0|1|0. The vector# may be normalized, but it needn't.#
("mUp", Vector3D),#'LookAt' - vector of the camera coordinate system relative to# the coordinate space defined by the corresponding node.## This is the viewing direction of the user.# The default value is 0|0|1. The vector# may be normalized, but it needn't.#
("mLookAt", Vector3D),#Half horizontal field of view angle, in radians.## The field of view angle is the angle between the center# line of the screen and the left or right border.# The default value is 1/4PI.#
("mHorizontalFOV", c_float),#Distance of the near clipping plane from the camera.##The value may not be 0.f (for arithmetic reasons to prevent#a division through zero). The default value is 0.1f.#
("mClipPlaneNear", c_float),#Distance of the far clipping plane from the camera.##The far clipping plane must, of course, be further away than the#near clipping plane. The default value is 1000.f. The ratio#between the near and the far plane should not be too#large (between 1000-10000 should be ok) to avoid floating-point#inaccuracies which could lead to z-fighting.#
("mClipPlaneFar", c_float),#Screen aspect ratio.##This is the ration between the width and the height of the#screen. Typical values are 4/3, 1/2 or 1/1. This value is#0 if the aspect ratio is not defined in the source file.#0 is also the default value.#
("mAspect", c_float),
]
class Texture(Structure):
"""
See 'aiTexture.h' for details.
"""
_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),#Height of the texture, in pixels##If this value is zero, pcData points to an compressed texture#in any format (e.g. JPEG).#
("mHeight", c_uint),#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#is set 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 trailing dot. If there#are multiple file extensions for a format, the shortest#extension is chosen (JPEG maps to 'jpg', not to 'jpeg').#E.g. 'dds\\0', 'pcx\\0', 'jpg\\0'. All characters are lower-case.#The fourth character will always be '\\0'.#
("achFormatHint", c_char*4),#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)),
]
class Ray(Structure):
"""
See 'aiTypes.h' for details.
"""
_fields_ = [
# Position and direction of the ray
("pos", Vector3D),("dir", Vector3D),
]
class Light(Structure):
"""
See 'aiLight.h' for details.
"""
_fields_ = [
#The name of the light source.## There must be a node in the scenegraph with the same name.# This node specifies the position of the light in the scene# hierarchy and can be animated.#
("mName", String),#The type of the light source.##aiLightSource_UNDEFINED is not a valid value for this member.#
("mType", c_uint),#Position of the light source in space. Relative to the# transformation of the node corresponding to the light.## The position is undefined for directional lights.#
("mPosition", Vector3D),#Direction of the light source in space. Relative to the# transformation of the node corresponding to the light.## The direction is undefined for point lights. The vector# may be normalized, but it needn't.#
("mDirection", Vector3D),#Constant light attenuation factor.## The intensity of the light source at a given distance 'd' from# the light's position is# @code# Atten = 1/( att0 + att1#d + att2#d*d)# @endcode# This member corresponds to the att0 variable in the equation.# Naturally undefined for directional lights.#
("mAttenuationConstant", c_float),#Linear light attenuation factor.## The intensity of the light source at a given distance 'd' from# the light's position is# @code# Atten = 1/( att0 + att1#d + att2#d*d)# @endcode# This member corresponds to the att1 variable in the equation.# Naturally undefined for directional lights.#
("mAttenuationLinear", c_float),#Quadratic light attenuation factor.## The intensity of the light source at a given distance 'd' from# the light's position is# @code# Atten = 1/( att0 + att1#d + att2#d*d)# @endcode# This member corresponds to the att2 variable in the equation.# Naturally undefined for directional lights.#
("mAttenuationQuadratic", c_float),#Diffuse color of the light source## The diffuse light color is multiplied with the diffuse# material color to obtain the final color that contributes# to the diffuse shading term.#
("mColorDiffuse", Color3D),#Specular color of the light source## The specular light color is multiplied with the specular# material color to obtain the final color that contributes# to the specular shading term.#
("mColorSpecular", Color3D),#Ambient color of the light source## The ambient light color is multiplied with the ambient# material color to obtain the final color that contributes# to the ambient shading term. Most renderers will ignore# this value it, is just a remaining of the fixed-function pipeline# that is still supported by quite many file formats.#
("mColorAmbient", Color3D),#Inner angle of a spot light's light cone.## The spot light has maximum influence on objects inside this# angle. The angle is given in radians. It is 2PI for point# lights and undefined for directional lights.#
("mAngleInnerCone", c_float),#Outer angle of a spot light's light cone.## The spot light does not affect objects outside this angle.# The angle is given in radians. It is 2PI for point lights and# undefined for directional lights. The outer angle must be# greater than or equal to the inner angle.# It is assumed that the application uses a smooth# interpolation between the inner and the outer cone of the# spot light.#
("mAngleOuterCone", c_float),
]
class Bone(Structure):
"""
See 'aiMesh.h' for details.
"""
_fields_ = [
# The name of the bone.
("mName", String),# The number of vertices affected by this bone# The maximum value for this member is #AI_MAX_BONE_WEIGHTS.
("mNumWeights", c_uint),# The vertices affected by this bone
("mWeights", POINTER(VertexWeight)),# Matrix that transforms from mesh space to bone space in bind pose
("mOffsetMatrix", Matrix4x4),
]
class Mesh(Structure):
"""
See 'aiMesh.h' for details.
"""
AI_MAX_FACE_INDICES = 0x7fff
AI_MAX_BONE_WEIGHTS = 0x7fffffff
AI_MAX_VERTICES = 0x7fffffff
AI_MAX_FACES = 0x7fffffff
AI_MAX_NUMBER_OF_COLOR_SETS = 0x8
AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x8
_fields_ = [
#Bitwise combination of the members of the #aiPrimitiveType enum.#This specifies which types of primitives are present in the mesh.#The "SortByPrimitiveType"-Step can be used to make sure the#output meshes consist of one primitive type each.#
("mPrimitiveTypes", c_uint),#The number of vertices in this mesh.#This is also the size of all of the per-vertex data arrays.#The maximum value for this member is #AI_MAX_VERTICES.#
("mNumVertices", c_uint),#The number of primitives (triangles, polygons, lines) in this mesh.#This is also the size of the mFaces array.#The maximum value for this member is #AI_MAX_FACES.#
("mNumFaces", c_uint),#Vertex positions.#This array is always present in a mesh. The array is#mNumVertices in size.#
("mVertices", POINTER(Vector3D)),#Vertex normals.#The array contains normalized vectors, NULL if not present.#The array is mNumVertices in size. Normals are undefined for#point and line primitives. A mesh consisting of points and#lines only may not have normal vectors. Meshes with mixed#primitive types (i.e. lines and triangles) may have normals,#but the normals for vertices that are only referenced by#point or line primitives are undefined and set to QNaN (WARN:#qNaN compares to inequal to *everything*, even to qNaN itself.#Using code like this to check whether a field is qnan is:#@code##define IS_QNAN(f) (f != f)#@endcode#still dangerous because even 1.f == 1.f could evaluate to false! (#remember the subtleties of IEEE754 artithmetics). Use stuff like#@c fpclassify instead.#@note Normal vectors computed by Assimp are always unit-length.#However, this needn't apply for normals that have been taken# directly from the model file.#
("mNormals", POINTER(Vector3D)),#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. A mesh consisting#of points and lines only may not have normal vectors. Meshes with#mixed primitive types (i.e. lines and triangles) may have#normals, but the normals for vertices that are only referenced by#point or line primitives are undefined and set to qNaN. See#the #mNormals member for a detailled discussion of qNaNs.#@note If the mesh contains tangents, it automatically also#contains bitangents.#
("mTangents", POINTER(Vector3D)),#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)),#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),#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),#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),#The faces the mesh is constructed from.#Each face refers to a number of vertices by their indices.#This array is always present in a mesh, its size is given#in mNumFaces. If the #AI_SCENE_FLAGS_NON_VERBOSE_FORMAT#is NOT set each face references an unique set of vertices.#
("mFaces", POINTER(Face)),#The number of bones this mesh contains.#Can be 0, in which case the mBones array is NULL.#
("mNumBones", c_uint),#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))),#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),#Name of the mesh. Meshes can be named, but this is not a# requirement and leaving this field empty is totally fine.# There are mainly three uses for mesh names:# - some formats name nodes and meshes independently.# - importers tend to split meshes up to meet the# one-material-per-mesh requirement. Assigning# the same (dummy) name to each of the result meshes# aids the caller at recovering the original mesh# partitioning.# - Vertex animations refer to meshes by their names.#
("mName", String),#NOT CURRENTLY IN USE. The number of attachment meshes#
("mNumAnimMeshes", c_uint),#NOT CURRENTLY IN USE. Attachment meshes for this mesh, for vertex-based animation.# Attachment meshes carry replacement data for some of the# mesh'es vertex components (usually positions, normals).#
]
class VectorKey(Structure):
"""
See 'aiAnim.h' for details.
"""
_fields_ = [
#The time of this key#
("mTime", c_double),#The value of this key#
("mValue", Vector3D),
]
class QuatKey(Structure):
"""
See 'aiAnim.h' for details.
"""
_fields_ = [
#The time of this key#
("mTime", c_double),#The value of this key#
("mValue", Quaternion),
]
class NodeAnim(Structure):
"""
See 'aiAnim.h' for details.
"""
_fields_ = [
#The name of the node affected by this animation. The node# must exist and it must be unique.#
("mNodeName", 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.##If there are position keys, there will also be at least one#scaling and one rotation key.#
("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.##If there are rotation keys, there will also be at least one#scaling and one position key.#
("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.##If there are scaling keys, there will also be at least one#position and one rotation key.#
("mScalingKeys", POINTER(VectorKey)),#Defines how the animation behaves before the first# key is encountered.## The default value is aiAnimBehaviour_DEFAULT (the original# transformation matrix of the affected node is used).#
("mPreState", c_uint),#Defines how the animation behaves after the last# key was processed.## The default value is aiAnimBehaviour_DEFAULT (the original# transformation matrix of the affected node is taken).#
("mPostState", c_uint),
]
class Animation(Structure):
"""
See 'aiAnim.h' for details.
"""
_fields_ = [
#The name of the animation. If the modeling 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 node.#
("mNumChannels", c_uint),#The node animation channels. Each channel affects a single node.# The array is mNumChannels in size.#
("mChannels", POINTER(POINTER(NodeAnim))),#The number of mesh animation channels. Each channel affects# a single mesh and defines vertex-based animation.#
("mNumMeshChannels", c_uint),#The mesh animation channels. Each channel affects a single mesh.# The array is mNumMeshChannels in size.#
]
class UVTransform(Structure):
"""
See 'aiMaterial.h' for details.
"""
_fields_ = [
#Translation on the u and v axes.## The default value is (0|0).#
("mTranslation", Vector2D),#Scaling on the u and v axes.## The default value is (1|1).#
("mScaling", Vector2D),#Rotation - in counter-clockwise direction.## The rotation angle is specified in radians. The# rotation center is 0.5f|0.5f. The default value# 0.f.#
("mRotation", c_float),
]
class MaterialProperty(Structure):
"""
See 'aiMaterial.h' for details.
"""
_fields_ = [
#Specifies the name of the property (key)# Keys are generally case insensitive.#
("mKey", String),#Textures: Specifies their exact usage semantic.#For non-texture properties, this member is always 0#(or, better-said, #aiTextureType_NONE).#
("mSemantic", c_uint),#Textures: Specifies the index of the texture.# For non-texture properties, this member is always 0.#
("mIndex", c_uint),#Size of the buffer mData is pointing to, in bytes.# This value may not be 0.#
("mDataLength", c_uint),#Type information for the property.##Defines the data layout inside the data buffer. This is used#by the library internally to perform debug checks and to#utilize proper type conversions.#(It's probably a hacky solution, but it works.)#
("mType", c_uint),#Binary buffer to hold the property's value.#The size of the buffer is always mDataLength.#
("mData", POINTER(c_char)),
]
class Material(Structure):
"""
See 'aiMaterial.h' for details.
"""
_fields_ = [
#List of all material properties loaded.#
("mProperties", POINTER(POINTER(MaterialProperty))),#Number of properties in the data base#
("mNumProperties", c_uint),#Storage allocated#
("mNumAllocated", c_uint),
]
class Scene(Structure):
"""
See 'aiScene.h' for details.
"""
AI_SCENE_FLAGS_INCOMPLETE = 0x1
AI_SCENE_FLAGS_VALIDATED = 0x2
AI_SCENE_FLAGS_VALIDATION_WARNING = 0x4
AI_SCENE_FLAGS_NON_VERBOSE_FORMAT = 0x8
AI_SCENE_FLAGS_TERRAIN = 0x10
_fields_ = [
#Any combination of the AI_SCENE_FLAGS_XXX flags. By default#this value is 0, no flags are set. Most applications will#want to reject all scenes with the AI_SCENE_FLAGS_INCOMPLETE#bit set.#
("mFlags", c_uint),#The root node of the hierarchy.##There will always be at least the root node if the import#was successful (and no special flags have been set).#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),#The array of meshes.##Use the indices given in the aiNode structure to access#this array. The array is mNumMeshes in size. If the#AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always#be at least ONE material.#
("mMeshes", POINTER(POINTER(Mesh))),#The number of materials in the scene.#
("mNumMaterials", c_uint),#The array of materials.##Use the index given in each aiMesh structure to access this#array. The array is mNumMaterials in size. If the#AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always#be at least ONE material.#
("mMaterials", POINTER(POINTER(Material))),#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),#The array of embedded textures.##Not many file formats embed their textures into the file.#An example is Quake's MDL format (which is also used by#some GameStudio versions)#
("mTextures", POINTER(POINTER(Texture))),#The number of light sources in the scene. Light sources#are fully optional, in most cases this attribute will be 0#
("mNumLights", c_uint),#The array of light sources.##All light sources imported from the given file are#listed here. The array is mNumLights in size.#
("mLights", POINTER(POINTER(Light))),#The number of cameras in the scene. Cameras#are fully optional, in most cases this attribute will be 0#
("mNumCameras", c_uint),#The array of cameras.##All cameras imported from the given file are listed here.#The array is mNumCameras in size. The first camera in the#array (if existing) is the default camera view into#the scene.#
("mCameras", POINTER(POINTER(Camera))),
]

45
port/PyAssimp3/quicktest.py 100644
View File

@ -0,0 +1,45 @@
#!/usr/bin/env python3
#-*- coding: UTF-8 -*-
"""
This module uses the sample.py script to load all test models it finds.
Note: this is not an exhaustive test suite, it does not check the
data structures in detail. It just verifies whether basic
loading and querying of 3d models using pyassimp works.
"""
import sys,os
import sample
from pyassimp import pyassimp,errors
# paths to be walkd recursively
basepaths = [os.path.join('..','..','test','models'), os.path.join('..','..','test','models-nonbsd')]
# file extensions to be considered
extensions = ['.3ds','.x','.lwo','.obj','.md5mesh','.dxf','.ply','.stl','.dae','.md5anim','.lws','.irrmesh','.nff','.off','.blend']
def run_tests():
ok,err = 0,0
for path in basepaths:
for root, dirs, files in os.walk(path):
for afile in files:
base,ext = os.path.splitext(afile)
if ext in extensions:
try:
sample.main(os.path.join(root,afile))
ok += 1
except errors.AssimpError as error:
# assimp error is fine, this is a controlled case
print(error)
err += 1
print(('** Loaded %s models, got controlled errors for %s files' % (ok,err)))
if __name__ == '__main__':
run_tests()

71
port/PyAssimp3/sample.py 100644
View File

@ -0,0 +1,71 @@
#!/usr/bin/env python3
#-*- coding: UTF-8 -*-
"""
This module demonstrates the functionality of PyAssimp.
"""
from pyassimp import pyassimp
import os, sys
#get a model out of assimp's test-data if none is provided on the command line
DEFAULT_MODEL = os.path.join(os.path.dirname(__file__),
"..", "..",
"test", "models", "Collada", "duck.dae")
def main(filename=None):
filename = filename or DEFAULT_MODEL
scene = pyassimp.load(filename)
#the model we load
print("MODEL:", filename)
print()
#write some statistics
print("SCENE:")
print(" meshes:", len(scene.meshes))
print(" materials:", len(scene.materials))
print(" textures:", len(scene.textures))
print()
print("MESHES:")
for index, mesh in enumerate(scene.meshes):
print(" MESH", index+1)
print(" material:", mesh.mMaterialIndex+1)
print(" vertices:", len(mesh.vertices))
print(" first 3 verts:", mesh.vertices[:3])
#if len(mesh.normals):
# print " first 3 normals:", mesh.normals[:3]
print(" colors:", len(mesh.colors))
tc = mesh.texcoords
print(" texture-coords 1:", len(tc[0]), "first3:", tc[0][:3])
print(" texture-coords 2:", len(tc[1]), "first3:", tc[1][:3])
print(" texture-coords 3:", len(tc[2]), "first3:", tc[2][:3])
print(" texture-coords 4:", len(tc[3]), "first3:", tc[3][:3])
print(" uv-component-count:", len(mesh.mNumUVComponents))
print(" faces:", len(mesh.faces), "first:", [f.indices for f in mesh.faces[:3]])
print(" bones:", len(mesh.bones), "first:", [b.mName for b in mesh.bones[:3]])
print()
print("MATERIALS:")
for index, material in enumerate(scene.materials):
print(" MATERIAL", index+1)
properties = pyassimp.GetMaterialProperties(material)
for key in properties:
print(" %s: %s" % (key, properties[key]))
print()
print("TEXTURES:")
for index, texture in enumerate(scene.textures):
print(" TEXTURE", index+1)
print(" width:", texture.mWidth)
print(" height:", texture.mHeight)
print(" hint:", texture.achFormatHint)
print(" data (size):", texture.mWidth*texture.mHeight)
# Finally release the model
pyassimp.release(scene)
if __name__ == "__main__":
main(sys.argv[1] if len(sys.argv)>1 else None)