mdparker / derelict3 Goto Github PK

bindFunctions(
    "FT_Init_FreeType",
    "FT_Done_FreeType",
    "FT_New_Face",
    ...
);

derelict/lua/types.d(58): Error: struct derelict.lua.types.lua_State unknown size
derelict/lua/types.d(58): Error: struct derelict.lua.types.lua_State no size yet for forward reference

/*

Boost Software License - Version 1.0 - August 17th, 2003

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

*/
module derelict.assimp3.assimp;

public
{
    import derelict.assimp3.types;
    import derelict.assimp3.functions;
}

private
{
    import derelict.util.loader;
    import derelict.util.system;

    static if(Derelict_OS_Windows)
    {
        static if (size_t.sizeof == 4)
            enum libNames = "assimp.dll, Assimp32.dll";
        else static if (size_t.sizeof == 8)
            enum libNames = "assimp.dll, Assimp64.dll";
        else
            static assert(0);
    }
    else static if(Derelict_OS_Mac)
        enum libNames = "libassimp.dylib";
    else static if(Derelict_OS_Posix)
        enum libNames = "libassimp.so, libassimp.so.3, libassimp.so.3.0.0";
    else
        static assert(0, "Need to implement ASSIMP libNames for this operating system.");
}

class DerelictASSIMP3Loader : SharedLibLoader
{

    protected
    {
        override void loadSymbols()
        {
            bindFunc(cast(void**)&aiApplyPostProcessing, "aiApplyPostProcessing");
            bindFunc(cast(void**)&aiAttachLogStream, "aiAttachLogStream");
            bindFunc(cast(void**)&aiCopyScene, "aiCopyScene");
            bindFunc(cast(void**)&aiCreatePropertyStore, "aiCreatePropertyStore");
            bindFunc(cast(void**)&aiCreateQuaternionFromMatrix, "aiCreateQuaternionFromMatrix");
            bindFunc(cast(void**)&aiDecomposeMatrix, "aiDecomposeMatrix");
            bindFunc(cast(void**)&aiDetachAllLogStreams, "aiDetachAllLogStreams");
            bindFunc(cast(void**)&aiDetachLogStream, "aiDetachLogStream");
            bindFunc(cast(void**)&aiEnableVerboseLogging, "aiEnableVerboseLogging");
            bindFunc(cast(void**)&aiExportScene, "aiExportScene");
            bindFunc(cast(void**)&aiExportSceneEx, "aiExportSceneEx");
            bindFunc(cast(void**)&aiExportSceneToBlob, "aiExportSceneToBlob");
            bindFunc(cast(void**)&aiGetCompileFlags, "aiGetCompileFlags");
            bindFunc(cast(void**)&aiGetErrorString, "aiGetErrorString");
            bindFunc(cast(void**)&aiGetExportFormatCount, "aiGetExportFormatCount");
            bindFunc(cast(void**)&aiGetExportFormatDescription, "aiGetExportFormatDescription");
            bindFunc(cast(void**)&aiGetExtensionList, "aiGetExtensionList");
            bindFunc(cast(void**)&aiGetLegalString, "aiGetLegalString");
            bindFunc(cast(void**)&aiGetMaterialColor, "aiGetMaterialColor");
            bindFunc(cast(void**)&aiGetMaterialFloatArray, "aiGetMaterialFloatArray");
            bindFunc(cast(void**)&aiGetMaterialIntegerArray, "aiGetMaterialIntegerArray");
            bindFunc(cast(void**)&aiGetMaterialProperty, "aiGetMaterialProperty");
            bindFunc(cast(void**)&aiGetMaterialString, "aiGetMaterialString");
            bindFunc(cast(void**)&aiGetMaterialTexture, "aiGetMaterialTexture");
            bindFunc(cast(void**)&aiGetMaterialTextureCount, "aiGetMaterialTextureCount");
            bindFunc(cast(void**)&aiGetMemoryRequirements, "aiGetMemoryRequirements");
            bindFunc(cast(void**)&aiGetPredefinedLogStream, "aiGetPredefinedLogStream");
            bindFunc(cast(void**)&aiGetVersionMajor, "aiGetVersionMajor");
            bindFunc(cast(void**)&aiGetVersionMinor, "aiGetVersionMinor");
            bindFunc(cast(void**)&aiGetVersionRevision, "aiGetVersionRevision");
            bindFunc(cast(void**)&aiIdentityMatrix3, "aiIdentityMatrix3");
            bindFunc(cast(void**)&aiIdentityMatrix4, "aiIdentityMatrix4");
            bindFunc(cast(void**)&aiImportFile, "aiImportFile");
            bindFunc(cast(void**)&aiImportFileEx, "aiImportFileEx");
            bindFunc(cast(void**)&aiImportFileExWithProperties, "aiImportFileExWithProperties");
            bindFunc(cast(void**)&aiImportFileFromMemory, "aiImportFileFromMemory");
            bindFunc(cast(void**)&aiImportFileFromMemoryWithProperties, "aiImportFileFromMemoryWithProperties");
            bindFunc(cast(void**)&aiIsExtensionSupported, "aiIsExtensionSupported");
            bindFunc(cast(void**)&aiMultiplyMatrix3, "aiMultiplyMatrix3");
            bindFunc(cast(void**)&aiMultiplyMatrix4, "aiMultiplyMatrix4");
            bindFunc(cast(void**)&aiReleaseExportBlob, "aiReleaseExportBlob");
            bindFunc(cast(void**)&aiReleaseImport, "aiReleaseImport");
            bindFunc(cast(void**)&aiReleasePropertyStore, "aiReleasePropertyStore");
            bindFunc(cast(void**)&aiSetImportPropertyFloat, "aiSetImportPropertyFloat");
            bindFunc(cast(void**)&aiSetImportPropertyInteger, "aiSetImportPropertyInteger");
            bindFunc(cast(void**)&aiSetImportPropertyString, "aiSetImportPropertyString");
            bindFunc(cast(void**)&aiTransformVecByMatrix3, "aiTransformVecByMatrix3");
            bindFunc(cast(void**)&aiTransformVecByMatrix4, "aiTransformVecByMatrix4");
            bindFunc(cast(void**)&aiTransposeMatrix3, "aiTransposeMatrix3");
            bindFunc(cast(void**)&aiTransposeMatrix4, "aiTransposeMatrix4");
        }
    }

    public
    {
        this()
        {
            super(libNames);
        }
    }
}

__gshared DerelictASSIMP3Loader DerelictASSIMP3;

shared static this()
{
    DerelictASSIMP3 = new DerelictASSIMP3Loader();
}

shared static ~this()
{
    DerelictASSIMP3.unload();
}

/*

Boost Software License - Version 1.0 - August 17th, 2003

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

*/
module derelict.assimp3.types;


// assimp.h
extern (C) nothrow alias void function(const(char)*, char*) aiLogStreamCallback;

struct aiPropertyStore
{
    char sentinel;
}

struct aiLogStream
{
    aiLogStreamCallback callback;
    char* user;
}


// aiPostProcess.h
enum aiPostProcessSteps : uint
{
    CalcTangentSpace = 0x1,
    JoinIdenticalVertices = 0x2,
    MakeLeftHanded = 0x4,
    Triangulate = 0x8,
    RemoveComponent = 0x10,
    GenNormals = 0x20,
    GenSmoothNormals = 0x40,
    SplitLargeMeshes = 0x80,
    PreTransformVertices = 0x100,
    LimitBoneWeights = 0x200,
    ValidateDataStructure = 0x400,
    ImproveCacheLocality = 0x800,
    RemoveRedundantMaterials = 0x1000,
    FixInfacingNormals = 0x2000,
    SortByPType = 0x8000,
    FindDegenerates = 0x10000,
    FindInvalidData = 0x20000,
    GenUVCoords = 0x40000,
    TransformUVCoords = 0x80000,
    FindInstances = 0x100000,
    OptimizeMeshes = 0x200000,
    OptimizeGraph = 0x400000,
    FlipUVs = 0x800000,
    FlipWindingOrder = 0x1000000,
    aiProcess_SplitByBoneCount  = 0x2000000,
    aiProcess_Debone  = 0x4000000,
}

// aiAnim.h
struct aiVectorKey
{
    double mTime;
    aiVector3D mValue;
}

struct aiQuatKey
{
    double mTime;
    aiQuaternion mValue;
}

struct aiMeshKey
{
    double mTime;
    uint mValue;
}

enum aiAnimBehaviour : uint
{
    DEFAULT = 0x0,
    CONSTANT = 0x1,
    LINEAR = 0x2,
    REPEAT = 0x3,
}

struct aiNodeAnim
{
    aiString mNodeName;
    uint mNumPositionKeys;
    aiVectorKey* mPositionKEys;
    uint mNumRotationKeys;
    aiQuatKey* mRotationKeys;
    uint mNumScalingKeys;
    aiVectorKey* mScalingKeys;
    aiAnimBehaviour mPreState;
    aiAnimBehaviour mPostState;
}

struct aiMeshAnim
{
    aiString mName;
    uint mNumKeys;
    aiMeshKey* mKeys;
}

struct aiAnimation
{
    aiString mName;
    double mDuration;
    double mTicksPerSecond;
    uint mNumChannels;
    aiNodeAnim** mChannels;
    uint mNumMeshChannels;
    aiMeshAnim** mMeshChannels;
}


// aiMaterial.h
enum AI_DEFUALT_MATERIAL_NAME = "DefaultMaterial";

const uint AI_MAX_NUMBER_OF_COLOR_SETS = 0x8;
const uint AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x8;

enum aiTextureOp : uint
{
    Multiply = 0x0,
    Add = 0x1,
    Subtract = 0x2,
    Divide = 0x3,
    SmoothAdd = 0x4,
    SignedAdd = 0x5,
}

enum aiTextureMapMode : uint
{
    Wrap = 0x0,
    Clamp = 0x1,
    Decal = 0x3,
    Mirror = 0x2,
}

enum aiTextureMapping : uint
{
    UV = 0x0,
    SPHERE = 0x1,
    CYLINDER = 0x2,
    BOX = 0x3,
    PLANE = 0x4,
    OTHER = 0x5,
}

enum aiTextureType : uint
{
    NONE = 0x0,
    DIFFUSE = 0x1,
    SPECULAR = 0x2,
    AMBIENT = 0x3,
    EMISSIVE = 0x4,
    HEIGHT = 0x5,
    NORMALS = 0x6,
    SHININESS = 0x7,
    OPACITY = 0x8,
    DISPLACEMENT = 0x9,
    LIGHTMAP = 0xA,
    REFLECTION = 0xB,
    UNKNOWN = 0xC,
}

enum aiShadingMode : uint
{
    Flat = 0x1,
    Gouraud = 0x2,
    Phong = 0x3,
    Blinn = 0x4,
    Toon = 0x5,
    OrenNayar = 0x6,
    Minnaert = 0x7,
    CookTorrance = 0x8,
    NoShading = 0x9,
    Fresnel = 0xA,
}

enum aiTextureFlags : uint
{
    Invert = 0x1,
    UseAlpha = 0x2,
    IgnoreAlpha = 0x4,
}

enum aiBlendMode : uint
{
    Default = 0x0,
    Additive = 0x1,
}

struct aiUVTransform
{
    aiVector2D mTranslation;
    aiVector3D mScaling;
    float mRotation;
}

enum aiPropertyTypeInfo : uint
{
    Float = 0x1,
    String = 0x3,
    Integer = 0x4,
    Buffer = 0x5,
}

struct aiMaterialProperty
{
    aiString mKey;
    uint mSemantic;
    uint mIndex;
    uint mDataLength;
    aiPropertyTypeInfo mType;
    char* mData;
}

struct aiMaterial
{
    aiMaterialProperty** mProperties;
    uint mNumProperties;
    uint mNumAllocated;
}


// aiTexture.h
struct aiTexel
{
    ubyte b, g, r, a;
}

struct aiTexture
{
    uint mWidth;
    uint mHeight;
    char achFormatHint[4];
    aiTexel* pcData;
}


// aiLight.h
enum aiLightSourceType : uint
{
    UNDEFINED = 0x0,
    DIRECTIONAL = 0x1,
    POINT = 0x2,
    SPOT = 0x3,
}

struct aiLight
{
    aiString mName;
    aiLightSourceType mType;
    aiVector3D mPosition;
    aiVector3D mDirection;
    float mAttenuationConstant;
    float mAttenuationLinear;
    float mAttentuationQuadratic;
    aiColor3D mColorDiffuse;
    aiColor3D mColorSpecular;
    aiColor3D mColorAmbient;
    float mAngleInnerCone;
    float mAngleOuterCone;
}


// aiCamera.h
struct aiCamera
{
    aiString mName;
    aiVector3D mPosition;
    aiVector3D mUp;
    aiVector3D mLookAt;
    float mHorizontalFOV;
    float mClipPlaneNear;
    float mClipPlaneFar;
    float mAspect;
}


// aiFileIO.h
extern (C) nothrow
{
    alias size_t function(aiFile*, const char*, size_t, size_t) aiFileWriteProc;
    alias size_t function(aiFile*, char*, size_t, size_t) aiFileReadProc;
    alias size_t function(aiFile*) aiFileTellProc;
    alias void function(aiFile*) aiFileFlushProc;
    alias aiReturn function(aiFile*, size_t, aiOrigin) aiFileSeekProc;

    alias aiFile* function(aiFileIO*, const char*, const char*) aiFileOpenProc;
    alias void function(aiFileIO*, aiFile*) aiFileCloseProc;

    alias char* aiUserData;
}

struct aiFileIO
{
    aiFileOpenProc OpenProc;
    aiFileCloseProc CloseProc;
    aiUserData UserData;
}

struct aiFile
{
    aiFileReadProc ReadProc;
    aiFileWriteProc WriteProc;
    aiFileTellProc TellProc;
    aiFileTellProc FileSizeProc;
    aiFileSeekProc SeekProc;
    aiFileFlushProc FlushProc;
    aiUserData UserData;
}


// aiVector2D.h
struct aiVector2D
{
    float x, y;
}


// aiVector3D.h
struct aiVector3D
{
    float x, y, z;
}


// aiQuaternion.h
struct aiQuaternion
{
    float w, x, y, z;
}


// aiMatrix3x3.h
struct aiMatrix3x3
{
    float a1, a2, a3;
    float b1, b2, b3;
    float c1, c2, c3;
}


// aiMatrix4x4.h
struct aiMatrix4x4
{
    float a1, a2, a3, a4;
    float b1, b2, b3, b4;
    float c1, c2, c3, c4;
    float d1, d2, d3, d4;
}


// aiColor4D.h
struct aiColor4D
{
    float r, g, b, a;
}


// aiMesh.h
struct aiFace
{
    uint mNumIndices;
    uint* mIndices;
}

struct aiVertexWeight
{
    uint mVertexId;
    float mWeight;
}

struct aiBone
{
    aiString mName;
    uint mnumWeights;
    aiVertexWeight* mWeights;
    aiMatrix4x4 mOffsetMatrix;
}

enum aiPrimitiveType : uint
{
    POINT = 0x1,
    LINE = 0x2,
    TRIANGLE = 0x4,
    POLYGON = 0x8,
}

struct aiAnimMesh
{
    aiVector3D* mVertices;
    aiVector3D* mNormals;
    aiVector3D* mTangents;
    aiVector3D* mBitangents;
    aiColor4D* mColor[AI_MAX_NUMBER_OF_COLOR_SETS];
    aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
    uint mNumVertices;
}

struct aiMesh
{
    uint mPrimitiveTypes;
    uint mNumVertices;
    uint mNumFaces;
    aiVector3D* mVertices;
    aiVector3D* mNormals;
    aiVector3D* mTangents;
    aiVector3D* mBitangents;
    aiColor4D * mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
    aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
    uint mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS];
    aiFace* mFaces;
    uint mNumBones;
    aiBone** mBones;
    uint mMaterialIndex;
    aiString mName;
    uint mNumAnimMeshes;
    aiAnimMesh** mAnimMeshes;
}


// aiScene.h
struct aiNode
{
    aiString mName;
    aiMatrix4x4 mTransformation;
    aiNode* mParent;
    uint mNumChildren;
    aiNode** mChildren;
    uint mNumMeshes;
    uint* mMeshes;
}

struct aiScene
{
    uint mFlags;
    aiNode* mRootNode;
    uint mNumMeshes;
    aiMesh** mMeshes;
    uint mNumMaterials;
    aiMaterial** mMaterials;
    uint mNumAnimations;
    aiAnimation** mAnimations;
    uint mNumTextures;
    aiTexture** mTextures;
    uint mNumLights;
    aiLight** mLights;
    uint mNumCameras;
    aiCamera** mCameras;
}


// aiTypes.h
struct aiPlane
{
    float a, b, c, d;
}

struct aiRay
{
    aiVector3D pos, dir;
}

struct aiColor3D
{
    float r, g, b;
}

struct aiString
{
    size_t length;
    char data[MAXLEN];
}

enum aiReturn : int
{
    SUCCESS = 0x0,
    FAILURE = -0x1,
    OUTOFMEMORY = -0x3,
}

enum aiOrigin : uint
{
    SET = 0x0,
    CUR = 0x1,
    END = 0x2,
}

enum aiDefaultLogStream : int
{
    FILE = 0x1,
    STDOUT = 0x2,
    STDERR = 0x4,
    DEBUGGER = 0x8,
}

struct aiMemoryInfo
{
    uint textures;
    uint materials;
    uint meshes;
    uint nodes;
    uint animations;
    uint cameras;
    uint lights;
    uint total;
}

const size_t MAXLEN = 1024;

alias int aiBool;

enum AI_FALSE = 0,
     AI_TRUE = 1;


// version.h
enum ASSIMP_CFLAGS_SHARED = 0x1,
     ASSIMP_CFLAGS_STLPORT = 0x2,
     ASSIMP_CFLAGS_DEBUG = 0x4,
     ASSIMP_CFLAGS_NOBOOST = 0x8,
     ASSIMP_CFLAGS_SINGLETHREADED = 0x10;

// cexport.h
struct aiExportDataBlob 
{
    size_t size;
    void* data;
    aiString name;
    aiExportDataBlob* next;
}

struct aiExportFormatDesc
{
    const(char)* id;
    const(char)* description;
    const(char)* fileExtension;
};

/*

Boost Software License - Version 1.0 - August 17th, 2003

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

*/
module derelict.assimp3.functions;

private
{
    import derelict.assimp3.types;
}

extern(C)
{
    alias nothrow const(aiScene)* function(const(char)*, uint) da_aiImportFile;
    alias nothrow const(aiScene)* function(const(char)*, uint, aiFileIO*) da_aiImportFileEx;
    alias nothrow const(aiScene)* function(const(char)*, uint, aiFileIO*, aiPropertyStore*) da_aiImportFileExWithProperties;
    alias nothrow const(aiScene)* function(const(char)*, uint, uint, const(char)*) da_aiImportFileFromMemory;
    alias nothrow const(aiScene)* function(const(char)*, uint, uint, const(char)*, aiPropertyStore*) da_aiImportFileFromMemoryWithProperties;
    alias nothrow const(aiScene)* function(const(aiScene)*, uint) da_aiApplyPostProcessing;
    alias nothrow aiLogStream function(aiDefaultLogStream, const(char)*) da_aiGetPredefinedLogStream;
    alias nothrow void function(const(aiLogStream)*) da_aiAttachLogStream;
    alias nothrow void function(aiBool) da_aiEnableVerboseLogging;
    alias nothrow aiReturn function(const(aiLogStream)*) da_aiDetachLogStream;
    alias nothrow void function() da_aiDetachAllLogStreams;
    alias nothrow void function(const(aiScene)*) da_aiReleaseImport;
    alias nothrow const(char)* function() da_aiGetErrorString;
    alias nothrow aiBool function(const(char)*) da_aiIsExtensionSupported;
    alias nothrow void function(aiString*) da_aiGetExtensionList;
    alias nothrow void function(const(aiScene)*, aiMemoryInfo*) da_aiGetMemoryRequirements;
    alias nothrow aiPropertyStore* function() da_aiCreatePropertyStore;
    alias nothrow void function(aiPropertyStore*) da_aiReleasePropertyStore;
    alias nothrow void function(aiPropertyStore*, const(char)*, int) da_aiSetImportPropertyInteger;
    alias nothrow void function(aiPropertyStore*, const(char)*, float) da_aiSetImportPropertyFloat;
    alias nothrow void function(aiPropertyStore*, const(char)*, const(aiString)*) da_aiSetImportPropertyString;
    alias nothrow void function(aiQuaternion*, const(aiMatrix3x3)*) da_aiCreateQuaternionFromMatrix;
    alias nothrow void function(const aiMatrix4x4*, aiVector3D*, aiQuaternion*, aiVector3D*) da_aiDecomposeMatrix;
    alias nothrow void function(aiMatrix4x4*) da_aiTransposeMatrix4;
    alias nothrow void function(aiMatrix3x3*) da_aiTransposeMatrix3;
    alias nothrow void function(aiVector3D*, const(aiMatrix3x3)*) da_aiTransformVecByMatrix3;
    alias nothrow void function(aiVector3D*, const(aiMatrix4x4)*) da_aiTransformVecByMatrix4;
    alias nothrow void function(aiMatrix4x4*, const(aiMatrix4x4)*) da_aiMultiplyMatrix4;
    alias nothrow void function(aiMatrix3x3*, const(aiMatrix3x3)*) da_aiMultiplyMatrix3;
    alias nothrow void function(aiMatrix3x3*) da_aiIdentityMatrix3;
    alias nothrow void function(aiMatrix4x4*) da_aiIdentityMatrix4;
    alias nothrow const(char)* function() da_aiGetLegalString;
    alias nothrow uint function() da_aiGetVersionMinor;
    alias nothrow uint function() da_aiGetVersionMajor;
    alias nothrow uint function() da_aiGetVersionRevision;
    alias nothrow uint function() da_aiGetCompileFlags;

    // from material.h
    alias nothrow aiReturn function(const(aiMaterial)*, const(char)*, uint, uint, const(aiMaterialProperty*)*) da_aiGetMaterialProperty;
    alias nothrow aiReturn function(const(aiMaterial)*, const(char)*, uint, uint, float*, uint*) da_aiGetMaterialFloatArray;
    alias nothrow aiReturn function(const(aiMaterial)*, const(char)*, uint, uint, int*, uint*) da_aiGetMaterialIntegerArray;
    alias nothrow aiReturn function(const(aiMaterial)*, const(char)*, uint, uint, aiColor4D*) da_aiGetMaterialColor;
    alias nothrow aiReturn function(const(aiMaterial)*, const(char)*, uint, uint, aiString*) da_aiGetMaterialString;
    alias nothrow aiReturn function(const(aiMaterial)*, aiTextureType) da_aiGetMaterialTextureCount;
    alias nothrow aiReturn function(const(aiMaterial)*, aiTextureType, uint, aiString*, aiTextureMapping*, uint*, float*, aiTextureOp*, aiTextureMapMode*, uint*) da_aiGetMaterialTexture;

    // from cexport.h
    alias nothrow void function(const(aiScene)*, aiScene**) da_aiCopyScene;

    alias nothrow aiReturn function(const(aiScene)*, const(char)*, const(char)*, uint) da_aiExportScene;
    alias nothrow aiReturn function(const(aiScene)*, const(char)*, const(char)*, aiFileIO*, uint) da_aiExportSceneEx;

    alias nothrow const(aiExportDataBlob)* function(const(aiScene)*, const(char)*, uint) da_aiExportSceneToBlob;
    alias nothrow void function(const(aiExportDataBlob)*) da_aiReleaseExportBlob;

    alias nothrow size_t function() da_aiGetExportFormatCount;

    alias nothrow const(aiExportFormatDesc)* function(size_t) da_aiGetExportFormatDescription;
}

__gshared
{
    da_aiApplyPostProcessing aiApplyPostProcessing;
    da_aiAttachLogStream aiAttachLogStream;
    da_aiCopyScene aiCopyScene;
    da_aiCreatePropertyStore aiCreatePropertyStore;
    da_aiCreateQuaternionFromMatrix aiCreateQuaternionFromMatrix;
    da_aiDecomposeMatrix aiDecomposeMatrix;
    da_aiDetachAllLogStreams aiDetachAllLogStreams;
    da_aiDetachLogStream aiDetachLogStream;
    da_aiEnableVerboseLogging aiEnableVerboseLogging;
    da_aiExportScene aiExportScene;
    da_aiExportSceneEx aiExportSceneEx;
    da_aiExportSceneToBlob aiExportSceneToBlob;
    da_aiGetCompileFlags aiGetCompileFlags;
    da_aiGetErrorString aiGetErrorString;
    da_aiGetExportFormatCount aiGetExportFormatCount;
    da_aiGetExportFormatDescription aiGetExportFormatDescription;
    da_aiGetExtensionList aiGetExtensionList;
    da_aiGetLegalString aiGetLegalString;
    da_aiGetMaterialColor aiGetMaterialColor;
    da_aiGetMaterialFloatArray aiGetMaterialFloatArray;
    da_aiGetMaterialIntegerArray aiGetMaterialIntegerArray;
    da_aiGetMaterialProperty aiGetMaterialProperty;
    da_aiGetMaterialString aiGetMaterialString;
    da_aiGetMaterialTexture aiGetMaterialTexture;
    da_aiGetMaterialTextureCount aiGetMaterialTextureCount;
    da_aiGetMemoryRequirements aiGetMemoryRequirements;
    da_aiGetPredefinedLogStream aiGetPredefinedLogStream;
    da_aiGetVersionMajor aiGetVersionMajor;
    da_aiGetVersionMinor aiGetVersionMinor;
    da_aiGetVersionRevision aiGetVersionRevision;
    da_aiIdentityMatrix3 aiIdentityMatrix3;
    da_aiIdentityMatrix4 aiIdentityMatrix4;
    da_aiImportFile aiImportFile;
    da_aiImportFileEx aiImportFileEx;
    da_aiImportFileExWithProperties aiImportFileExWithProperties;
    da_aiImportFileFromMemory aiImportFileFromMemory;
    da_aiImportFileFromMemoryWithProperties aiImportFileFromMemoryWithProperties;
    da_aiIsExtensionSupported aiIsExtensionSupported;
    da_aiMultiplyMatrix3 aiMultiplyMatrix3;
    da_aiMultiplyMatrix4 aiMultiplyMatrix4;
    da_aiReleaseExportBlob aiReleaseExportBlob;
    da_aiReleaseImport aiReleaseImport;
    da_aiReleasePropertyStore aiReleasePropertyStore;
    da_aiSetImportPropertyFloat aiSetImportPropertyFloat;
    da_aiSetImportPropertyInteger aiSetImportPropertyInteger;
    da_aiSetImportPropertyString aiSetImportPropertyString;
    da_aiTransformVecByMatrix3 aiTransformVecByMatrix3;
    da_aiTransformVecByMatrix4 aiTransformVecByMatrix4;
    da_aiTransposeMatrix3 aiTransposeMatrix3;
    da_aiTransposeMatrix4 aiTransposeMatrix4;
}

derelict/lua/macros.d(128): Error: cannot implicitly convert expression ((*luaL_checkinteger)(L, n)) of type long to int
derelict/lua/macros.d(131): Error: cannot implicitly convert expression ((*luaL_optinteger)(L, n, d)) of type long to int

define AI_MAX_NUMBER_OF_COLOR_SETS 0x8
define AI_MAX_NUMBER_OF_TEXTURECOORDS 0x8

const uint AI_MAX_NUMBER_OF_COLOR_SETS = 0x4;
const uint AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x4;

[mfag@mfag-tpad lighthouse]$ cat test.d
int main() {
    DerelictSDL2.load();
    return 0;
}
[mfag@mfag-tpad lighthouse]$ dmd test.d -L-lSDL2 -L-ldl -L-lDerelictSDL2 -L-lDerelictUtil
[mfag@mfag-tpad lighthouse]$ ./test
derelict.util.exception.SymbolLoadException@../import/derelict/util/exception.d(38): Failed to load symbol SDL_JoystickOpened from shared library libSDL2.so
----------------
./test(void derelict.util.loader.SharedLibLoader.bindFunc(void**, immutable(char)[], bool)+0x7d) [0x4306a9]
./test(void derelict.sdl2.sdl.DerelictSDL2Loader.loadSymbols()+0x116a) [0x42d97e]
./test(void derelict.util.loader.SharedLibLoader.load(immutable(char)[][])+0x2f) [0x430553]
./test(void derelict.util.loader.SharedLibLoader.load(immutable(char)[])+0xa4) [0x43051c]
./test(void derelict.util.loader.SharedLibLoader.load()+0x18) [0x430470]
./test(_Dmain+0x12) [0x42c752]
./test(extern (C) int rt.dmain2.main(int, char**).void runMain()+0x1c) [0x4355f8]
./test(extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate())+0x2a) [0x434f72]
./test(extern (C) int rt.dmain2.main(int, char**).void runAll()+0x3b) [0x43563f]
./test(extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate())+0x2a) [0x434f72]
./test(main+0xd1) [0x434efd]
/usr/lib/libc.so.6(__libc_start_main+0xf5) [0x7fe5ba134725]
----------------

[...]
../import/derelict/opengl3/glx.d(177): Error: expected 3 function arguments, not 2
../import/derelict/opengl3/glx.d(178): Error: expected 3 function arguments, not 2
[...]
../import/derelict/opengl3/glx.d(198): Error: expected 3 function arguments, not 2
[...]
Building DerelictSFML2

std.file.FileException@std/file.d(2514): ../import/derelict/sfml2/: No such file or directory
[...]

#define GLFW_RESIZABLE            0x00022007

GLFW_WINDOW_RESIZABLE     = 0x0002100D,

alias void function(GLFWwindow, double, double) GLFWscrollfun;