Serious-Engine/Sources/LWSkaExporter/SectionsExport.cpp

/* Copyright (c) 2002-2012 Croteam Ltd. All rights reserved. */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <assert.h>
#include <lwsurf.h>
#include <lwhost.h>
#include <lwserver.h>
#include <lwgeneric.h>
#include <crtdbg.h>
#include <stdarg.h>
#include "vecmat.h"
#include <crtdbg.h>

#include <lwserver.h>
#include <lwmotion.h>
#include <lwxpanel.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "base.h"

static int _iFrame = 0;
static int _ctFrames = 0;
static int _ctBones = 0;
static int ctBoneEnvelopes = 0;
static int ctMorphEnvelopes = 0;
static LWItemID idMasterObjID = 0;

extern bool bRecordDefaultFrame;
extern int ReloadGlobalObjects();
extern bool bExportAbsPositions;  // export first bone absolute position
typedef float Matrix12[12];



static int _ctNumBones;
static FILE *_f = NULL;
static char *_strFileName = NULL;

static BoneInfo *_pbiFirst = NULL; // linked list of all instances
static MorphInfo *_pmiFirst = NULL; // linked list of all instances
static Matrix12 *_pmRootBoneAbs=NULL;


/*
======================================================================
Create()

Handler callback.  Allocate and initialize instance data.
====================================================================== */				 
XCALL_( static LWInstance )
Create( void *priv, LWItemID item, LWError *err )
{
  // create the instance
  BoneInfo *pii = (BoneInfo*)malloc(sizeof(BoneInfo));
  pii->bi_strName = strdup(_iti->name(item));  

  _ctBones++;

  // get parent bone name
  LWItemID pParentID = _iti->parent(item);
  //strdup()
  pii->bi_strParentName = strdup(_iti->name(pParentID));
  if(pParentID == LWITEM_NULL) {
    // this is root bone
    pii->bi_strParentName = "";
  }
  // get item type
  pii->bi_lwItemType = _iti->type(item);

  // allocate space for storing frames
  pii->bi_abfFrames = (BoneFrame*)malloc(sizeof(BoneFrame)*_ctFrames);
  
  // if first time here
/*  if(_pbiFirst==NULL)
  {
    // allocate space for storing absolute position for root bone
    _pmRootBoneAbs = (Matrix12*)malloc(sizeof(Matrix12)*_ctFrames);
    for(int ifr=0;ifr<_ctFrames;ifr++)
    {
      // reset matrices of root bone for all frames
      MakeIdentityMatrix(_pmRootBoneAbs[ifr]);
      int a=0;
    }
  }
*/
  // link into list
  pii->bi_pbiNext = _pbiFirst;

  _pbiFirst = pii;
  return pii;
};


/*
======================================================================
Destroy()

Handler callback.  Free resources allocated by Create().
====================================================================== */

XCALL_( static void )
Destroy( BoneInfo *inst)
{
  free(inst);
  //free(_pmRootBoneAbs);
}


/*
======================================================================
Copy()

Handler callback.  Copy instance data.
====================================================================== */

XCALL_( static LWError )
Copy( BoneInfo *to, BoneInfo *from )
{
  *to = *from;
  return NULL;
}


/*
======================================================================
Load()

Handler callback.  Read instance data.
====================================================================== */

XCALL_( static LWError )
Load( BoneInfo *inst, const LWLoadState *ls )
{
  return NULL;
}


/*
======================================================================
Save()

Handler callback.  Write instance data.
====================================================================== */

XCALL_( static LWError )
Save( BoneInfo *inst, const LWSaveState *ss )
{
   return NULL;
}


/*
======================================================================
Describe()

Handler callback.  Write a short, human-readable string describing
the instance data.
====================================================================== */

XCALL_( static const char * )
Describe( BoneInfo *inst )
{
  static char desc[ 80 ];
  sprintf( desc, "SE Sections Motion Export Handler");
  return desc;
}


/*
======================================================================
Flags()

Handler callback.
====================================================================== */

XCALL_( static int )
Flags( BoneInfo *inst )
{
   return LWIMF_AFTERIK;
}


/*
======================================================================
Evaluate()

Handler callback.  This is where we can modify the item's motion.
====================================================================== */

XCALL_( static void )
Evaluate( BoneInfo *pii, const LWItemMotionAccess *access )
{
  LWItemID parentID,parentparentID;
  double pos[3], rot[3];
 	double dvParentPos[3] = {0,0,0};
	double dvParentRot[3] = {0,0,0};


  access->getParam( LWIP_POSITION, access->time, pos);
  access->getParam( LWIP_ROTATION, access->time, rot);
  parentID = _iti->parent(access->item);


  LWItemID bone = access->item;

	if (access->item != idMasterObjID) {
		parentID = _iti->parent(bone);
  
    _pmesh = _obi->meshInfo(parentID, 0);
    if (_pmesh != NULL) {
      parentparentID = _iti->parent(parentID);

      _pmesh = _obi->meshInfo(parentparentID, 0);
      if (_pmesh == NULL) {
        _iti->param(parentparentID,LWIP_POSITION,0,dvParentPos);     
      } else {
			  _iti->param(parentID,LWIP_POSITION,0,dvParentPos);
      }
    }  else {
        parentparentID = _iti->parent(parentID);

        _pmesh = _obi->meshInfo(parentparentID, 0);
        if (_pmesh == NULL) {
          _iti->param(parentID,LWIP_POSITION,0,dvParentPos);        
        }
      }
	}
  
  

  pii->bi_abfFrames[_iFrame].fi_vPos[0] = (float)(pos[0] - dvParentPos[0]);
  pii->bi_abfFrames[_iFrame].fi_vPos[1] = (float)(pos[1] - dvParentPos[1]);
  pii->bi_abfFrames[_iFrame].fi_vPos[2] = (float)(pos[2] - dvParentPos[2]);
  pii->bi_abfFrames[_iFrame].fi_vRot[0] = (float)(rot[0] - dvParentRot[0]);
  pii->bi_abfFrames[_iFrame].fi_vRot[1] = (float)(rot[1] - dvParentRot[1]);
  pii->bi_abfFrames[_iFrame].fi_vRot[2] = (float)(rot[2] - dvParentRot[2]);

  /*// get pivot position
  _iti->param(bone,LWIP_PIVOT,access->time,pivotpos);
  _iti->param(bone,LWIP_PIVOT_ROT,access->time,pivotrot);
  float fPivotPos[3], fPivotRot[3];
  for(int ia=0;ia<3;ia++)
  {
    fPivotPos[ia] = (float)pivotpos[ia];
    fPivotRot[ia] = (float)pivotrot[ia];
  }
  fPivotPos[2] *=-1;
  pii->bi_abfFrames[_iFrame].fi_vPos[2] *=-1;
  
  // get object pivot matix
  Matrix12 mPivot,mPivotInvert;
  MakeRotationAndPosMatrix(mPivot,fPivotPos,fPivotRot);
  MatrixTranspose(mPivotInvert,mPivot);
  // get object matrix
  Matrix12 mTemp,mObject;
  MakeRotationAndPosMatrix(mObject,&pii->bi_abfFrames[_iFrame].fi_vPos[0],&pii->bi_abfFrames[_iFrame].fi_vRot[0]);
  MatrixCopy(mTemp,mObject);
  MatrixMultiply(mObject,mTemp,mPivotInvert);

  //MakeIdentityMatrix(mTemp);
  //MatrixCopy(mTemp,mPivot);

  // add its position and rotation to abs matrix
  //MakeIdentityMatrix(mTemp);
  MatrixCopy(mTemp,_pmRootBoneAbs[_iFrame]);
  MatrixMultiply(_pmRootBoneAbs[_iFrame],mObject,mTemp);*/
  pii->bi_abfFrames[_iFrame].fi_vPos[2] *=-1;

};













XCALL_( int )
SectionAnimation_Handler( long version, GlobalFunc *_global, LWItemMotionHandler *local,
   void *serverData)
{
  if ( version != LWITEMMOTION_VERSION ) return AFUNC_BADVERSION;

  _iti = (LWItemInfo *)_global(LWITEMINFO_GLOBAL, GFUSE_TRANSIENT);
  if (_iti==NULL) {
    return AFUNC_BADGLOBAL;
  }

  local->inst->create  = Create;
  local->inst->destroy = (void (*)(void *))Destroy;
  local->inst->load    = (const char *(__cdecl *)(void *,const struct st_LWLoadState *))Load;
  local->inst->save    = (const char *(__cdecl *)(void *,const struct st_LWSaveState *))Save;
  local->inst->copy    = (const char *(__cdecl *)(void *,void *))Copy;
  local->inst->descln  = (const char *(__cdecl *)(void *))Describe;
  local->evaluate      = (void (__cdecl *)(void *,const struct st_LWItemMotionAccess *))Evaluate;
  local->flags         = (unsigned int (__cdecl *)(void *))Flags;

  return AFUNC_OK;
}






void AddBoneToCount(LWItemID objectid) 
{
	LWItemID childID;

	childID = _iti->firstChild(objectid);
	if(_iti->type(objectid) == LWI_OBJECT)
  {
    _pmesh = _obi->meshInfo(objectid, 0);
    if((_pmesh == NULL) && (childID == LWITEM_NULL))
    {
			return;
		}

		_ctNumBones++;

		while (childID != LWITEM_NULL) {
			AddBoneToCount(childID);
			childID = _iti->nextChild(objectid,childID);
		}

  }

};



void WriteBoneInfo(LWItemID objectid) 
{
	LWItemID childID,parentID,parentparentID;
	double dvPos[3],dvRot[3];
	double dvParentPos[3] = {0,0,0};
	double dvParentRot[3] = {0,0,0};
	float  fvPos[3],fvRot[3];
	Matrix12 bi_mRot;
	const char *strName, *strParentName;
	float fLength = 0.5;


	childID = _iti->firstChild(objectid);
	if(_iti->type(objectid) == LWI_OBJECT)
  {
		
    _pmesh = _obi->meshInfo(objectid, 0);
    if((_pmesh == NULL) && (childID == LWITEM_NULL))
    {
			return;
		}


		_iti->param(objectid,LWIP_POSITION,0,dvPos);
		_iti->param(objectid,LWIP_ROTATION,0,dvRot);

		strName = _iti->name(objectid);
		fprintf(_f, "  NAME \"%s\";\n", strName);
		if (_ctNumBones > 0) {

			parentID = _iti->parent(objectid);
  
      _pmesh = _obi->meshInfo(parentID, 0);
      if (_pmesh != NULL) {
        parentparentID = _iti->parent(parentID);

        _pmesh = _obi->meshInfo(parentparentID, 0);
        if (_pmesh == NULL) {
          _iti->param(parentparentID,LWIP_POSITION,0,dvParentPos);
			    //_iti->param(parentparentID,LWIP_ROTATION,0,dvParentRot);
          
        } else {
			    _iti->param(parentID,LWIP_POSITION,0,dvParentPos);
			    //_iti->param(parentID,LWIP_ROTATION,0,dvParentRot);
        }
      } else {
        parentparentID = _iti->parent(parentID);

        _pmesh = _obi->meshInfo(parentparentID, 0);
        if (_pmesh == NULL) {
          _iti->param(parentID,LWIP_POSITION,0,dvParentPos);
			   // _iti->param(parentID,LWIP_ROTATION,0,dvParentRot);
        
        }
      }


			strParentName =  _iti->name(parentID);			
		} else {
			strParentName = strdup("");
		}

    	
		fprintf(_f, "  PARENT \"%s\";\n", strParentName);
    fprintf(_f, "  LENGTH %g;\n", fLength);
    fprintf(_f, "  {\n");

		for (int i=0;i<3;i++) {
			fvPos[i] = (float) (dvPos[i] - dvParentPos[i]);
			fvRot[i] = 0;//(float) (dvRot[i] - dvParentRot[i]);
		}
		fvPos[2] = -fvPos[2];

		MakeRotationAndPosMatrix(bi_mRot,fvPos,fvRot);
    PrintMatrix(_f,bi_mRot,4);
    fprintf(_f,"\n  }\n");

		_ctNumBones++;

		 while (childID != LWITEM_NULL) {
		 	 WriteBoneInfo(childID);
		 	 childID = _iti->nextChild(objectid,childID);
		 }

  }

};



bool AddMotionHandler(LWItemID objectid) 
{
	LWItemID childID;

	childID = _iti->firstChild(objectid);
	if(_iti->type(objectid) == LWI_OBJECT)
  {
    _pmesh = _obi->meshInfo(objectid, 0);
    if((_pmesh == NULL) && (childID == LWITEM_NULL))
    {
			return false;
		}

		if (!ExecCmd("SelectItem %x", objectid)) {
			_msg->error("ERROR: Item selection\n", NULL);	
			return false;
		}
		if (!ExecCmd("ApplyServer ItemMotionHandler " DEBUGEXT "internal_SESectionAnimExport")) {
			_msg->error("ERROR: Applying ItemMotionHandler\n", NULL);	
			return false;
		}

		while (childID != LWITEM_NULL) {
			AddMotionHandler(childID);
			childID = _iti->nextChild(objectid,childID);
		}

  }

	return true;

};



int RemoveMotionHandler(LWItemID objectid) 
{
	LWItemID childID;

	childID = _iti->firstChild(objectid);
	if(_iti->type(objectid) == LWI_OBJECT)
  {
    _pmesh = _obi->meshInfo(objectid, 0);
    if((_pmesh == NULL) && (childID == LWITEM_NULL))
    {
			return false;
		}

	  if (!ExecCmd("SelectItem %x", objectid)) {
			_msg->error("ERROR: Item selection\n", NULL);	
			return false;
		}
		for(int iServer=1;;iServer++) {
			const char *strServer = _iti->server(objectid, "ItemMotionHandler", iServer);
			if (strServer==NULL) {
				break;
			}
			if (strcmp(strServer, DEBUGEXT "internal_SESectionAnimExport")==0) {
				if (!ExecCmd("RemoveServer ItemMotionHandler %d", iServer)) {
					_msg->error("ERROR: Applying ItemMotionHandler\n", NULL);	
					return false;
				}
			}
		}

		while (childID != LWITEM_NULL) {
			RemoveMotionHandler(childID);
			childID = _iti->nextChild(objectid,childID);
		}
  }

	return true;

};






int ExportBones() 
{
	LWItemID idMasterObjID;
	char strMessage[256];

	if(!_evaluate)
  {
    // lightwave error
    _msg->error("Lightwave process error !\nClose plugins window and try again.\n", NULL);
    return AFUNC_BADAPP;
  }

  // !!!! make it work with a selected object, not the first one in scene
  ReloadGlobalObjects();

  bool bExportOnlySelected = false;
  int ctSkeletonBones=0;

  // find selected object - to be replaced with the master bone
  int ctSelected = 0;
  int ctMeshes=0;
  _objid = _iti->first(LWI_OBJECT,0);
	idMasterObjID = LWITEM_NULL;
  while(_objid != LWITEM_NULL)
  {
    if(_iti->type(_objid) == LWI_OBJECT)
    {
        if(_ifi->itemFlags(_objid) & LWITEMF_SELECTED)
        {
          ctSelected++;
					idMasterObjID = _objid;
        }
      ctMeshes++;
    }
    _objid = _iti->next(_objid);
  }

	if (idMasterObjID == LWITEM_NULL) 
	{
    // lightwave error
    _msg->error("ERROR: Object for top level bone not selected.\n", NULL);
    return AFUNC_BADAPP;
  }

	if (ctSelected > 1) 
	{
    // lightwave error
    _msg->error("ERROR: More than one object selected.\n", NULL);
    return AFUNC_BADAPP;
  }
		
	_ctNumBones = 0;
	AddBoneToCount(idMasterObjID);

	sprintf(strMessage,"Number of bones: %d",_ctNumBones);


  // get scene name
  _strFileName = strdup(_sci->filename);

  // open the file to print into
  char fnmOut[256];
  strcpy(fnmOut, _strFileName);
  char *pchDot = strrchr(fnmOut, '.');
  if (pchDot!=NULL) {
    strcpy(pchDot, ".as");
  }

  _msg->info(strMessage,fnmOut);

	if ((_f = fopen(fnmOut,"w")) == NULL) {
		_msg->error("ERROR: File open.\n", NULL);
    return AFUNC_BADAPP;
	}

	fprintf(_f, "SE_SKELETON %s;\n\n",SE_ANIM_VER);
  fprintf(_f, "BONES %d\n{\n",_ctNumBones);

	_ctNumBones = 0;
	WriteBoneInfo(idMasterObjID);

	fprintf(_f, "}\n\nSE_SKELETON_END;\n");
	fclose(_f);


	return AFUNC_OK;
};






int ExportSecAnim(LWXPanelID pan) 
{

	LWItemID idMasterObjID;
	char strMessage[256];
	Matrix12 bi_mRot;


  _iFrame = 0;
  _ctFrames = 0;
  _ctBones = 0;
  ctBoneEnvelopes = 0;
  ctMorphEnvelopes = 0;

	if(!_evaluate)
  {
    // lightwave error
    _msg->error("Lightwave process error !\nClose plugins window and try again.\n", NULL);
    return AFUNC_BADAPP;
  }

  // !!!! make it work with a selected object, not the first one in scene
  ReloadGlobalObjects();

	
  bool bExportOnlySelected = false;
  int ctSkeletonBones=0;

  // find selected object - to be replaced with the master bone
  int ctSelected = 0;
  int ctMeshes=0;
  _objid = _iti->first(LWI_OBJECT,0);
	idMasterObjID = LWITEM_NULL;
  while(_objid != LWITEM_NULL)
  {
    if(_iti->type(_objid) == LWI_OBJECT)
    {
        if(_ifi->itemFlags(_objid) & LWITEMF_SELECTED)
        {
          ctSelected++;
					idMasterObjID = _objid;
        }
      ctMeshes++;
    }
    _objid = _iti->next(_objid);
  }

	if (idMasterObjID == LWITEM_NULL) 
	{
    // lightwave error
    _msg->error("ERROR: Object for top level bone not selected.\n", NULL);
    return AFUNC_BADAPP;
  }

	if (ctSelected > 1) 
	{
    // lightwave error
    _msg->error("ERROR: More than one object selected.\n", NULL);
    return AFUNC_BADAPP;
  }
		
  // get scene name
  _strFileName = strdup(_sci->filename);

  // open the file to print into
  char fnmOut[256];
  strcpy(fnmOut, _strFileName);
  char *pchDot = strrchr(fnmOut, '.');
  if (pchDot!=NULL) {
    strcpy(pchDot, ".aa");
  }
	_ctNumBones = 0;
	AddBoneToCount(idMasterObjID);


	if ((_f = fopen(fnmOut,"w")) == NULL) {
		_msg->error("ERROR: File open.\n", NULL);
    return AFUNC_BADAPP;
	}
	
// calculate number of frames to export
  _ctFrames = ((_ifi->previewEnd-_ifi->previewStart)/_ifi->previewStep)+1;
  if (_ctFrames<=0) {
    _ctFrames = 1;
  }


  // find all morph channels for the current mesh
  _pmiFirst = NULL;
  FindMorphChannels(NULL);


	AddMotionHandler(idMasterObjID);

  sprintf(strMessage,"ctBoneEnvelopes: %d",_ctBones);
	_msg->error(strMessage,fnmOut);


  bRecordDefaultFrame = true;
  if (!ExecCmd("GoToFrame 0"))
  {
//    goto end;
  }
  bRecordDefaultFrame = false;


  int bExportAnimBackward = *(int*)_xpanf->formGet( pan, ID_ANIM_ORDER);

  float fTime;
  // export normal order
  if(!bExportAnimBackward) {
    // for each frame in current preview selection
    for (int iFrame=_ifi->previewStart; iFrame<=_ifi->previewEnd; iFrame+=_ifi->previewStep) {
      // go to that frame
      if (!ExecCmd("GoToFrame %d", iFrame)) {
//        goto end;
      }
  
      assert(_iFrame>=0 && _iFrame<_ctFrames);

      // NOTE: walking all frames implicitly lets the internal itemmotion handler record all bone positions
      // we walk the morph maps manually

      _iFrame++;
    }
    // get time
    fTime = (float) GetCurrentTime();
  // export backward
  } else {
    // remember time in last frame
    if (!ExecCmd("GoToFrame %d", _ifi->previewEnd)) {
      //goto end;
      return AFUNC_BADGLOBAL;
    }
    // get time
    fTime = (float) GetCurrentTime();
    // for each frame in current preview selection going from last to first
    for (int iFrame=_ifi->previewEnd; iFrame>=_ifi->previewStart; iFrame-=_ifi->previewStep) {
      // go to that frame
      if (!ExecCmd("GoToFrame %d", iFrame)) {
        //goto end;
        return AFUNC_BADGLOBAL;
      }
  
      assert(_iFrame>=0 && _iFrame<_ctFrames);

      LWTimeInfo *_tmi = (LWTimeInfo *)_global( LWTIMEINFO_GLOBAL, GFUSE_TRANSIENT );

      // NOTE: walking all frames implicitly lets the internal itemmotion handler record all bone positions
      // we walk the morph maps manually

      _iFrame++;
    }
  }


  // find the number of morph envelopes

  for(MorphInfo *ptmpmi=_pmiFirst;ptmpmi!=NULL; ptmpmi = ptmpmi->mi_pmiNext)
    ctMorphEnvelopes++;



   fTime = (float) GetCurrentTime();
	char strAnimID[256];
	strcpy(strAnimID,_strFileName);	
	GetAnimID(strAnimID);
	
  fprintf(_f, "SE_ANIM %s;\n\n",SE_ANIM_VER);
  fprintf(_f, "SEC_PER_FRAME %g;\n",fTime / _ifi->previewEnd * _ifi->previewStep);
  fprintf(_f, "FRAMES %d;\n", _ctFrames);
  fprintf(_f, "ANIM_ID \"%s\";\n\n", strAnimID);


	fprintf(_f, "BONEENVELOPES %d\n{\n", _ctNumBones);





  BoneInfo *pbiLast = NULL;
  for (BoneInfo *pbi=_pbiFirst; pbi!=NULL; pbi = pbi->bi_pbiNext)
  {
    bool bRootBone = false;
    
    // write its info
    fprintf(_f, "  NAME \"%s\"\n", pbi->bi_strName);
    // write first frame - default pose
    fprintf(_f, "  DEFAULT_POSE {");
    BoneFrame &bfDef = pbi->bi_abfFrames[0];
    MakeRotationAndPosMatrix(bi_mRot,bfDef.fi_vPos,bfDef.fi_vRot);
    PrintMatrix(_f,bi_mRot,0);

    fprintf(_f, "}\n");
    fprintf(_f, "  {\n");

    LWItemType itLast;
    if(!pbiLast) itLast = LWI_OBJECT;
    else itLast = pbiLast->bi_lwItemType;


    // write anim
    // for each frame
    for (int iFrame=0; iFrame<_ctFrames; iFrame++)
    {
      // Fill 3x4 matrix and store rotation and position in it
      BoneFrame &bf = pbi->bi_abfFrames[iFrame];
      MakeRotationAndPosMatrix(bi_mRot,bf.fi_vPos,bf.fi_vRot);

      // write matrix to file
      PrintMatrix(_f,bi_mRot,4);
      fprintf(_f,"\n");
      
    }
    pbiLast = pbi;
    fprintf(_f,"  }\n\n");
  }

  fprintf(_f,"}\n");
	
  fprintf(_f, "\nMORPHENVELOPES %d\n{\n", ctMorphEnvelopes);

  // for each morph in list
  {for (MorphInfo *pmi=_pmiFirst; pmi!=NULL; pmi = pmi->mi_pmiNext)
  {
    // write its info
    fprintf(_f, "  NAME \"%s\"\n", pmi->mi_strName);
    fprintf(_f, "  {\n");
    for (int iFrame=0; iFrame<_ctFrames; iFrame++)
    {
      fprintf(_f, "    %g;\n", pmi->mi_afFrames[iFrame]);
    }
    fprintf(_f,"  }\n\n");
  }
  }

  fprintf(_f,"}\n");

  // free all morph infos
  { MorphInfo *pmi=_pmiFirst;
    MorphInfo *pmiNext=NULL;
    for(;;) {
      if(pmi==NULL) {
        break;
      }
      pmiNext = pmi->mi_pmiNext;

      free(pmi->mi_strName);
      free(pmi->mi_afFrames);
      free(pmi);

      pmi = pmiNext;
  }}



  fprintf(_f, "SE_ANIM_END;\n");
	fclose(_f);

	RemoveMotionHandler(idMasterObjID);
  _pbiFirst = NULL;

	return AFUNC_OK;

};