【转】Cal3d的DELPHI的PAS文件。

从一个老外的BLOG上找到的，准备在引擎中使用。Cal3d是个很强的骨骼系统，很多虚拟现实系统都使用这个。本人做了略微略微的修改，但并不大，就增加 了个DLLPATH，呵呵。用的时候只要修改下这个就好了。

{
        $Id: cal3d.pas,v 1.4 2003/05/31 23:14:44 pythian Exp $
        Description:     Delphi header file for cal3d.dll library
        Author:          Elessar (elessar@wladca.pl)
        Created on:      15.11.2001
}

unit VRCal3d;

interface

uses windows, sysutils;

const

  DLLPath = '..\..\引擎部分\外部DLL\';

  //file magic cookies
  SKELETON_FILE_MAGIC: array[0..3] of char = ('C', 'S', 'F', #0);
  ANIMATION_FILE_MAGIC: array[0..3] of char = ('C', 'A', 'F', #0);
  MESH_FILE_MAGIC: array[0..3] of char = ('C', 'M', 'F', #0);
  MATERIAL_FILE_MAGIC: array[0..3] of char = ('C', 'R', 'F', #0);

  //library version
  LIBRARY_VERSION = 600;

  //file version
  CURRENT_FILE_VERSION: Cardinal = LIBRARY_VERSION;
  EARLIEST_COMPATIBLE_FILE_VERSION = 600;

  //maximum array ranges
  MAX_SINGLE = 29999;
  MAX_INT = 29999;

type
  //some additional types
  PByte = ^Byte;
  PInteger = ^Integer;
  PSingle = ^Single;

  PSingleArray = array of single;
  PByteArray = array of byte;
  PIntArray = array of integer;
  PStringArray = array of string;

  PCalSingleArray = ^CalSingleArray;
  CalSingleArray = array[0..MAX_SINGLE] of single;
  PCalIntArray = ^CalIntArray;
  CalIntArray = array[0..MAX_INT] of integer;

  PCalColorBuf = ^CalColorBuf;
  CalColorBuf = array[0..3] of byte;

  //Some cal3d functions return pointers to standard c++ objects, these ones
  //are impossible to use in delphi, however, I do not consider them important
  //for programs that use cal3d, they are used rather internally
  StdList = class
  end;
  StdMap = class
  end;
  StdVector = class
  end;

  CalUserData = Pointer;

  PCalColor = ^CalColor;
  CalColor = record
    red: byte;
    green: byte;
    blue: byte;
    alpha: byte;
  end;

  PCalMap = ^CalMap;
  CalMap = record
    strFilename: PChar;
    userData: CalUserData;
  end;

  PCalFace = ^CalFace;
  CalFace = array[0..2] of Integer;

  PCalTextureCoordinate = ^CalTextureCoordinate;
  CalTextureCoordinate = record
    u: single;
    v: single;
  end;

  PCalInfluence = ^CalInfluence;
  CalInfluence = record
    boneId: integer;
    weight: single;
    x, y, z: single;
    nx, ny, nz: single;
  end;

  PCalVertex = ^CalVertex;
  CalVertex = record
    vectorInfluence: StdVector;
    collapseId: integer;
    faceCollapseCount: integer;
  end;

{
  CalQuaternion = class
  end;
  CalVector = class
  end;
}
  CalQuaternion = ^CalQuaternionRec;
  CalQuaternionRec = record
    x, y, z, w: Single;
  end;
  CalVector = ^CalVectorRec;
  CalVectorRec = record
    x, y, z: Single;
  end;
 

  CalAnimation = class
  end;
  CalAnimationAction = class
  end;
  CalAnimationCycle = class
  end;
  CalCoreAnimation = class
  end;
  CalCoreKeyframe = class
  end;
  CalCoreTrack = class
  end;
  CalCoreMaterial = class
  end;
  CalCoreMesh = class
  end;
  CalCoreModel = class
  end;
  CalCoreSubmesh = class
  end;
  CalCoreSkeleton = class
  end;
  CalBone = class
  end;
  CalCoreBone = class
  end;
  CalSkeleton = class
  end;
  CalLoader = class
  end;
  CalSaver = class
  end;
  CalModel = class
  end;
  CalMixer = class
  end;
  CalMesh = class
  end;
  CalRenderer = class
  end;
  CalSubmesh = class
  end;

var
  // *** CalAnimation ***
  Animation_Destroy: procedure(self: CalAnimation); cdecl;
  Animation_GetCoreAnimation: function(self: CalAnimation): CalCoreAnimation;
    cdecl;
  Animation_GetState: function(self: CalAnimation): cardinal; cdecl;
  Animation_GetTime: function(self: CalAnimation): single; cdecl;
  Animation_GetType: function(self: CalAnimation): cardinal; cdecl;

  // *** CalAnimationAction ***
  AnimationAction_New: function(): CalAnimationAction; cdecl;
  AnimationAction_Delete: procedure(self: CalAnimationAction); cdecl;
  AnimationAction_Create: function(self: CalAnimationAction; pCoreAnimation:
    CalCoreAnimation): boolean; cdecl;
  AnimationAction_Destroy: procedure(self: CalAnimationAction); cdecl;
  AnimationAction_Execute: function(self: CalAnimationAction; delayIn, delayOut:
    single): boolean; cdecl;
  AnimationAction_GetWeight: function(self: CalAnimationAction): single; cdecl;
  AnimationAction_Update: function(self: CalAnimationAction; deltaTime: single):
    boolean; cdecl;

  // *** CalAnimationCycle ***
  AnimationCycle_New: function(): CalAnimationCycle; cdecl;
  AnimationCycle_Delete: procedure(self: CalAnimationCycle); cdecl;
  AnimationCycle_Blend: function(self: CalAnimationCycle; weight, delay:
    single): boolean; cdecl;
  AnimationCycle_Create: function(self: CalAnimationCycle; pCoreAnimation:
    CalCoreAnimation): boolean; cdecl;
  AnimationCycle_Destroy: procedure(self: CalAnimationCycle); cdecl;
  AnimationCycle_GetWeight: function(self: CalAnimationCycle): single; cdecl;
  AnimationCycle_SetAsync: procedure(self: CalAnimationCycle; time, duration:
    single); cdecl;
  AnimationCycle_Update: function(self: CalAnimationCycle; deltaTime: single):
    boolean; cdecl;

  // *** CalBone ***
  Bone_New: function(): CalBone; cdecl;
  Bone_Delete: procedure(self: CalBone); cdecl;
  Bone_BlendState: procedure(self: CalBone; weight: single; translation:
    CalVector; rotation: CalQuaternion); cdecl;
  Bone_CalculateState: procedure(self: CalBone); cdecl;
  Bone_ClearState: procedure(self: CalBone); cdecl;
  Bone_Create: function(self: CalBone; pCoreBone: CalCoreBone): boolean; cdecl;
  Bone_Destroy: procedure(self: CalBone); cdecl;
  Bone_GetCoreBone: function(self: CalBone): CalCoreBone; cdecl;
  Bone_GetRotation: function(self: CalBone): CalQuaternion; cdecl;
  Bone_GetRotationAbsolute: function(self: CalBone): CalQuaternion; cdecl;
  Bone_GetRotationBoneSpace: function(self: CalBone): CalQuaternion; cdecl;
  Bone_GetTranslation: function(self: CalBone): CalVector; cdecl;
  Bone_GetTranslationAbsolute: function(self: CalBone): CalVector; cdecl;
  Bone_GetTranslationBoneSpace: function(self: CalBone): CalVector; cdecl;
  Bone_LockState: procedure(self: CalBone); cdecl;
  Bone_SetSkeleton: procedure(self: CalBone; pSkeleton: CalSkeleton); cdecl;

  // *** CalCoreAnimation ***
  CoreAnimation_New: function(): CalCoreAnimation; cdecl;
  CoreAnimation_Delete: procedure(self: CalCoreAnimation); cdecl;
  CoreAnimation_AddCoreTrack: function(self: CalCoreAnimation; pCoreTrack:
    CalCoreTrack): Boolean; cdecl;
  CoreAnimation_Create: function(self: CalCoreAnimation): boolean; cdecl;
  CoreAnimation_Destroy: procedure(self: CalCoreAnimation); cdecl;
  CoreAnimation_GetCoreTrack: function(self: CalCoreAnimation; coreBoneId:
    integer): CalCoreTrack; cdecl;
  CoreAnimation_GetDuration: function(self: CalCoreAnimation): single; cdecl;
  CoreAnimation_GetListCoreTrack: function(self: CalCoreAnimation): StdList;
    cdecl;
  CoreAnimation_SetDuration: procedure(self: CalCoreAnimation; duration:
    single); cdecl;

  // *** CalCoreBone ***          骨头
  CoreBone_New: function(): CalCoreBone; cdecl;
  CoreBone_Delete: procedure(self: CalCoreBone); cdecl;
  CoreBone_AddChildId: function(self: CalCoreBone; childId: integer): boolean;
    cdecl;
  CoreBone_CalculateState: procedure(self: CalCoreBone); cdecl;
  CoreBone_Create: function(self: CalCoreBone; strName: PChar): boolean; cdecl;
  CoreBone_Destroy: procedure(self: CalCoreBone); cdecl;
  CoreBone_GetListChildId: function(self: CalCoreBone): StdList; cdecl;
  CoreBone_GetName: function(self: CalCoreBone): PChar; cdecl;
  CoreBone_GetParentId: function(self: CalCoreBone): integer; cdecl;
  CoreBone_GetRotation: function(self: CalCoreBone): CalQuaternion; cdecl;
  CoreBone_GetRotationAbsolute: function(self: CalCoreBone): CalQuaternion;
    cdecl;
  CoreBone_GetTranslation: function(self: CalCoreBone): CalVector; cdecl;
  CoreBone_GetTranslationAbsolute: function(self: CalCoreBone): CalVector;
    cdecl;
  CoreBone_GetUserData: function(self: CalCoreBone): CalUserData; cdecl;
  CoreBone_SetCoreSkeleton: procedure(self: CalCoreBone; pCoreSkeleton:
    CalCoreSkeleton); cdecl;
  CoreBone_SetParentId: procedure(self: CalCoreBone; parentId: integer); cdecl;
  CoreBone_SetRotation: procedure(self: CalCoreBone; rotation: CalQuaternion);
    cdecl;
  CoreBone_SetTranslation: procedure(self: CalCoreBone; translation: CalVector);
    cdecl;
  CoreBone_SetUserData: procedure(self: CalCoreBone; userData: CalUserData);
    cdecl;

  // *** CalCoreKeyFrame ***       关键帧
  CoreKeyframe_New: function(): CalCoreKeyframe; cdecl;
  CoreKeyframe_Delete: procedure(self: CalCoreKeyframe); cdecl;
  CoreKeyframe_Create: function(self: CalCoreKeyframe): boolean; cdecl;
  CoreKeyframe_Destroy: procedure(self: CalCoreKeyframe); cdecl;
  CoreKeyframe_GetRotation: function(self: CalCoreKeyframe): CalQuaternion;
    cdecl;
  CoreKeyframe_GetTime: function(self: CalCoreKeyframe): single; cdecl;
  CoreKeyframe_GetTranslation: function(self: CalCoreKeyframe): CalVector;
    cdecl;
  CoreKeyframe_SetRotation: procedure(self: CalCoreKeyframe; rotation:
    CalQuaternion); cdecl;
  CoreKeyframe_SetTime: procedure(self: CalCoreKeyframe; time: single); cdecl;
  CoreKeyframe_SetTranslation: procedure(self: CalCoreKeyframe; translation:
    CalVector); cdecl;

  // *** CalCoreMaterial ***
  CoreMaterial_New: function(): CalCoreMaterial; cdecl;
  CoreMaterial_Delete: procedure(self: CalCoreMaterial); cdecl;
  CoreMaterial_Create: function(self: CalCoreMaterial): boolean; cdecl;
  CoreMaterial_Destroy: procedure(self: CalCoreMaterial); cdecl;
  CoreMaterial_GetAmbientColor: function(self: CalCoreMaterial): PCalColor;
    cdecl;
  CoreMaterial_GetDiffuseColor: function(self: CalCoreMaterial): PCalColor;
    cdecl;
  CoreMaterial_GetMapCount: function(self: CalCoreMaterial): integer; cdecl;
  CoreMaterial_GetMapFilename: function(self: CalCoreMaterial; mapId: integer):
    PChar; cdecl;
  CoreMaterial_GetMapUserData: function(self: CalCoreMaterial; mapId: integer):
    CalUserData; cdecl;
  CoreMaterial_GetShininess: function(self: CalCoreMaterial): single; cdecl;
  CoreMaterial_GetSpecularColor: function(self: CalCoreMaterial): PCalColor;
    cdecl;
  CoreMaterial_GetUserData: function(self: CalCoreMaterial): CalUserData; cdecl;
  CoreMaterial_GetVectorMap: function(self: CalCoreMaterial): StdVector; cdecl;
  CoreMaterial_Reserve: function(self: CalCoreMaterial; mapCount: integer):
    boolean; cdecl;
  CoreMaterial_SetMUserData: procedure(self: CalCoreMaterial; mapId: integer;
    userData: CalUserData); cdecl;
  CoreMaterial_SetAmbientColor: procedure(self: CalCoreMaterial; ambientColor:
    PCalColor); cdecl;
  CoreMaterial_SetDiffuseColor: procedure(self: CalCoreMaterial; diffuseColor:
    PCalColor); cdecl;
  CoreMaterial_SetMap: function(self: CalCoreMaterial; id: integer; map:
    PCalMap): boolean; cdecl;
  CoreMaterial_SetMapUserData: function(self: CalCoreMaterial; mapId: integer;
    userData: CalUserData): boolean; cdecl;
  CoreMaterial_SetShininess: procedure(self: CalCoreMaterial; shininess:
    single); cdecl;
  CoreMaterial_SetSpecularColor: procedure(self: CalCoreMaterial; specularColor:
    PCalColor); cdecl;
  CoreMaterial_SetUserData: procedure(self: CalCoreMaterial; userData:
    CalUserData); cdecl;

  // *** CalCoreMesh ***
  CoreMesh_New: function(): CalCoreMesh; cdecl;
  CoreMesh_Delete: procedure(self: CalCoreMesh); cdecl;
  CoreMesh_AddCoreSubmesh: function(self: CalCoreMesh; pCoreSubmesh:
    CalCoreSubmesh): integer; cdecl;
  CoreMesh_Create: function(self: CalCoreMesh): boolean; cdecl;
  CoreMesh_Destroy: procedure(self: CalCoreMesh); cdecl;
  CoreMesh_GetCoreSubmesh: function(self: CalCoreMesh; id: integer):
    CalCoreSubmesh; cdecl;
  CoreMesh_GetCoreSubmeshCount: function(self: CalCoreMesh): integer; cdecl;
  CoreMesh_GetVectorCoreSubmesh: function(self: CalCoreMesh): StdVector; cdecl;

  // *** CalCoreModel ***
  CoreModel_New: function(): CalCoreModel; cdecl;
  CoreModel_Delete: procedure(self: CalCoreModel); cdecl;
  CoreModel_AddCoreAnimation: function(self: CalCoreModel; pCoreAnimation:
    CalCoreAnimation): integer; cdecl;
  CoreModel_AddCoreMaterial: function(self: CalCoreModel; pCoreMaterial:
    CalCoreMaterial): integer; cdecl;
  CoreModel_AddCoreMesh: function(self: CalCoreModel; pCoreMesh: CalCoreMesh):
    integer; cdecl;
  CoreModel_Create: function(self: CalCoreModel; strName: PChar): boolean;
    cdecl;
  CoreModel_CreateCoreMaterialThread: function(self: CalCoreModel;
    coreMaterialThreadId: integer): boolean; cdecl;
  CoreModel_Destroy: procedure(self: CalCoreModel); cdecl;
  CoreModel_GetCoreAnimation: function(self: CalCoreModel; id: integer):
    CalCoreAnimation; cdecl;
  CoreModel_GetCoreAnimationCount: function(self: CalCoreModel): integer; cdecl;
  CoreModel_GetCoreMaterial: function(self: CalCoreModel; id: integer):
    CalCoreMaterial; cdecl;
  CoreModel_GetCoreMaterialCount: function(self: CalCoreModel): integer; cdecl;
  CoreModel_GetCoreMaterialId: function(self: CalCoreModel;
    coreMaterialThreadId, setId: integer): integer; cdecl;
  CoreModel_GetCoreMesh: function(self: CalCoreModel; id: integer): CalCoreMesh;
    cdecl;
  CoreModel_GetCoreMeshCount: function(self: CalCoreModel): integer; cdecl;
  CoreModel_GetCoreSkeleton: function(self: CalCoreModel): CalCoreSkeleton;
    cdecl;
  CoreModel_GetUserData: function(self: CalCoreModel): CalUserData; cdecl;
  CoreModel_LoadCoreAnimation: function(self: CalCoreModel; strFilename: PChar):
    integer; cdecl;
  CoreModel_LoadCoreMaterial: function(self: CalCoreModel; strFilename: PChar):
    integer; cdecl;
  CoreModel_LoadCoreMesh: function(self: CalCoreModel; strFilename: PChar):
    integer; cdecl;
  CoreModel_LoadCoreSkeleton: function(self: CalCoreModel; strFilename: PChar):
    boolean; cdecl;
  CoreModel_SaveCoreAnimation: function(self: CalCoreModel; strFilename: PChar;
    id: integer): boolean; cdecl;
  CoreModel_SaveCoreMaterial: function(self: CalCoreModel; strFilename: PChar;
    id: integer): boolean; cdecl;
  CoreModel_SaveCoreMesh: function(self: CalCoreModel; strFilename: PChar; id:
    integer): boolean; cdecl;
  CoreModel_SaveCoreSkeleton: function(self: CalCoreModel; strFilename: PChar):
    boolean; cdecl;
  CoreModel_SetCoreMaterialId: function(self: CalCoreModel;
    coreMaterialThreadId, setId, coreMaterialId: integer): boolean; cdecl;
  CoreModel_SetUserData: procedure(self: CalCoreModel; userData: CalUserData);
    cdecl;

  // *** CalCoreSkeleton ***
  CoreSkeleton_New: function(): CalCoreSkeleton; cdecl;
  CoreSkeleton_Delete: procedure(self: CalCoreSkeleton); cdecl;
  CoreSkeleton_AddCoreBone: function(self: CalCoreSkeleton; pCoreBone:
    CalCoreBone): integer; cdecl;
  CoreSkeleton_AddRootCoreBoneId: function(self: CalCoreSkeleton; boneId:
    integer): boolean; cdecl;
  CoreSkeleton_CalculateState: procedure(self: CalCoreSkeleton); cdecl;
  CoreSkeleton_Create: function(self: CalCoreSkeleton): boolean; cdecl;
  CoreSkeleton_Destroy: procedure(self: CalCoreSkeleton); cdecl;
  CoreSkeleton_GetCoreBone: function(self: CalCoreSkeleton; boneId: integer):
    CalCoreBone; cdecl;
  CoreSkeleton_GetCoreBoneId: function(self: CalCoreSkeleton; strBone: PChar):
    integer; cdecl;
  CoreSkeleton_GetListRootCoreBoneId: function(self: CalCoreSkeleton): StdList;
    cdecl;
  CoreSkeleton_GetVectorCoreBone: function(self: CalCoreSkeleton): StdVector;
    cdecl;

  // *** CalCoreSubmesh ***
  CoreSubmesh_New: function(): CalCoreSubmesh; cdecl;
  CoreSubmesh_Delete: procedure(self: CalCoreSubmesh); cdecl;
  CoreSubmesh_Create: function(self: CalCoreSubmesh): boolean; cdecl;
  CoreSubmesh_Destroy: procedure(self: CalCoreSubmesh); cdecl;
  CoreSubmesh_GetCoreMaterialThreadId: function(self: CalCoreSubmesh): integer;
    cdecl;
  CoreSubmesh_GetFaceCount: function(self: CalCoreSubmesh): integer; cdecl;
  CoreSubmesh_GetLodCount: function(self: CalCoreSubmesh): integer; cdecl;
  CoreSubmesh_GetVectorFace: function(self: CalCoreSubmesh): StdVector; cdecl;
  CoreSubmesh_GetVectorVectorTextureCoordinate: function(self: CalCoreSubmesh):
    StdVector; cdecl;
  CoreSubmesh_GetVectorVertex: function(self: CalCoreSubmesh): StdVector; cdecl;
  CoreSubmesh_GetVertexCount: function(self: CalCoreSubmesh): integer; cdecl;
  CoreSubmesh_Reserve: function(self: CalCoreSubmesh; vertexCount,
    textureCoordinateCount, faceCount: integer): boolean; cdecl;
  CoreSubmesh_SetCoreMaterialThreadId: procedure(self: CalCoreSubmesh;
    coreMaterialThreadId: integer); cdecl;
  CoreSubmesh_SetFace: function(self: CalCoreSubmesh; id: integer; face:
    PCalFace): boolean; cdecl;
  CoreSubmesh_SetLodCount: procedure(self: CalCoreSubmesh; lodCount: integer);
    cdecl;
  CoreSubmesh_SetTextureCoordinate: function(self: CalCoreSubmesh; vertexId, id:
    integer; textureCoordinate: PCalTextureCoordinate): boolean; cdecl;
  CoreSubmesh_SetVertex: function(self: CalCoreSubmesh; id: integer; vertex:
    PCalVertex): boolean; cdecl;

  // *** CalCoreTrack ***
  CoreTrack_New: function(): CalCoreTrack; cdecl;
  CoreTrack_Delete: procedure(self: CalCoreTrack); cdecl;
  CoreTrack_AddCoreKeyframe: function(self: CalCoreTrack; pCoreKeyFrame:
    CalCoreKeyframe): boolean; cdecl;
  CoreTrack_Create: function(self: CalCoreTrack): boolean; cdecl;
  CoreTrack_Destroy: procedure(self: CalCoreTrack); cdecl;
  CoreTrack_GetCoreBoneId: function(self: CalCoreTrack): integer; cdecl;
  CoreTrack_GetMapCoreKeyframe: function(self: CalCoreTrack): StdMap; cdecl;
  CoreTrack_GetState: function(self: CalCoreTrack; time, duration: single;
    translation: CalVector; rotation: CalQuaternion): boolean; cdecl;
  CoreTrack_SetCoreBoneId: function(self: CalCoreTrack; coreBoneId: integer):
    boolean; cdecl;

  // *** CalLoader ***
  Loader_New: function(): CalLoader; cdecl;
  Loader_Delete: procedure(self: CalLoader); cdecl;
  Loader_LoadCoreAnimation: function(self: CalLoader; strFilename: PChar):
    CalCoreAnimation; cdecl;
  Loader_LoadCoreMaterial: function(self: CalLoader; strFilename: PChar):
    CalCoreMaterial; cdecl;
  Loader_LoadCoreMesh: function(self: CalLoader; strFilename: PChar):
    CalCoreMesh; cdecl;
  Loader_LoadCoreSkeleton: function(self: CalLoader; strFilename: PChar):
    CalCoreSkeleton; cdecl;

  // *** CalMesh ***
  Mesh_New: function(): CalMesh; cdecl;
  Mesh_Delete: procedure(self: CalMesh); cdecl;
  Mesh_Create: function(self: CalMesh; pCoreMesh: CalCoreMesh): boolean; cdecl;
  Mesh_Destroy: procedure(self: CalMesh); cdecl;
  Mesh_GetCoreMesh: function(self: CalMesh): CalCoreMesh; cdecl;
  Mesh_GetSubmesh: function(self: CalMesh; id: integer): CalSubmesh; cdecl;
  Mesh_GetSubmeshCount: function(self: CalMesh): integer; cdecl;
  Mesh_SetLodLevel: procedure(self: CalMesh; lodLevel: single); cdecl;
  Mesh_SetMaterialSet: procedure(self: CalMesh; setId: integer); cdecl;
  Mesh_SetModel: procedure(self: CalMesh; pModel: CalModel); cdecl;

  // *** CalMixer ***
  Mixer_New: function(): CalMixer; cdecl;
  Mixer_Delete: procedure(self: CalMixer); cdecl;
  Mixer_BlendCycle: function(self: CalMixer; id: integer; weight, delay:
    single): boolean; cdecl;
  Mixer_ClearCycle: function(self: CalMixer; id: integer; delay: single):
    boolean; cdecl;
  Mixer_Create: function(self: CalMixer; pModel: CalModel): boolean; cdecl;
  Mixer_Destroy: procedure(self: CalMixer); cdecl;
  Mixer_ExecuteAction: function(self: CalMixer; id: integer; delayIn, delayOut:
    single): boolean; cdecl;
  Mixer_UpdateAnimation: procedure(self: CalMixer; deltaTime: single); cdecl;
  Mixer_UpdateSkeleton: procedure(self: CalMixer); cdecl;

  // *** CalModel ***
  Model_New: function(): CalModel; cdecl;
  Model_Delete: procedure(self: CalModel); cdecl;
  Model_Create: function(self: CalModel; pCoreModel: CalCoreModel): boolean;
    cdecl;
  Model_Destroy: procedure(self: CalModel); cdecl;
  Model_AttachMesh: function(self: CalModel; coreMeshId: integer):
    boolean; cdecl;
  Model_GetCoreModel: function(self: CalModel): CalCoreModel; cdecl;
  Model_GetMixer: function(self: CalModel): CalMixer; cdecl;
  Model_GetRenderer: function(self: CalModel): CalRenderer; cdecl;
  Model_GetSkeleton: function(self: CalModel): CalSkeleton; cdecl;
  Model_GetUserData: function(self: CalModel): CalUserData; cdecl;
  Model_SetLodLevel: procedure(self: CalModel; lodLevel: single); cdecl;
  Model_SetMaterialSet: procedure(self: CalModel; setId: integer); cdecl;
  Model_SetUserData: procedure(self: CalModel; userData: CalUserData); cdecl;
  Model_Update: procedure(self: CalModel; deltaTime: single); cdecl;

  // *** CalQuaternion ***
  Quaternion_New: function(x, y, z, w: single): CalQuaternion; cdecl;
  Quaternion_Delete: procedure(self: CalQuaternion); cdecl;
  Quaternion_Blend: procedure(self: CalQuaternion; factor: single; q:
    CalQuaternion); cdecl;
  Quaternion_Product1: procedure(self: CalQuaternion; q: CalQuaternion); cdecl;
  Quaternion_Product3: procedure(self: CalQuaternion; tx, ty, tz: single);
    cdecl;
  Quaternion_Product4: procedure(self: CalQuaternion; tx, ty, tz, tw: single);
    cdecl;

  // *** CalRenderer ***
  Renderer_New: function(): CalRenderer; cdecl;
  Renderer_Delete: procedure(self: CalRenderer); cdecl;
  Renderer_BeginRendering: function(self: CalRenderer): boolean; cdecl;
  Renderer_Create: function(self: CalRenderer; pModel: CalModel): boolean;
    cdecl;
  Renderer_Destroy: procedure(self: CalRenderer); cdecl;
  Renderer_DetachMesh: function(self: CalRenderer; coreMeshId: integer):
    boolean; cdecl;
  Renderer_EndRendering: procedure(self: CalRenderer); cdecl;
  Renderer_GetAmbientColor: procedure(self: CalRenderer; pColorBuffer: PByte);
    cdecl;
  Renderer_GetDiffuseColor: procedure(self: CalRenderer; pColorBuffer: PByte);
    cdecl;
  Renderer_GetFaceCount: function(self: CalRenderer): integer; cdecl;
  Renderer_GetFaces: function(self: CalRenderer; pFaceBuffer: PInteger):
    integer; cdecl;
  Renderer_GetMapCount: function(self: CalRenderer): integer; cdecl;
  Renderer_GetMapUserData: function(self: CalRenderer; mapId: integer):
    CalUserData; cdecl;
  Renderer_GetMeshCount: function(self: CalRenderer): integer; cdecl;
  Renderer_GetNormals: function(self: CalRenderer; pNormalBuffer: PSingle):
    integer; cdecl;
  Renderer_GetShininess: function(self: CalRenderer): Single; cdecl;
  Renderer_GetSpecularColor: procedure(self: CalRenderer; pColorBuffer: PByte);
    cdecl;
  Renderer_GetSubmeshCount: function(self: CalRenderer; meshId: integer):
    integer; cdecl;
  Renderer_GetTextureCoordinates: function(self: CalRenderer; mapId: integer;
    pTextureCoordinateBuffer: PSingle): integer; cdecl;
  Renderer_GetVectorMesh: function(self: CalRenderer): StdVector; cdecl;
  Renderer_GetVertexCount: function(self: CalRenderer): integer; cdecl;
  Renderer_GetVertices: function(self: CalRenderer; pVertexBuffer: Pointer):
    integer; cdecl;
  Renderer_SelectMeshSubmesh: function(self: CalRenderer; meshId, submeshId:
    integer): boolean; cdecl;

  // *** CalSaver ***
  Saver_New: function(): CalSaver; cdecl;
  Saver_Delete: procedure(self: CalSaver); cdecl;
  Saver_SaveCoreAnimation: function(self: CalSaver; strFilename: PChar;
    pCoreAnimation: CalCoreAnimation): boolean; cdecl;
  Saver_SaveCoreMaterial: function(self: CalSaver; strFilename: PChar;
    pCoreMaterial: CalCoreMaterial): boolean; cdecl;
  Saver_SaveCoreMesh: function(self: CalSaver; strFilename: PChar; pCoreMesh:
    CalCoreMesh): boolean; cdecl;
  Saver_SaveCoreSkeleton: function(self: CalSaver; strFilename: PChar;
    pCoreSkeleton: CalCoreSkeleton): boolean; cdecl;

  // *** CalSkeleton ***
  Skeleton_New: function(): CalSkeleton; cdecl;
  Skeleton_Delete: procedure(self: CalSkeleton); cdecl;
  Skeleton_CalculateState: procedure(self: CalSkeleton); cdecl;
  Skeleton_ClearState: procedure(self: CalSkeleton); cdecl;
  Skeleton_Create: function(self: CalSkeleton; pCoreSkeleton: CalCoreSkeleton):
    boolean; cdecl;
  Skeleton_Destroy: procedure(self: CalSkeleton); cdecl;
  Skeleton_GetBone: function(self: CalSkeleton; boneId: integer): CalBone;
    cdecl;
  Skeleton_GetVectorBone: function(self: CalSkeleton): StdVector; cdecl;
  Skeleton_LockState: procedure(self: CalSkeleton); cdecl;
  Skeleton_GetBonePoints: function(self: CalSkeleton; pPoints: PSingle):
    integer; cdecl;
  Skeleton_GetBonePointsStatic: function(self: CalSkeleton; pPoints: PSingle):
    integer; cdecl;
  Skeleton_GetBoneLines: function(self: CalSkeleton; pLines: PSingle): integer;
    cdecl;
  Skeleton_GetBoneLinesStatic: function(self: CalSkeleton; pLines: PSingle):
    integer; cdecl;

  // *** CalSubmesh ***
  Submesh_New: function(): CalSubmesh; cdecl;
  Submesh_Delete: procedure(self: CalSubmesh); cdecl;
  Submesh_Create: function(self: CalSubmesh; pCoreSubmesh: CalCoreSubmesh):
    boolean; cdecl;
  Submesh_Destroy: procedure(self: CalSubmesh); cdecl;
  Submesh_GetCoreSubmesh: function(self: CalSubmesh): CalCoreSubmesh; cdecl;
  Submesh_GetCoreMaterialId: function(self: CalSubmesh): integer; cdecl;
  Submesh_GetFaceCount: function(self: CalSubmesh): integer; cdecl;
  Submesh_GetFaces: function(self: CalSubmesh; pFaceBuffer: PInteger): integer;
    cdecl;
  Submesh_GetVertexCount: function(self: CalSubmesh): integer; cdecl;
  Submesh_SetCoreMaterialId: procedure(self: CalSubmesh; coreMaterialId:
    integer); cdecl;
  Submesh_SetLodLevel: procedure(self: CalSubmesh; lodLevel: single); cdecl;

  // *** CalVector ***
  Vector_New: function(x, y, z: single): CalVector; cdecl;
  Vector_Delete: procedure(self: CalVector); cdecl;
  Vector_Blend: procedure(self: CalVector; factor: single; v: CalVector); cdecl;
  Vector_Add: procedure(self: CalVector; v: CalVector); cdecl;
  Vector_Transform: procedure(self: CalVector; q: CalQuaternion); cdecl;

procedure LoadCal3D();
procedure FreeCal3D();
function IsLoaded(): Boolean;

implementation

var
  hDLL: THandle = 0;

function IsLoaded(): Boolean;
begin
  Result := (hDLL <> 0);
end;

procedure LoadCal3d();
begin
  if fileexists(DLLPath+'cal3d.dll') then
    hDLL := LoadLibrary(DLLPath+'cal3d.dll')
  else
    raise exception.create('Could not locate cal3d.dll');

  // *** CalAnimation ***
  Animation_Destroy := GetProcAddress(hDLL, 'CalAnimation_Destroy');
  Animation_GetCoreAnimation := GetProcAddress(hDLL,
    'CalAnimation_GetCoreAnimation');
  Animation_GetState := GetProcAddress(hDLL, 'CalAnimation_GetState');
  Animation_GetTime := GetProcAddress(hDLL, 'CalAnimation_GetTime');
  Animation_GetType := GetProcAddress(hDLL, 'CalAnimation_GetType');

  // *** CalAnimationAction ***
  AnimationAction_New := GetProcAddress(hDLL, 'CalAnimationAction_New');
  AnimationAction_Delete := GetProcAddress(hDLL, 'CalAnimationAction_Delete');
  AnimationAction_Create := GetProcAddress(hDLL, 'CalAnimationAction_Create');
  AnimationAction_Destroy := GetProcAddress(hDLL, 'CalAnimationAction_Destroy');
  AnimationAction_Execute := GetProcAddress(hDLL, 'CalAnimationAction_Execute');
  AnimationAction_GetWeight := GetProcAddress(hDLL,
    'CalAnimationAction_GetWeight');
  AnimationAction_Update := GetProcAddress(hDLL, 'CalAnimationAction_Update');

  // *** CalAnimationCycle ***
  AnimationCycle_New := GetProcAddress(hDLL, 'CalAnimationCycle_New');
  AnimationCycle_Delete := GetProcAddress(hDLL, 'CalAnimationCycle_Delete');
  AnimationCycle_Blend := GetProcAddress(hDLL, 'CalAnimationCycle_Blend');
  AnimationCycle_Create := GetProcAddress(hDLL, 'CalAnimationCycle_Create');
  AnimationCycle_Destroy := GetProcAddress(hDLL, 'CalAnimationCycle_Destroy');
  AnimationCycle_GetWeight := GetProcAddress(hDLL, 'CalAnimationCycle_GetWeight');
  AnimationCycle_SetAsync := GetProcAddress(hDLL, 'CalAnimationCycle_SetAsync');
  AnimationCycle_Update := GetProcAddress(hDLL, 'CalAnimationCycle_Update');

  // *** CalBone ***
  Bone_New := GetProcAddress(hDLL, 'CalBone_New');
  Bone_Delete := GetProcAddress(hDLL, 'CalBone_Delete');
  Bone_BlendState := GetProcAddress(hDLL, 'CalBone_BlendState');
  Bone_CalculateState := GetProcAddress(hDLL, 'CalBone_CalculateState');
  Bone_ClearState := GetProcAddress(hDLL, 'CalBone_ClearState');
  Bone_Create := GetProcAddress(hDLL, 'CalBone_Create');
  Bone_Destroy := GetProcAddress(hDLL, 'CalBone_Destroy');
  Bone_GetCoreBone := GetProcAddress(hDLL, 'CalBone_GetCoreBone');
  Bone_GetRotation := GetProcAddress(hDLL, 'CalBone_GetRotation');
  Bone_GetRotationAbsolute := GetProcAddress(hDLL, 'CalBone_GetRotationAbsolute');
  Bone_GetRotationBoneSpace := GetProcAddress(hDLL, 'CalBone_GetRotationBoneSpace');
  Bone_GetTranslation := GetProcAddress(hDLL, 'CalBone_GetTranslation');
  Bone_GetTranslationAbsolute := GetProcAddress(hDLL, 'CalBone_GetTranslationAbsolute');
  Bone_GetTranslationBoneSpace := GetProcAddress(hDLL, 'CalBone_GetTranslationBoneSpace');
  Bone_LockState := GetProcAddress(hDLL, 'CalBone_LockState');
  Bone_SetSkeleton := GetProcAddress(hDLL, 'CalBone_SetSkeleton');

  // *** CalCoreAnimation ***
  CoreAnimation_New := GetProcAddress(hDLL, 'CalCoreAnimation_New');
  CoreAnimation_Delete := GetProcAddress(hDLL, 'CalCoreAnimation_Delete');
  CoreAnimation_AddCoreTrack := GetProcAddress(hDLL,
    'CalCoreAnimation_AddCoreTrack');
  CoreAnimation_Create := GetProcAddress(hDLL, 'CalCoreAnimation_Create');
  CoreAnimation_Destroy := GetProcAddress(hDLL, 'CalCoreAnimation_Destroy');
  CoreAnimation_GetCoreTrack := GetProcAddress(hDLL,
    'CalCoreAnimation_GetCoreTrack');
  CoreAnimation_GetDuration := GetProcAddress(hDLL,
    'CalCoreAnimation_GetDuration');
  CoreAnimation_GetListCoreTrack := GetProcAddress(hDLL,
    'CalCoreAnimation_GetListCoreTrack');
  CoreAnimation_SetDuration := GetProcAddress(hDLL,
    'CalCoreAnimation_SetDuration');

  // *** CalCoreBone ***
  CoreBone_New := GetProcAddress(hDLL, 'CalCoreBone_New');
  CoreBone_Delete := GetProcAddress(hDLL, 'CalCoreBone_Delete');
  CoreBone_AddChildId := GetProcAddress(hDLL, 'CalCoreBone_AddChildId');
  CoreBone_CalculateState := GetProcAddress(hDLL, 'CalCoreBone_CalculateState');
  CoreBone_Create := GetProcAddress(hDLL, 'CalCoreBone_Create');
  CoreBone_Destroy := GetProcAddress(hDLL, 'CalCoreBone_Destroy');
  CoreBone_GetListChildId := GetProcAddress(hDLL, 'CalCoreBone_GetListChildId');
  CoreBone_GetName := GetProcAddress(hDLL, 'CalCoreBone_GetName');
  CoreBone_GetParentId := GetProcAddress(hDLL, 'CalCoreBone_GetParentId');
  CoreBone_GetRotation := GetProcAddress(hDLL, 'CalCoreBone_GetRotation');
  CoreBone_GetRotationAbsolute := GetProcAddress(hDLL,
    'CalCoreBone_GetRotationAbsolute');
  CoreBone_GetTranslation := GetProcAddress(hDLL, 'CalCoreBone_GetTranslation');
  CoreBone_GetTranslationAbsolute := GetProcAddress(hDLL,
    'CalCoreBone_GetTranslationAbsolute');
  CoreBone_GetUserData := GetProcAddress(hDLL, 'CalCoreBone_GetUserData');
  CoreBone_SetCoreSkeleton := GetProcAddress(hDLL, 'CalCoreBone_SetCoreSkeleton');
  CoreBone_SetParentId := GetProcAddress(hDLL, 'CalCoreBone_SetParentId');
  CoreBone_SetRotation := GetProcAddress(hDLL, 'CalCoreBone_SetRotation');
  CoreBone_SetTranslation := GetProcAddress(hDLL, 'CalCoreBone_SetTranslation');
  CoreBone_SetUserData := GetProcAddress(hDLL, 'CalCoreBone_SetUserData');

  // *** CalCoreKeyFrame ***
  CoreKeyframe_New := GetProcAddress(hDLL, 'CalCoreKeyframe_New');
  CoreKeyframe_Delete := GetProcAddress(hDLL, 'CalCoreKeyframe_Delete');
  CoreKeyframe_Create := GetProcAddress(hDLL, 'CalCoreKeyframe_Create');
  CoreKeyframe_Destroy := GetProcAddress(hDLL, 'CalCoreKeyframe_Destroy');
  CoreKeyframe_GetRotation := GetProcAddress(hDLL, 'CalCoreKeyframe_GetRotation');
  CoreKeyframe_GetTime := GetProcAddress(hDLL, 'CalCoreKeyframe_GetTime');
  CoreKeyframe_GetTranslation := GetProcAddress(hDLL,
    'CalCoreKeyframe_GetTranslation');
  CoreKeyframe_SetRotation := GetProcAddress(hDLL, 'CalCoreKeyframe_SetRotation');
  CoreKeyframe_SetTime := GetProcAddress(hDLL, 'CalCoreKeyframe_SetTime');
  CoreKeyframe_SetTranslation := GetProcAddress(hDLL,
    'CalCoreKeyframe_SetTranslation');

  // *** CalCoreMaterial ***
  CoreMaterial_New := GetProcAddress(hDLL, 'CalCoreMaterial_New');
  CoreMaterial_Delete := GetProcAddress(hDLL, 'CalCoreMaterial_Delete');
  CoreMaterial_Create := GetProcAddress(hDLL, 'CalCoreMaterial_Create');
  CoreMaterial_Destroy := GetProcAddress(hDLL, 'CalCoreMaterial_Destroy');
  CoreMaterial_GetAmbientColor := GetProcAddress(hDLL,
    'CalCoreMaterial_GetAmbientColor');
  CoreMaterial_GetDiffuseColor := GetProcAddress(hDLL,
    'CalCoreMaterial_GetDiffuseColor');
  CoreMaterial_GetMapCount := GetProcAddress(hDLL, 'CalCoreMaterial_GetMapCount');
  CoreMaterial_GetMapFilename := GetProcAddress(hDLL,
    'CalCoreMaterial_GetMapFilename');
  CoreMaterial_GetMapUserData := GetProcAddress(hDLL,
    'CalCoreMaterial_GetMapUserData');
  CoreMaterial_GetShininess := GetProcAddress(hDLL,
    'CalCoreMaterial_GetShininess');
  CoreMaterial_GetSpecularColor := GetProcAddress(hDLL,
    'CalCoreMaterial_GetSpecularColor');
  CoreMaterial_GetUserData := GetProcAddress(hDLL, 'CalCoreMaterial_GetUserData');
  CoreMaterial_GetVectorMap := GetProcAddress(hDLL,
    'CalCoreMaterial_GetVectorMap');
  CoreMaterial_Reserve := GetProcAddress(hDLL, 'CalCoreMaterial_Reserve');
  CoreMaterial_SetMUserData := GetProcAddress(hDLL,
    'CalCoreMaterial_SetMUserData');
  CoreMaterial_SetAmbientColor := GetProcAddress(hDLL,
    'CalCoreMaterial_SetAmbientColor');
  CoreMaterial_SetDiffuseColor := GetProcAddress(hDLL,
    'CalCoreMaterial_SetDiffuseColor');
  CoreMaterial_SetMap := GetProcAddress(hDLL, 'CalCoreMaterial_SetMap');
  CoreMaterial_SetMapUserData := GetProcAddress(hDLL,
    'CalCoreMaterial_SetMapUserData');
  CoreMaterial_SetShininess := GetProcAddress(hDLL,
    'CalCoreMaterial_SetShininess');
  CoreMaterial_SetSpecularColor := GetProcAddress(hDLL,
    'CalCoreMaterial_SetSpecularColor');
  CoreMaterial_SetUserData := GetProcAddress(hDLL, 'CalCoreMaterial_SetUserData');

  // *** CalCoreMesh ***
  CoreMesh_New := GetProcAddress(hDLL, 'CalCoreMesh_New');
  CoreMesh_Delete := GetProcAddress(hDLL, 'CalCoreMesh_Delete');
  CoreMesh_AddCoreSubmesh := GetProcAddress(hDLL, 'CalCoreMesh_AddCoreSubmesh');
  CoreMesh_Create := GetProcAddress(hDLL, 'CalCoreMesh_Create');
  CoreMesh_Destroy := GetProcAddress(hDLL, 'CalCoreMesh_Destroy');
  CoreMesh_GetCoreSubmesh := GetProcAddress(hDLL, 'CalCoreMesh_GetCoreSubmesh');
  CoreMesh_GetCoreSubmeshCount := GetProcAddress(hDLL,
    'CalCoreMesh_GetCoreSubmeshCount');
  CoreMesh_GetVectorCoreSubmesh := GetProcAddress(hDLL,
    'CalCoreMesh_GetVectorCoreSubmesh');

  // *** CalCoreModel ***
  CoreModel_New := GetProcAddress(hDLL, 'CalCoreModel_New');
  CoreModel_Delete := GetProcAddress(hDLL, 'CalCoreModel_Delete');
  CoreModel_AddCoreAnimation := GetProcAddress(hDLL,
    'CalCoreModel_AddCoreAnimation');
  CoreModel_AddCoreMaterial := GetProcAddress(hDLL,
    'CalCoreModel_AddCoreMaterial');
  CoreModel_AddCoreMesh := GetProcAddress(hDLL, 'CalCoreModel_AddCoreMesh');
  CoreModel_Create := GetProcAddress(hDLL, 'CalCoreModel_Create');
  CoreModel_CreateCoreMaterialThread := GetProcAddress(hDLL,
    'CalCoreModel_CreateCoreMaterialThread');
  CoreModel_Destroy := GetProcAddress(hDLL, 'CalCoreModel_Destroy');
  CoreModel_GetCoreAnimation := GetProcAddress(hDLL,
    'CalCoreModel_GetCoreAnimation');
  CoreModel_GetCoreAnimationCount := GetProcAddress(hDLL,
    'CalCoreModel_GetCoreAnimationCount');
  CoreModel_GetCoreMaterial := GetProcAddress(hDLL,
    'CalCoreModel_GetCoreMaterial');
  CoreModel_GetCoreMaterialCount := GetProcAddress(hDLL,
    'CalCoreModel_GetCoreMaterialCount');
  CoreModel_GetCoreMaterialId := GetProcAddress(hDLL,
    'CalCoreModel_GetCoreMaterialId');
  CoreModel_GetCoreMesh := GetProcAddress(hDLL, 'CalCoreModel_GetCoreMesh');
  CoreModel_GetCoreMeshCount := GetProcAddress(hDLL,
    'CalCoreModel_GetCoreMeshCount');
  CoreModel_GetCoreSkeleton := GetProcAddress(hDLL,
    'CalCoreModel_GetCoreSkeleton');
  CoreModel_GetUserData := GetProcAddress(hDLL, 'CalCoreModel_GetUserData');
  CoreModel_LoadCoreAnimation := GetProcAddress(hDLL,
    'CalCoreModel_LoadCoreAnimation');
  CoreModel_LoadCoreMaterial := GetProcAddress(hDLL,
    'CalCoreModel_LoadCoreMaterial');
  CoreModel_LoadCoreMesh := GetProcAddress(hDLL, 'CalCoreModel_LoadCoreMesh');
  CoreModel_LoadCoreSkeleton := GetProcAddress(hDLL,
    'CalCoreModel_LoadCoreSkeleton');
  CoreModel_SaveCoreAnimation := GetProcAddress(hDLL,
    'CalCoreModel_SaveCoreAnimation');
  CoreModel_SaveCoreMaterial := GetProcAddress(hDLL,
    'CalCoreModel_SaveCoreMaterial');
  CoreModel_SaveCoreMesh := GetProcAddress(hDLL, 'CalCoreModel_SaveCoreMesh');
  CoreModel_SaveCoreSkeleton := GetProcAddress(hDLL,
    'CalCoreModel_SaveCoreSkeleton');
  CoreModel_SetCoreMaterialId := GetProcAddress(hDLL,
    'CalCoreModel_SetCoreMaterialId');
  CoreModel_SetUserData := GetProcAddress(hDLL, 'CalCoreModel_SetUserData');

  // *** CalCoreSkeleton ***
  CoreSkeleton_New := GetProcAddress(hDLL, 'CalCoreSkeleton_New');
  CoreSkeleton_Delete := GetProcAddress(hDLL, 'CalCoreSkeleton_Delete');
  CoreSkeleton_AddCoreBone := GetProcAddress(hDLL, 'CalCoreSkeleton_AddCoreBone');
  CoreSkeleton_AddRootCoreBoneId := GetProcAddress(hDLL,
    'CalCoreSkeleton_AddRootCoreBoneId');
  CoreSkeleton_CalculateState := GetProcAddress(hDLL,
    'CalCoreSkeleton_CalculateState');
  CoreSkeleton_Create := GetProcAddress(hDLL, 'CalCoreSkeleton_Create');
  CoreSkeleton_Destroy := GetProcAddress(hDLL, 'CalCoreSkeleton_Destroy');
  CoreSkeleton_GetCoreBone := GetProcAddress(hDLL, 'CalCoreSkeleton_GetCoreBone');
  CoreSkeleton_GetCoreBoneId := GetProcAddress(hDLL,
    'CalCoreSkeleton_GetCoreBoneId');
  CoreSkeleton_GetListRootCoreBoneId := GetProcAddress(hDLL,
    'CalCoreSkeleton_GetListRootCoreBoneId');
  CoreSkeleton_GetVectorCoreBone := GetProcAddress(hDLL,
    'CalCoreSkeleton_GetVectorCoreBone');

  // *** CalCoreSubmesh ***
  CoreSubmesh_New := GetProcAddress(hDLL, 'CalCoreSubmesh_New');
  CoreSubmesh_Delete := GetProcAddress(hDLL, 'CalCoreSubmesh_Delete');
  CoreSubmesh_Create := GetProcAddress(hDLL, 'CalCoreSubmesh_Create');
  CoreSubmesh_Destroy := GetProcAddress(hDLL, 'CalCoreSubmesh_Destroy');
  CoreSubmesh_GetCoreMaterialThreadId := GetProcAddress(hDLL,
    'CalCoreSubmesh_GetCoreMaterialThreadId');
  CoreSubmesh_GetFaceCount := GetProcAddress(hDLL, 'CalCoreSubmesh_GetFaceCount');
  CoreSubmesh_GetLodCount := GetProcAddress(hDLL, 'CalCoreSubmesh_GetLodCount');
  CoreSubmesh_GetVectorFace := GetProcAddress(hDLL,
    'CalCoreSubmesh_GetVectorFace');
  CoreSubmesh_GetVectorVectorTextureCoordinate := GetProcAddress(hDLL,
    'CalCoreSubmesh_GetVectorVectorTextureCoordinate');
  CoreSubmesh_GetVectorVertex := GetProcAddress(hDLL,
    'CalCoreSubmesh_GetVectorVertex');
  CoreSubmesh_GetVertexCount := GetProcAddress(hDLL,
    'CalCoreSubmesh_GetVertexCount');
  CoreSubmesh_Reserve := GetProcAddress(hDLL, 'CalCoreSubmesh_Reserve');
  CoreSubmesh_SetCoreMaterialThreadId := GetProcAddress(hDLL,
    'CalCoreSubmesh_SetCoreMaterialThreadId');
  CoreSubmesh_SetFace := GetProcAddress(hDLL, 'CalCoreSubmesh_SetFace');
  CoreSubmesh_SetLodCount := GetProcAddress(hDLL, 'CalCoreSubmesh_SetLodCount');
  CoreSubmesh_SetTextureCoordinate := GetProcAddress(hDLL,
    'CalCoreSubmesh_SetTextureCoordinate');
  CoreSubmesh_SetVertex := GetProcAddress(hDLL, 'CalCoreSubmesh_SetVertex');

  // *** CalCoreTrack ***
  CoreTrack_New := GetProcAddress(hDLL, 'CalCoreTrack_New');
  CoreTrack_Delete := GetProcAddress(hDLL, 'CalCoreTrack_Delete');
  CoreTrack_AddCoreKeyframe := GetProcAddress(hDLL,
    'CalCoreTrack_AddCoreKeyframe');
  CoreTrack_Create := GetProcAddress(hDLL, 'CalCoreTrack_Create');
  CoreTrack_Destroy := GetProcAddress(hDLL, 'CalCoreTrack_Destroy');
  CoreTrack_GetCoreBoneId := GetProcAddress(hDLL, 'CalCoreTrack_GetCoreBoneId');
  CoreTrack_GetMapCoreKeyframe := GetProcAddress(hDLL,
    'CalCoreTrack_GetMapCoreKeyframe');
  CoreTrack_GetState := GetProcAddress(hDLL, 'CalCoreTrack_GetState');
  CoreTrack_SetCoreBoneId := GetProcAddress(hDLL, 'CalCoreTrack_SetCoreBoneId');

  // *** CalLoader ***
  Loader_New := GetProcAddress(hDLL, 'CalLoader_New');
  Loader_Delete := GetProcAddress(hDLL, 'CalLoader_Delete');
  Loader_LoadCoreAnimation := GetProcAddress(hDLL, 'CalLoader_LoadCoreAnimation');
  Loader_LoadCoreMaterial := GetProcAddress(hDLL, 'CalLoader_LoadCoreMaterial');
  Loader_LoadCoreMesh := GetProcAddress(hDLL, 'CalLoader_LoadCoreMesh');
  Loader_LoadCoreSkeleton := GetProcAddress(hDLL, 'CalLoader_LoadCoreSkeleton');

  // *** CalMesh ***
  Mesh_New := GetProcAddress(hDLL, 'CalMesh_New');
  Mesh_Delete := GetProcAddress(hDLL, 'CalMesh_Delete');
  Mesh_Create := GetProcAddress(hDLL, 'CalMesh_Create');
  Mesh_Destroy := GetProcAddress(hDLL, 'CalMesh_Destroy');
  Mesh_GetCoreMesh := GetProcAddress(hDLL, 'CalMesh_GetCoreMesh');
  Mesh_GetSubmesh := GetProcAddress(hDLL, 'CalMesh_GetSubmesh');
  Mesh_GetSubmeshCount := GetProcAddress(hDLL, 'CalMesh_GetSubmeshCount');
  Mesh_SetLodLevel := GetProcAddress(hDLL, 'CalMesh_SetLodLevel');
  Mesh_SetMaterialSet := GetProcAddress(hDLL, 'CalMesh_SetMaterialSet');
  Mesh_SetModel := GetProcAddress(hDLL, 'CalMesh_SetModel');

  // *** CalMixer ***
  Mixer_New := GetProcAddress(hDLL, 'CalMixer_New');
  Mixer_Delete := GetProcAddress(hDLL, 'CalMixer_Delete');
  Mixer_BlendCycle := GetProcAddress(hDLL, 'CalMixer_BlendCycle');
  Mixer_ClearCycle := GetProcAddress(hDLL, 'CalMixer_ClearCycle');
  Mixer_Create := GetProcAddress(hDLL, 'CalMixer_Create');
  Mixer_Destroy := GetProcAddress(hDLL, 'CalMixer_Destroy');
  Mixer_ExecuteAction := GetProcAddress(hDLL, 'CalMixer_ExecuteAction');
  Mixer_UpdateAnimation := GetProcAddress(hDLL, 'CalMixer_UpdateAnimation');
  Mixer_UpdateSkeleton := GetProcAddress(hDLL, 'CalMixer_UpdateSkeleton');

  // *** CalModel ***
  Model_New := GetProcAddress(hDLL, 'CalModel_New');
  Model_Delete := GetProcAddress(hDLL, 'CalModel_Delete');
  Model_Create := GetProcAddress(hDLL, 'CalModel_Create');
  Model_Destroy := GetProcAddress(hDLL, 'CalModel_Destroy');
  Model_AttachMesh := GetProcAddress(hDLL, 'CalModel_AttachMesh');
  Model_GetCoreModel := GetProcAddress(hDLL, 'CalModel_GetCoreModel');
  Model_GetMixer := GetProcAddress(hDLL, 'CalModel_GetMixer');
  Model_GetRenderer := GetProcAddress(hDLL, 'CalModel_GetRenderer');
  Model_GetSkeleton := GetProcAddress(hDLL, 'CalModel_GetSkeleton');
  Model_GetUserData := GetProcAddress(hDLL, 'CalModel_GetUserData');
  Model_SetLodLevel := GetProcAddress(hDLL, 'CalModel_SetLodLevel');
  Model_SetMaterialSet := GetProcAddress(hDLL, 'CalModel_SetMaterialSet');
  Model_SetUserData := GetProcAddress(hDLL, 'CalModel_SetUserData');
  Model_Update := GetProcAddress(hDLL, 'CalModel_Update');

  // *** CalQuaternion ***
  Quaternion_New := GetProcAddress(hDLL, 'CalQuaternion_New');
  Quaternion_Delete := GetProcAddress(hDLL, 'CalQuaternion_Delete');
  Quaternion_Blend := GetProcAddress(hDLL, 'CalQuaternion_Blend');
  Quaternion_Product1 := GetProcAddress(hDLL, 'CalQuaternion_Product1');
  Quaternion_Product3 := GetProcAddress(hDLL, 'CalQuaternion_Product3');
  Quaternion_Product4 := GetProcAddress(hDLL, 'CalQuaternion_Product4');

  // *** CalRenderer ***
  Renderer_New := GetProcAddress(hDLL, 'CalRenderer_New');
  Renderer_Delete := GetProcAddress(hDLL, 'CalRenderer_Delete');
  Renderer_BeginRendering := GetProcAddress(hDLL, 'CalRenderer_BeginRendering');
  Renderer_Create := GetProcAddress(hDLL, 'CalRenderer_Create');
  Renderer_Destroy := GetProcAddress(hDLL, 'CalRenderer_Destroy');
  Renderer_DetachMesh := GetProcAddress(hDLL, 'CalRenderer_DetachMesh');
  Renderer_EndRendering := GetProcAddress(hDLL, 'CalRenderer_EndRendering');
  Renderer_GetAmbientColor := GetProcAddress(hDLL, 'CalRenderer_GetAmbientColor');
  Renderer_GetDiffuseColor := GetProcAddress(hDLL, 'CalRenderer_GetDiffuseColor');
  Renderer_GetFaceCount := GetProcAddress(hDLL, 'CalRenderer_GetFaceCount');
  Renderer_GetFaces := GetProcAddress(hDLL, 'CalRenderer_GetFaces');
  Renderer_GetMapCount := GetProcAddress(hDLL, 'CalRenderer_GetMapCount');
  Renderer_GetMapUserData := GetProcAddress(hDLL, 'CalRenderer_GetMapUserData');
  Renderer_GetMeshCount := GetProcAddress(hDLL, 'CalRenderer_GetMeshCount');
  Renderer_GetNormals := GetProcAddress(hDLL, 'CalRenderer_GetNormals');
  Renderer_GetShininess := GetProcAddress(hDLL, 'CalRenderer_GetShininess');
  Renderer_GetSpecularColor := GetProcAddress(hDLL,
    'CalRenderer_GetSpecularColor');
  Renderer_GetSubmeshCount := GetProcAddress(hDLL, 'CalRenderer_GetSubmeshCount');
  Renderer_GetTextureCoordinates := GetProcAddress(hDLL,
    'CalRenderer_GetTextureCoordinates');
  Renderer_GetVectorMesh := GetProcAddress(hDLL, 'CalRenderer_GetVectorMesh');
  Renderer_GetVertexCount := GetProcAddress(hDLL, 'CalRenderer_GetVertexCount');
  Renderer_GetVertices := GetProcAddress(hDLL, 'CalRenderer_GetVertices');
  Renderer_SelectMeshSubmesh := GetProcAddress(hDLL,
    'CalRenderer_SelectMeshSubmesh');

  // *** CalSaver ***
  Saver_New := GetProcAddress(hDLL, 'CalSaver_New');
  Saver_Delete := GetProcAddress(hDLL, 'CalSaver_Delete');
  Saver_SaveCoreAnimation := GetProcAddress(hDLL, 'CalSaver_SaveCoreAnimation');
  Saver_SaveCoreMaterial := GetProcAddress(hDLL, 'CalSaver_SaveCoreMaterial');
  Saver_SaveCoreMesh := GetProcAddress(hDLL, 'CalSaver_SaveCoreMesh');
  Saver_SaveCoreSkeleton := GetProcAddress(hDLL, 'CalSaver_SaveCoreSkeleton');

  // *** CalSkeleton ***
  Skeleton_New := GetProcAddress(hDLL, 'CalSkeleton_New');
  Skeleton_Delete := GetProcAddress(hDLL, 'CalSkeleton_Delete');
  Skeleton_CalculateState := GetProcAddress(hDLL, 'CalSkeleton_CalculateState');
  Skeleton_ClearState := GetProcAddress(hDLL, 'CalSkeleton_ClearState');
  Skeleton_Create := GetProcAddress(hDLL, 'CalSkeleton_Create');
  Skeleton_Destroy := GetProcAddress(hDLL, 'CalSkeleton_Destroy');
  Skeleton_GetBone := GetProcAddress(hDLL, 'CalSkeleton_GetBone');
  Skeleton_GetVectorBone := GetProcAddress(hDLL, 'CalSkeleton_GetVectorBone');
  Skeleton_LockState := GetProcAddress(hDLL, 'CalSkeleton_LockState');
  Skeleton_GetBonePoints := GetProcAddress(hDLL, 'CalSkeleton_GetBonePoints');
  Skeleton_GetBonePointsStatic := GetProcAddress(hDLL,
    'CalSkeleton_GetBonePointsStatic');
  Skeleton_GetBoneLines := GetProcAddress(hDLL, 'CalSkeleton_GetBoneLines');
  Skeleton_GetBoneLinesStatic := GetProcAddress(hDLL,
    'CalSkeleton_GetBoneLinesStatic');

  // *** CalSubmesh ***
  Submesh_New := GetProcAddress(hDLL, 'CalSubmesh_New');
  Submesh_Delete := GetProcAddress(hDLL, 'CalSubmesh_Delete');
  Submesh_Create := GetProcAddress(hDLL, 'CalSubmesh_Create');
  Submesh_Destroy := GetProcAddress(hDLL, 'CalSubmesh_Destroy');
  Submesh_GetCoreSubmesh := GetProcAddress(hDLL, 'CalSubmesh_GetCoreSubmesh');
  Submesh_GetCoreMaterialId := GetProcAddress(hDLL,
    'CalSubmesh_GetCoreMaterialId');
  Submesh_GetFaceCount := GetProcAddress(hDLL, 'CalSubmesh_GetFaceCount');
  Submesh_GetFaces := GetProcAddress(hDLL, 'CalSubmesh_GetFaces');
  Submesh_GetVertexCount := GetProcAddress(hDLL, 'CalSubmesh_GetVertexCount');
  Submesh_SetCoreMaterialId := GetProcAddress(hDLL,
    'CalSubmesh_SetCoreMaterialId');
  Submesh_SetLodLevel := GetProcAddress(hDLL, 'CalSubmesh_SetLodLevel');

  // *** CalVector ***
  Vector_New := GetProcAddress(hDLL, 'CalVector_New');
  Vector_Delete := GetProcAddress(hDLL, 'CalVector_Delete');
  Vector_Add := GetProcAddress(hDLL, 'CalVector_Add');
  Vector_Blend := GetProcAddress(hDLL, 'CalVector_Blend');
  Vector_Transform := GetProcAddress(hDLL, 'CalVector_Transform');
end;

procedure FreeCal3d();
begin
  // *** CalAnimation ***
  @Animation_Destroy := nil;
  @Animation_GetCoreAnimation := nil;
  @Animation_GetState := nil;
  @Animation_GetTime := nil;
  @Animation_GetType := nil;

  // *** CalAnimationAction ***
  @AnimationAction_New := nil;
  @AnimationAction_Delete := nil;
  @AnimationAction_Create := nil;
  @AnimationAction_Destroy := nil;
  @AnimationAction_Execute := nil;
  @AnimationAction_GetWeight := nil;
  @AnimationAction_Update := nil;

  // *** CalAnimationCycle ***
  @AnimationCycle_New := nil;
  @AnimationCycle_Delete := nil;
  @AnimationCycle_Blend := nil;
  @AnimationCycle_Create := nil;
  @AnimationCycle_Destroy := nil;
  @AnimationCycle_GetWeight := nil;
  @AnimationCycle_SetAsync := nil;
  @AnimationCycle_Update := nil;

  // *** CalBone ***
  Bone_New := nil;
  Bone_Delete := nil;
  Bone_BlendState := nil;
  Bone_CalculateState := nil;
  Bone_ClearState := nil;
  Bone_Create := nil;
  Bone_Destroy := nil;
  Bone_GetCoreBone := nil;
  Bone_GetRotation := nil;
  Bone_GetRotationAbsolute := nil;
  Bone_GetRotationBoneSpace := nil;
  Bone_GetTranslation := nil;
  Bone_GetTranslationAbsolute := nil;
  Bone_GetTranslationBoneSpace := nil;
  Bone_LockState := nil;
  Bone_SetSkeleton := nil;

  // *** CalCoreAnimation ***
  @CoreAnimation_New := nil;
  @CoreAnimation_Delete := nil;
  @CoreAnimation_AddCoreTrack := nil;
  @CoreAnimation_Create := nil;
  @CoreAnimation_Destroy := nil;
  @CoreAnimation_GetCoreTrack := nil;
  @CoreAnimation_GetDuration := nil;
  @CoreAnimation_GetListCoreTrack := nil;
  @CoreAnimation_SetDuration := nil;

  // *** CalCoreBone ***
  @CoreBone_New := nil;
  @CoreBone_Delete := nil;
  @CoreBone_AddChildId := nil;
  @CoreBone_CalculateState := nil;
  @CoreBone_Create := nil;
  @CoreBone_Destroy := nil;
  @CoreBone_GetListChildId := nil;
  @CoreBone_GetName := nil;
  @CoreBone_GetParentId := nil;
  @CoreBone_GetRotation := nil;
  @CoreBone_GetRotationAbsolute := nil;
  @CoreBone_GetTranslation := nil;
  @CoreBone_GetTranslationAbsolute := nil;
  @CoreBone_GetUserData := nil;
  @CoreBone_SetCoreSkeleton := nil;
  @CoreBone_SetParentId := nil;
  @CoreBone_SetRotation := nil;
  @CoreBone_SetTranslation := nil;
  @CoreBone_SetUserData := nil;

  // *** CalCoreKeyFrame ***
  @CoreKeyframe_New := nil;
  @CoreKeyframe_Delete := nil;
  @CoreKeyframe_Create := nil;
  @CoreKeyframe_Destroy := nil;
  @CoreKeyframe_GetRotation := nil;
  @CoreKeyframe_GetTime := nil;
  @CoreKeyframe_GetTranslation := nil;
  @CoreKeyframe_SetRotation := nil;
  @CoreKeyframe_SetTime := nil;
  @CoreKeyframe_SetTranslation := nil;

  // *** CalCoreMaterial ***
  @CoreMaterial_New := nil;
  @CoreMaterial_Delete := nil;
  @CoreMaterial_Create := nil;
  @CoreMaterial_Destroy := nil;
  @CoreMaterial_GetAmbientColor := nil;
  @CoreMaterial_GetDiffuseColor := nil;
  @CoreMaterial_GetMapCount := nil;
  @CoreMaterial_GetMapFilename := nil;
  @CoreMaterial_GetMapUserData := nil;
  @CoreMaterial_GetShininess := nil;
  @CoreMaterial_GetSpecularColor := nil;
  @CoreMaterial_GetUserData := nil;
  @CoreMaterial_GetVectorMap := nil;
  @CoreMaterial_Reserve := nil;
  @CoreMaterial_SetMUserData := nil;
  @CoreMaterial_SetAmbientColor := nil;
  @CoreMaterial_SetDiffuseColor := nil;
  @CoreMaterial_SetMap := nil;
  @CoreMaterial_SetMapUserData := nil;
  @CoreMaterial_SetShininess := nil;
  @CoreMaterial_SetSpecularColor := nil;
  @CoreMaterial_SetUserData := nil;

  // *** CalCoreMesh ***
  @CoreMesh_New := nil;
  @CoreMesh_Delete := nil;
  @CoreMesh_AddCoreSubmesh := nil;
  @CoreMesh_Create := nil;
  @CoreMesh_Destroy := nil;
  @CoreMesh_GetCoreSubmesh := nil;
  @CoreMesh_GetCoreSubmeshCount := nil;
  @CoreMesh_GetVectorCoreSubmesh := nil;

  // *** CalCoreModel ***
  @CoreModel_New := nil;
  @CoreModel_Delete := nil;
  @CoreModel_AddCoreAnimation := nil;
  @CoreModel_AddCoreMaterial := nil;
  @CoreModel_AddCoreMesh := nil;
  @CoreModel_Create := nil;
  @CoreModel_CreateCoreMaterialThread := nil;
  @CoreModel_Destroy := nil;
  @CoreModel_GetCoreAnimation := nil;
  @CoreModel_GetCoreAnimationCount := nil;
  @CoreModel_GetCoreMaterial := nil;
  @CoreModel_GetCoreMaterialCount := nil;
  @CoreModel_GetCoreMaterialId := nil;
  @CoreModel_GetCoreMesh := nil;
  @CoreModel_GetCoreMeshCount := nil;
  @CoreModel_GetCoreSkeleton := nil;
  @CoreModel_GetUserData := nil;
  @CoreModel_LoadCoreAnimation := nil;
  @CoreModel_LoadCoreMaterial := nil;
  @CoreModel_LoadCoreMesh := nil;
  @CoreModel_LoadCoreSkeleton := nil;
  @CoreModel_SaveCoreAnimation := nil;
  @CoreModel_SaveCoreMaterial := nil;
  @CoreModel_SaveCoreMesh := nil;
  @CoreModel_SaveCoreSkeleton := nil;
  @CoreModel_SetCoreMaterialId := nil;
  @CoreModel_SetUserData := nil;

  // *** CalCoreSkeleton ***
  @CoreSkeleton_New := nil;
  @CoreSkeleton_Delete := nil;
  @CoreSkeleton_AddCoreBone := nil;
  @CoreSkeleton_AddRootCoreBoneId := nil;
  @CoreSkeleton_CalculateState := nil;
  @CoreSkeleton_Create := nil;
  @CoreSkeleton_Destroy := nil;
  @CoreSkeleton_GetCoreBone := nil;
  @CoreSkeleton_GetCoreBoneId := nil;
  @CoreSkeleton_GetListRootCoreBoneId := nil;
  @CoreSkeleton_GetVectorCoreBone := nil;

  // *** CalCoreSubmesh ***
  @CoreSubmesh_New := nil;
  @CoreSubmesh_Delete := nil;
  @CoreSubmesh_Create := nil;
  @CoreSubmesh_Destroy := nil;
  @CoreSubmesh_GetCoreMaterialThreadId := nil;
  @CoreSubmesh_GetFaceCount := nil;
  @CoreSubmesh_GetLodCount := nil;
  @CoreSubmesh_GetVectorFace := nil;
  @CoreSubmesh_GetVectorVectorTextureCoordinate := nil;
  @CoreSubmesh_GetVectorVertex := nil;
  @CoreSubmesh_GetVertexCount := nil;
  @CoreSubmesh_Reserve := nil;
  @CoreSubmesh_SetCoreMaterialThreadId := nil;
  @CoreSubmesh_SetFace := nil;
  @CoreSubmesh_SetLodCount := nil;
  @CoreSubmesh_SetTextureCoordinate := nil;
  @CoreSubmesh_SetVertex := nil;

  // *** CalCoreTrack ***
  @CoreTrack_New := nil;
  @CoreTrack_Delete := nil;
  @CoreTrack_AddCoreKeyframe := nil;
  @CoreTrack_Create := nil;
  @CoreTrack_Destroy := nil;
  @CoreTrack_GetCoreBoneId := nil;
  @CoreTrack_GetMapCoreKeyframe := nil;
  @CoreTrack_GetState := nil;
  @CoreTrack_SetCoreBoneId := nil;

  // *** CalLoader ***
  @Loader_New := nil;
  @Loader_Delete := nil;
  @Loader_LoadCoreAnimation := nil;
  @Loader_LoadCoreMaterial := nil;
  @Loader_LoadCoreMesh := nil;
  @Loader_LoadCoreSkeleton := nil;

  // *** CalMesh ***
  @Mesh_New := nil;
  @Mesh_Delete := nil;
  @Mesh_Create := nil;
  @Mesh_Destroy := nil;
  @Mesh_GetCoreMesh := nil;
  @Mesh_GetSubmesh := nil;
  @Mesh_GetSubmeshCount := nil;
  @Mesh_SetLodLevel := nil;
  @Mesh_SetMaterialSet := nil;
  @Mesh_SetModel := nil;

  // *** CalMixer ***
  @Mixer_New := nil;
  @Mixer_Delete := nil;
  @Mixer_BlendCycle := nil;
  @Mixer_ClearCycle := nil;
  @Mixer_Create := nil;
  @Mixer_Destroy := nil;
  @Mixer_ExecuteAction := nil;
  @Mixer_UpdateAnimation := nil;
  @Mixer_UpdateSkeleton := nil;

  // *** CalModel ***
  @Model_New := nil;
  @Model_Delete := nil;
  @Model_Create := nil;
  @Model_Destroy := nil;
  @Model_AttachMesh := nil;
  @Model_GetCoreModel := nil;
  @Model_GetMixer := nil;
  @Model_GetRenderer := nil;
  @Model_GetSkeleton := nil;
  @Model_GetUserData := nil;
  @Model_SetLodLevel := nil;
  @Model_SetMaterialSet := nil;
  @Model_SetUserData := nil;
  @Model_Update := nil;

  // *** CalQuaternion ***
  @Quaternion_New := nil;
  @Quaternion_Delete := nil;
  @Quaternion_Blend := nil;
  @Quaternion_Product1 := nil;
  @Quaternion_Product3 := nil;
  @Quaternion_Product4 := nil;

  // *** CalRenderer ***
  @Renderer_New := nil;
  @Renderer_Delete := nil;
  @Renderer_BeginRendering := nil;
  @Renderer_Create := nil;
  @Renderer_Destroy := nil;
  @Renderer_DetachMesh := nil;
  @Renderer_EndRendering := nil;
  @Renderer_GetAmbientColor := nil;
  @Renderer_GetDiffuseColor := nil;
  @Renderer_GetFaceCount := nil;
  @Renderer_GetFaces := nil;
  @Renderer_GetMapCount := nil;
  @Renderer_GetMapUserData := nil;
  @Renderer_GetMeshCount := nil;
  @Renderer_GetNormals := nil;
  @Renderer_GetShininess := nil;
  @Renderer_GetSpecularColor := nil;
  @Renderer_GetSubmeshCount := nil;
  @Renderer_GetTextureCoordinates := nil;
  @Renderer_GetVectorMesh := nil;
  @Renderer_GetVertexCount := nil;
  @Renderer_GetVertices := nil;
  @Renderer_SelectMeshSubmesh := nil;

  // *** CalSaver ***
  @Saver_New := nil;
  @Saver_Delete := nil;
  @Saver_SaveCoreAnimation := nil;
  @Saver_SaveCoreMaterial := nil;
  @Saver_SaveCoreMesh := nil;
  @Saver_SaveCoreSkeleton := nil;

  // *** CalSkeleton ***
  @Skeleton_New := nil;
  @Skeleton_Delete := nil;
  @Skeleton_CalculateState := nil;
  @Skeleton_ClearState := nil;
  @Skeleton_Create := nil;
  @Skeleton_Destroy := nil;
  @Skeleton_GetBone := nil;
  @Skeleton_GetVectorBone := nil;
  @Skeleton_LockState := nil;
  @Skeleton_GetBonePoints := nil;
  @Skeleton_GetBonePointsStatic := nil;
  @Skeleton_GetBoneLines := nil;
  @Skeleton_GetBoneLinesStatic := nil;

  // *** CalSubmesh ***
  @Submesh_New := nil;
  @Submesh_Delete := nil;
  @Submesh_Create := nil;
  @Submesh_Destroy := nil;
  @Submesh_GetCoreSubmesh := nil;
  @Submesh_GetCoreMaterialId := nil;
  @Submesh_GetFaceCount := nil;
  @Submesh_GetFaces := nil;
  @Submesh_GetVertexCount := nil;
  @Submesh_SetCoreMaterialId := nil;
  @Submesh_SetLodLevel := nil;

  // *** CalVector ***
  @Vector_New := nil;
  @Vector_Delete := nil;
  @Vector_Add := nil;
  @Vector_Blend := nil;
  @Vector_Transform := nil;

  FreeLibrary(hDLL);
  hDLL := 0;
end;

{$WARNINGS OFF}

end.

{
  $Log: cal3d.pas,v $
  Revision 1.4  2003/05/31 23:14:44  pythian
  new Editor almost stable

  Revision 1.3  2002/10/11 14:23:44  pythian
  Skeletal Animation, Cal 0.8, golurut

  Revision 1.2  2002/06/09 22:44:00  pythian
  Quake 3 bsp importer and patches working, Cal3D texture fix

  Revision 1.1  2002/06/09 14:02:11  mhearn
  Committed basic skeletal modelling code -mike

  Revision 1.9  2001/12/27 10:01:28  elessar
  - prepared for publishing :)

  Revision 1.8  2001/12/25 16:01:49  elessar
  - cosmetic changes (nothing significant)

  Revision 1.7  2001/12/23 17:07:31  elessar
  - can't remember :)

  Revision 1.6  2001/12/03 12:01:29  elessar
  - now it works!

  Revision 1.5  2001/11/25 18:24:30  elessar
  - some additional types in cal3d.pas

  Revision 1.4  2001/11/23 23:48:24  elessar
  - first quite well working version

  Revision 1.3  2001/11/22 14:35:37  elessar
  - CalAnimation, CalAnimationAction and CalAnimationCycle classes

  Revision 1.2  2001/11/20 20:58:25  elessar
  - Testing external functions

}