cal3d-0.1: c++/cal3d_c.cc

#include <cal3d/cal3d.h>

#include "cal3d_c.h"

/* ----------------------------------------------------------------------
   Class CalCoreModel
   ---------------------------------------------------------------------- */

CoreModelP newCoreModel (char * name) {
  return (CoreModelP) new CalCoreModel((const char *) name);
}


void deleteCoreModel (CoreModelP model) {
  delete (CalCoreModel *) model;
}


int loadCoreSkeleton (CoreModelP model, char * path) {
  // cast from bool
  return (int) 
    ((CalCoreModel *) model)->loadCoreSkeleton ((const char *) path);
}

int loadCoreAnimation (CoreModelP model, char * path) {
  // -1 = failed
  return ((CalCoreModel *) model)->loadCoreAnimation ((const char *) path);

}

int loadCoreMesh (CoreModelP model, char * path) {
  // -1 = failed
  return ((CalCoreModel *) model)->loadCoreMesh ((const char *) path);

}

int loadCoreMaterial(CoreModelP model, char * path) {
  // -1 = failed
  return ((CalCoreModel *) model)->loadCoreMaterial ((const char *) path);

}

int createCoreMaterialThread(CoreModelP model, int matl_thread_id) {
  // cast from bool
  return (int) 
    ((CalCoreModel *) model)->createCoreMaterialThread(matl_thread_id);
}

int setCoreMaterialId(CoreModelP model, int matl_thread, int matl_set,
		      int matl_id) {
  // cast from bool
  return (int) 
    ((CalCoreModel *) model)->
    setCoreMaterialId(matl_thread, matl_set, matl_id);
}

/* ----------------------------------------------------------------------
   Class CalMixer
   ---------------------------------------------------------------------- */


MixerP newMixer (ModelP model) {
  return (MixerP) new CalMixer((CalModel *) model);
}

void deleteMixer (MixerP mixer) {
  delete (CalMixer *) mixer;
}

int blendCycle(MixerP mixer, int id, float weight, float delay) {
  return (int)
    ((CalMixer *) mixer) ->
    blendCycle(id, weight, delay);
}

int clearCycle (MixerP mixer, int id, float delay) {
  return (int)
    ((CalMixer *) mixer) ->
    clearCycle(id, delay);

}

int executeAction (MixerP mixer, int id, float delayIn, float delayOut,
		   float weightTarget, int autoLock) {
  return (int)
    ((CalMixer *) mixer) ->
    executeAction (id, delayIn, delayOut, weightTarget, autoLock);

}


/* ----------------------------------------------------------------------
   Class CalModel
   ---------------------------------------------------------------------- */

ModelP newModel (CoreModelP coreModel) { 
  return (ModelP) new CalModel((CalCoreModel *) coreModel);
}

void deleteModel (ModelP model) { 
  delete (CalModel *) model;

}

int attachMesh (ModelP model, int coreMeshId) {
  // cast from bool
  return (int)
    ((CalModel *) model)->attachMesh(coreMeshId);
}

void setLodLevel (ModelP model, float lodLevel) { 
  ((CalModel *) model)->setLodLevel(lodLevel);
}

void setMaterialSet (ModelP model, int setId) { 
  ((CalModel *) model)->setMaterialSet(setId);
}
  
MixerP getMixer (ModelP model) { 
  return (MixerP)
    ((CalModel *) model)->getMixer();
}

/* update model for deltaTime seconds */
void update (ModelP model, float deltaTime) { 
  ((CalModel *) model)->update(deltaTime);
} 

RendererP getRenderer (ModelP model) {
  return (RendererP)
    ((CalModel *) model)->getRenderer();
}

/* ----------------------------------------------------------------------
   Class CalRenderer
   ---------------------------------------------------------------------- */


RendererP newRenderer (ModelP model) {
  return (RendererP) new CalRenderer ((CalModel *) model);
}

void deleteRenderer(RendererP renderer) {
  delete (CalRenderer *) renderer;
}

int beginRendering (RendererP renderer) {
  /* cast from bool */
  return (int)
    ((CalRenderer *) renderer) -> beginRendering();
}

void endRendering (RendererP renderer) {
  ((CalRenderer *) renderer) -> endRendering();
}


void getAmbientColor(RendererP renderer, unsigned char *pColorBuffer) {
  ((CalRenderer *) renderer) -> getAmbientColor(pColorBuffer);
}

void getDiffuseColor(RendererP renderer, unsigned char *pColorBuffer) {
  ((CalRenderer *) renderer) -> getDiffuseColor(pColorBuffer);
}

void getSpecularColor(RendererP renderer, unsigned char *pColorBuffer) {
  ((CalRenderer *) renderer) -> getSpecularColor(pColorBuffer);
}

float getShininess (RendererP renderer) {
  return ((CalRenderer *) renderer) -> getShininess();
}

/*
  int getMapCount(RendererP renderer);
  Cal::UserData getMapUserData(RendererP renderer, int mapId);
*/

int getMeshCount(RendererP renderer) {
  return ((CalRenderer *)renderer) -> getMeshCount();
}

/*
  int getNormals(RendererP renderer, float *pNormalBuffer, int stride=0);
  float getShininess(RendererP renderer);
  void getSpecularColor(RendererP renderer, unsigned char *pColorBuffer);
*/

int getSubmeshCount(RendererP renderer, int meshId) {
  return ((CalRenderer *) renderer) -> getSubmeshCount(meshId);
}


/*
  int getTextureCoordinates(RendererP renderer, int mapId, 
			    float *pTextureCoordinateBuffer, int stride);
*/


int getFaceCount(RendererP renderer) {
  return ((CalRenderer *)renderer) -> getFaceCount();
}

/* Writes to pFaceBuffer, affected by LOD setting;
   returns number of faces written to the buffer */

int getFaces(RendererP renderer, CalIndex *pFaceBuffer) {
  return ((CalRenderer *) renderer) -> getFaces(pFaceBuffer);
}

int getVertexCount(RendererP renderer) {
  return ((CalRenderer *) renderer) -> getVertexCount();
}

/* getVertices side-effects pVertexBuffer and returns the
   number of vertices written to the buffer */

int getVertices(RendererP renderer, float *pVertexBuffer, int stride=0) {
  return ((CalRenderer *) renderer) -> getVertices(pVertexBuffer, stride);
} 

int getNormals(RendererP renderer, float *pNormalBuffer, int stride) {
  return ((CalRenderer *) renderer) -> getNormals(pNormalBuffer, stride);
}

/*
  int getTangentSpaces(RendererP renderer, int mapId, 
		       float *pTangentSpaceBuffer, int stride);
  int getVerticesAndNormals(RendererP renderer, 
			    float *pVertexBuffer, int stride);
  int getVerticesNormalsAndTexCoords(RendererP renderer, 
				     float *pVertexBuffer,int NumTexCoords);
  bool isTangentsEnabled(RendererP renderer, int mapId);
*/

int selectMeshSubmesh(RendererP renderer, int meshId, int submeshId) {
  return (int) /* cast from bool */
    ((CalRenderer *) renderer) -> selectMeshSubmesh(meshId, submeshId);
}

/*
  void setNormalization(RendererP renderer, bool normalize);
*/

/* ------------------------------------------------------------------------
   DEBUG AIDS
   ------------------------------------------------------------------------ */

int calVectorSize () {
  CalVector v;
  return sizeof v;
}

void dumpVertices (RendererP renderer) {
  static float vtx [30000][3];
  int n = 0; 
  CalRenderer * calRenderer = (CalRenderer *) renderer;
  n = calRenderer->getVertexCount();
  std::cerr << "Got " << n << " vertices\n";

  /* NEXT STATEMENT SEGFAULTS, also with optional arg 0, 3, or 12 */
  /* n = calRenderer->getVertices(&vtx[0][0]); */
  n = calRenderer->getVertices(&vtx[0][0], 12);

  std::cerr << "Got " << n << " vertices\n";
    /* getVertices(renderer, vtx, 3);
  for (int i = 0; i < n; i++) {
    std::cerr << i << ": " << vtx[i] << "\nl";
  }
    */
}