Namespace SharpAssimp

Classes

Animation

An animation consists of keyframe data for a number of nodes. For each node affected by the animation, a separate series of data is given.

AssimpContext

Represents an Assimp Import/Export context that load or save models using the unmanaged library. Additionally, conversion functionality is offered to bypass loading model data into managed memory.

Represents a single bone of a mesh. A bone has a name which allows it to 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 and a matrix relating the mesh position to the position of the bone at the time of binding.

Camera

Describes a right-handed camera in the scene. An important aspect is that the camera itself is also part of the scenegraph, meaning any values such as the direction vector are not absolute, they can be relative to the coordinate system defined by the node which corresponds to the camera. This allows for camera animations.

ConsoleLogStream

Log stream that writes messages to the Console.

EmbeddedTexture

Represents an embedded texture. Some file formats directly embed texture assets. Embedded textures may be uncompressed, where the data is given in an uncompressed format. Or it may be compressed in a format like png or jpg. In the latter case, the raw file bytes are given so the application must utilize an image decoder (e.g. DevIL) to get access to the actual color data. This object represents both types, so some properties may or may not be valid depending if it is compressed or not.

ExportDataBlob

Describes a blob of exported scene data. Blobs can be nested - each blob may reference another blob, which in turn can reference another and so on. This is used to allow exporters to write more than one output for a given scene, such as material files. Existence of such files depends on the format.

ExportFormatDescription

Describes a file format which Assimp can export to.

Face

A single face in a mesh, referring to multiple vertices. This can be a triangle if the index count is equal to three, or a polygon if the count is greater than three.

Since multiple primitive types can be contained in a single mesh, this approach allows you to better examine how the mesh is constructed. If you use the SortByPrimitiveType post process step flag during import, then each mesh will be homogenous where primitive type is concerned.

FileIOSystem

Simple implementation of an IOSystem that searches for files on the disk. This implementation can be given a number of search directories that it will attempt to locate the file in first, before using the file path given by Assimp. That way, you can load models that have files distributed in a number of other directories besides the root model's.

IOStream

Defines a stream to some file input or output source. This object is responsible for reading/writing data that is used by Assimp.

IOSystem

Defines a custom IO handler that can be registered to an importer that will handle I/O for assimp. This includes searching/opening files to read during import, and creating/writing to files during export.

ImporterDescription

Metadata and feature support information for a given importer.

Light

Describes a light source in the scene. Assimp supports multiple light sources including spot, point, and directional lights. All are defined by a single structure and distinguished by their parameters. Lights have corresponding nodes in the scenegraph.

Some file formats such as 3DS and ASE export a "target point", e.g. the point a spot light is looking at (it can even be animated). Assimp writes the target point as a subnode of a spotlight's main node called "spotName.Target". However, this is just additional information then, the transform tracks of the main node make the spot light already point in the right direction.

LogStream

Represents a log stream, which receives all log messages and streams them somewhere.

Material

A material contains all the information that describes how to render a mesh. E.g. textures, colors, and render states. Internally all this information is stored as key-value pair properties. The class contains many convienence methods and properties for accessing non-texture/texture properties without having to know the Assimp material key names. Not all properties may be present, and if they aren't a default value will be returned.

Material.PBRMaterialProperties

Groups all PBR workflow properties into a single accessor.

Material.ShaderMaterialProperties

Groups all the properties for shader sources in a single accessor.

MaterialProperty

A key-value pairing that represents some material property.

MemoryHelper

Helper static class containing functions that aid dealing with unmanaged memory to managed memory conversions.

Mesh

A mesh represents geometry with a single material.

MeshAnimationAttachment

A mesh attachment store per-vertex animations for a particular frame. You may think of this as a 'patch' for the host mesh, since the mesh attachment replaces only certain vertex data streams at a particular time. Each mesh stores 'n' attached meshes. The actual relationship between the time line and mesh attachments is established by the mesh animation channel, which references singular mesh attachments by their ID and binds them to a time offset.

MeshAnimationChannel

Describes vertex-based animations for a single mesh or a group of meshes. Meshes carry the animation data for each frame. The purpose of this object is to define keyframes, linking each mesh attachment to a particular point in a time.

MeshMorphAnimationChannel

Describes morph-based keyframe animations for a single mesh or a group of meshes.

MeshMorphKey

Binds a morph animation mesh to a specific point in time.

Metadata

Represents a container for holding metadata, representing as key-value pairs.

NativeCustomMarshalerAttribute

Attribute for assocating a type with an INativeCustomMarshaler instance.

Node

A node in the imported model hierarchy.

NodeAnimationChannel

Describes the animation of a single node. The name specifies the bone/node which is affected by this animation chanenl. The keyframes are given in three separate seties of values, one for each position, rotation, and scaling. The transformation matrix is computed from these values and replaces the node's original transformation matrix at a specific time.

This means all keys are absolute and not relative to the bone default pose. The order which the transformations are to be applied is scaling, rotation, and translation (SRT).

Keys are in chronological order and duplicate keys do not pass the validation step. There most likely will be no negative time values, but they are not forbidden.

NodeCollection

A collection of child nodes owned by a parent node. Manages access to the collection while maintaing parent-child linkage.

PostProcessPreset

Static class containing preset properties for post processing options.

Scene

Represents a completely imported model or scene. Everything that was imported from the given file can be accessed from here. Once the scene is loaded from unmanaged memory, it resides solely in managed memory and Assimp's read only copy is released.

Structs

BoundingBox

Represents an axis-aligned bounding box

Matrix3x3

Represents a 3x3 matrix. Assimp docs say their matrices are always row-major, and it looks like they're only describing the memory layout. Matrices are treated as column vectors however (X base in the first column, Y base the second, and Z base the third)

MeshKey

Binds an anim mesh (referenced by an index) to a specific point in time.

Metadata.Entry

Represents an entry in a metadata container.

QuaternionKey

Time-value pair specifying a rotation for a given time.

Ray

Defines a 3D ray with a point of origin and a direction.

Texel

Represents a texel in ARGB8888 format.

TextureSlot

Describes all the values pertaining to a particular texture slot in a material.

UVTransform

Defines how an UV channel is transformed.

VectorKey

Time-value pair specifying a 3D vector for a given time.

VertexWeight

Represents a single influence of a bone on a vertex.

Interfaces

IMarshalable<Managed, Native>

Represents an object that can be marshaled to and from a native representation.

INativeCustomMarshaler

Custom marshaler for usage with the MemoryHelper for performing marshaling to-and-from unmanaged memory for non-blittable types. A type must be attributed with NativeCustomMarshalerAttribute to automatically have an instance of its marshaler be utilized.

Enums

AnimationBehaviour

Defines an animation channel behaves outside the defined time range. This corresponds to the prestate and poststates of the animation node.

AnimationInterpolation

Defines the type of interpolation to use.

BlendMode

Defines alpha blending flags, how the final color value of a pixel is computed, based on the following equation:

sourceColor * sourceBlend + destColor * destBlend

Where the destColor is the previous color in the frame buffer and sourceColor is the material color before the transparency calculation. This corresponds to the AI_MATKEY_BLEND_FUNC property.

CompileFlags

Enumerates how the native Assimp DLL was compiled

DefaultLogStream

Enumerates predefined log streaming destinations.

ExcludeComponent

Enumerates components of the scene or mesh data that can be excluded from the import using the post process step RemoveComponent.

FileIOMode

Defines the desired file I/O mode is when opening a new file.

ImporterFeatureFlags

Defines flags that indicate level of support for common features for a given importer.

LightSourceType

Enumerates all supported light sources.

MeshMorphingMethod

Defines the methods of mesh morphing supported.

MetaDataType

Enumerates metadata data types.

Origin

Seek origins for Assimp's virtual file system API.

PostProcessSteps

Post processing flag options, specifying a number of steps that can be run on the data to either generate additional vertex data or optimize the imported data.

PrimitiveType

Enumerates geometric primitive types.

PropertyType

Defines material property types.

ReturnCode

Enumerates Assimp function result codes.

SceneFlags

Defines the state of the imported scene data structure.

ShadingMode

Defines all shading models supported by the library.

The list of shading modes has been taken from Blender. See Blender documentation for more information.

TextureFlags

Defines some mixed flags for a particular texture. This corresponds to the AI_MAT_KEY_TEXFLAGS property.

TextureMapping

Defines how texture coordinates are generated

Real-time applications typically require full UV coordinates. So the use of GenerateUVCoords step is highly recommended. It generates proper UV channels for non-UV mapped objects, as long as an accurate description of how the mapping should look like is given.

TextureOperation

Defines how the Nth texture of a specific type is combined with the result of all previous layers.

Example (left: key, right: value):

DiffColor0     - gray
DiffTextureOp0 - TextureOperation.Multiply
DiffTexture0   - tex1.png
DiffTextureOp0 - TextureOperation.Add
DiffTexture1   - tex2.png

Written as an equation, the final diffuse term for a specific pixel would be:

diffFinal = DiffColor0 * sampleTex(DiffTexture0, UV0) + sampleTex(DiffTexture1, UV0) * diffContrib;

Namespace SharpAssimp

Classes

Structs

Interfaces

Enums

Delegates