mirror of
https://github.com/ptitSeb/Serious-Engine
synced 2024-11-22 18:30:27 +01:00
693 lines
17 KiB
C++
693 lines
17 KiB
C++
/* Copyright (c) 2002-2012 Croteam Ltd. All rights reserved. */
|
|
|
|
#include "base.h"
|
|
|
|
extern LWMessageFuncs *_msg = NULL;
|
|
extern LWItemInfo *_iti = NULL;
|
|
extern LWObjectFuncs *_obf = NULL;
|
|
extern LWObjectInfo *_obi = NULL;
|
|
extern LWSceneInfo *_sci = NULL;
|
|
extern LWInterfaceInfo *_ifi = NULL;
|
|
extern LWItemID _objid = NULL;
|
|
extern LWMeshInfo *_pmesh = NULL;
|
|
extern LWChannelInfo *_chi = NULL;
|
|
extern LWSurfaceFuncs *_srf = NULL;
|
|
extern LWBoneInfo *_pbi = NULL;
|
|
extern GlobalFunc *_global = NULL;
|
|
extern const LWMasterAccess *_local = NULL;
|
|
extern void *_serverData = NULL;
|
|
extern int (*_evaluate) (void *, const char *command) = NULL;
|
|
extern LWXPanelFuncs *_xpanf = NULL;
|
|
extern LWColorActivateFunc *_colorpick = NULL;
|
|
extern LWInstUpdate *_lwupdate = NULL;
|
|
extern EDStateRef _state;
|
|
|
|
// modeler globals
|
|
extern MeshEditOp *_meshEditOperations = NULL;
|
|
extern LWObjectFuncs *_objfunc = NULL;
|
|
extern LWStateQueryFuncs *_statequery = NULL;
|
|
|
|
LWPanelID _ModelerPanel = 0;
|
|
|
|
MCData *_pmcMaster = NULL; // the master settings for the scene
|
|
|
|
typedef int CommandFunc(const char *);
|
|
|
|
LWMessageFuncs *message;
|
|
|
|
const char *describe(LWInstance);
|
|
LWInstance create(void *,void *,LWError *);
|
|
void destroy(LWInstance);
|
|
LWError copy(LWInstance,LWInstance);
|
|
LWError load(LWInstance,const LWLoadState *);
|
|
LWError save(LWInstance,const LWSaveState *);
|
|
double process(LWInstance,const LWMasterAccess *);
|
|
unsigned int flags(LWInstance);
|
|
bool bExportAbsPositions = true; // export first bone absolute position
|
|
int _bExportAnimBackward = 0; // export animations from last to first
|
|
|
|
int ReloadGlobalObjects()
|
|
{
|
|
// realise _msg
|
|
_global(LWMESSAGEFUNCS_GLOBAL, GFUSE_RELEASE);
|
|
// acquire _msg again(restart)
|
|
_msg = (LWMessageFuncs *)_global(LWMESSAGEFUNCS_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_msg==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
// realise _iti
|
|
_global(LWITEMINFO_GLOBAL, GFUSE_RELEASE);
|
|
// acquire _iti again(restart)
|
|
_iti = (LWItemInfo *)_global(LWITEMINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_iti==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
// realise _obi
|
|
_global(LWOBJECTINFO_GLOBAL, GFUSE_RELEASE);
|
|
// acquire _obi again(restart)
|
|
_obi = (LWObjectInfo *)_global(LWOBJECTINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_obi==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
// realise _sci
|
|
_global(LWSCENEINFO_GLOBAL, GFUSE_RELEASE);
|
|
// acquire _sci again(restart)
|
|
_sci = (LWSceneInfo *)_global(LWSCENEINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_sci==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
// realise _ifi
|
|
_global(LWINTERFACEINFO_GLOBAL, GFUSE_RELEASE);
|
|
// acquire _ifi again(restart)
|
|
_ifi = (LWInterfaceInfo *)_global(LWINTERFACEINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_ifi==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
// realise _obf
|
|
_global(LWOBJECTFUNCS_GLOBAL, GFUSE_RELEASE);
|
|
// acquire _obf again(restart)
|
|
_obf = (LWObjectFuncs *)_global(LWOBJECTFUNCS_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_obf==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
// realise _chi
|
|
_global(LWCHANNELINFO_GLOBAL, GFUSE_RELEASE);
|
|
// acquire _chi again(restart)
|
|
_chi = (LWChannelInfo *)_global(LWCHANNELINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_chi==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
// realise _srf
|
|
_global(LWSURFACEFUNCS_GLOBAL, GFUSE_RELEASE);
|
|
// acquire _srf again(restart)
|
|
_srf = (LWSurfaceFuncs *)_global(LWSURFACEFUNCS_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_srf==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
// realise _pbi
|
|
_global(LWBONEINFO_GLOBAL, GFUSE_RELEASE);
|
|
// acquire _pbi again(restart)
|
|
_pbi = (LWBoneInfo *)_global(LWBONEINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_pbi==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
return(AFUNC_OK);
|
|
}
|
|
|
|
int Activate_Master(long version, GlobalFunc *global, LWMasterHandler *local, void *serverData)
|
|
{
|
|
_global = global ;
|
|
_serverData = serverData;
|
|
|
|
_msg = (LWMessageFuncs *)_global(LWMESSAGEFUNCS_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_msg==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
_iti = (LWItemInfo *)_global(LWITEMINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_iti==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
_obi = (LWObjectInfo *)_global(LWOBJECTINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_obi==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
_sci = (LWSceneInfo *)_global(LWSCENEINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_sci==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
_ifi = (LWInterfaceInfo *)_global(LWINTERFACEINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_ifi==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
_obf = (LWObjectFuncs *)_global(LWOBJECTFUNCS_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_obf==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
_chi = (LWChannelInfo *)_global(LWCHANNELINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_chi==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
_srf = (LWSurfaceFuncs *)_global(LWSURFACEFUNCS_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_srf==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
_pbi = (LWBoneInfo *)_global(LWBONEINFO_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_pbi==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
if(version != LWMASTER_VERSION)
|
|
return(AFUNC_BADVERSION);
|
|
|
|
if(local->inst)
|
|
{
|
|
local->inst->create = create;
|
|
local->inst->destroy = destroy;
|
|
local->inst->load = load;
|
|
local->inst->save = save;
|
|
local->inst->copy = copy;
|
|
local->inst->descln = describe;
|
|
}
|
|
|
|
if(local->item)
|
|
{
|
|
local->item->useItems = NULL;
|
|
local->item->changeID = NULL;
|
|
}
|
|
|
|
local->event = process;
|
|
local->flags = flags;
|
|
|
|
return(AFUNC_OK);
|
|
}
|
|
|
|
XCALL_(unsigned int) flags(LWInstance inst)
|
|
{
|
|
return(0);
|
|
}
|
|
|
|
XCALL_(const char *) describe(LWInstance inst)
|
|
{
|
|
return("SE Exporter master");
|
|
}
|
|
|
|
XCALL_(LWInstance) create(void *priv,void *context,LWError *err)
|
|
{
|
|
if (_pmcMaster!=NULL) {
|
|
*err = "Only one SE master plugin per scene is allowed.";
|
|
return NULL;
|
|
}
|
|
|
|
_pmcMaster = (MCData *)malloc(sizeof(MCData));
|
|
memset(_pmcMaster,0,sizeof(MCData));
|
|
return _pmcMaster;
|
|
}
|
|
|
|
XCALL_(void) destroy(LWInstance inst)
|
|
{
|
|
|
|
assert(_pmcMaster == (MCData *)inst);
|
|
|
|
free(inst);
|
|
_pmcMaster = NULL;
|
|
}
|
|
|
|
XCALL_(LWError) copy(LWInstance d1,LWInstance d2)
|
|
{
|
|
XCALL_INIT;
|
|
return(NULL);
|
|
}
|
|
|
|
XCALL_(LWError) load(LWInstance inst,const LWLoadState *state)
|
|
{
|
|
LWLOAD_I4( state, (long*)&_pmcMaster->mc_iFaceForward, 1);
|
|
// LWLOAD_I4( state, (long*)&_pmcMaster->mc_iAnimOrder, 1);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
XCALL_(LWError) save(LWInstance inst,const LWSaveState *state)
|
|
{
|
|
LWSAVE_I4( state, (long*)&_pmcMaster->mc_iFaceForward, 1);
|
|
// LWSAVE_I4( state, (long*)&_pmcMaster->mc_iAnimOrder, 1);
|
|
return NULL;
|
|
}
|
|
|
|
XCALL_(double) process(LWInstance inst,const LWMasterAccess *ma)
|
|
{
|
|
_local = ma;
|
|
_evaluate = _local->evaluate;
|
|
return((double)0.0);
|
|
}
|
|
|
|
/*
|
|
======================================================================
|
|
ui_get()
|
|
|
|
Xpanels callback for LWXP_VIEW panels. Returns a pointer to the data
|
|
for a given control value.
|
|
====================================================================== */
|
|
|
|
void *ui_get( MCData *inst, unsigned long vid )
|
|
{
|
|
switch ( vid ) {
|
|
case ID_FACEFORWARD: return &inst->mc_iFaceForward;
|
|
case ID_ANIM_ORDER: return &inst->mc_iAnimOrder;
|
|
default: return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
======================================================================
|
|
ui_set()
|
|
|
|
Xpanels callback for LWXP_VIEW panels. Store a value in our instance
|
|
data.
|
|
====================================================================== */
|
|
|
|
int ui_set( MCData *inst, unsigned long vid, void *value )
|
|
{
|
|
double *d = ( double * ) value;
|
|
|
|
switch ( vid ) {
|
|
case ID_FACEFORWARD:
|
|
inst->mc_iFaceForward = *(int*)value;
|
|
break;
|
|
case ID_ANIM_ORDER:
|
|
inst->mc_iAnimOrder = *(int*)value;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
char *astrFaceForward[] = {
|
|
"not",
|
|
"half-faceforward",
|
|
"full-faceforward",
|
|
NULL
|
|
};
|
|
|
|
char *astrAnimOrder[] = {
|
|
"Normal",
|
|
"Reversed",
|
|
NULL
|
|
};
|
|
|
|
void Click_ExportAnim(LWXPanelID pan, int cid)
|
|
{
|
|
ExportAnim(pan);
|
|
}
|
|
void Click_ExportSkeleton(LWXPanelID pan, int cid)
|
|
{
|
|
ExportSkeleton();
|
|
//_msg->error("Not implemented yet.", NULL);
|
|
}
|
|
void Click_ExportMesh(LWXPanelID pan, int cid)
|
|
{
|
|
ExportMesh(pan);
|
|
}
|
|
void Click_ExportBones(LWXPanelID pan, int cid)
|
|
{
|
|
ExportBones();
|
|
}
|
|
|
|
void Click_ExportSecAnim(LWXPanelID pan, int cid)
|
|
{
|
|
ExportSecAnim(pan);
|
|
}
|
|
|
|
|
|
LWXPanelID get_panel(LWInstance inst)
|
|
{
|
|
static LWXPanelControl xctl[] = {
|
|
{ ID_FACEFORWARD, "FaceForward", "iPopChoice", },
|
|
{ ID_ANIM_ORDER, "Animation order", "iPopChoice", },
|
|
{ ID_EXPORTMESH, "Export Mesh", "vButton", },
|
|
{ ID_EXPORTSKELETON, "Export Skeleton", "vButton", },
|
|
{ ID_EXPORTANIM, "Export Animation", "vButton", },
|
|
{ ID_EXPORTBONES, "Export Bones", "vButton", },
|
|
{ ID_EXPORTSECANIM, "Export Sections Anim", "vButton", },
|
|
{ ID_ABSPOSITIONS, "Absolute positions", "iBoolean", },
|
|
{ 0 }
|
|
};
|
|
static LWXPanelDataDesc xdata[] = {
|
|
{ ID_FACEFORWARD, "FaceForward", "integer", },
|
|
{ ID_ANIM_ORDER, "Animation order", "integer", },
|
|
{ 0 }
|
|
};
|
|
static LWXPanelHint xhint[] = {
|
|
XpLABEL( 0, "SE Exporter master controls" ),
|
|
XpSTRLIST(ID_FACEFORWARD, astrFaceForward),
|
|
XpSTRLIST(ID_ANIM_ORDER , astrAnimOrder),
|
|
XpBUTNOTIFY( ID_EXPORTMESH, Click_ExportMesh ),
|
|
XpBUTNOTIFY( ID_EXPORTSKELETON, Click_ExportSkeleton),
|
|
XpBUTNOTIFY( ID_EXPORTANIM, Click_ExportAnim),
|
|
XpBUTNOTIFY( ID_EXPORTBONES, Click_ExportBones),
|
|
XpBUTNOTIFY( ID_EXPORTSECANIM, Click_ExportSecAnim),
|
|
//XpCHGNOTIFY( /*ID_ABSPOSITIONS, */Click_AbsPositions),
|
|
//XpCHGNOTIFY( /*ID_ANIM_BACKWARD , */Click_AnimBackward),
|
|
//XpBUTNOTIFY( ID_COLOR, handle_color),
|
|
//XpCHGNOTIFY( ui_chgnotify),
|
|
XpEND
|
|
};
|
|
|
|
LWXPanelID panel;
|
|
|
|
if ( panel = _xpanf->create( LWXP_VIEW, xctl )) {
|
|
_xpanf->hint( panel, 0, xhint );
|
|
_xpanf->describe( panel, xdata,
|
|
(void *(__cdecl *)(void *,unsigned long))ui_get,
|
|
(enum en_LWXPRefreshCodes (__cdecl *)(void *,unsigned long,void *))ui_set );
|
|
_xpanf->viewInst( panel, inst );
|
|
_xpanf->setData( panel, 0, inst );
|
|
}
|
|
|
|
return panel;
|
|
}
|
|
|
|
XCALL_(int) Interface_Master(long version, GlobalFunc *global, LWInterface *local, void *serverData)
|
|
{
|
|
_global = global ;
|
|
_serverData = serverData;
|
|
|
|
|
|
if ( version != LWINTERFACE_VERSION ) return AFUNC_BADVERSION;
|
|
|
|
(void*&)_colorpick = global( LWCOLORACTIVATEFUNC_GLOBAL, GFUSE_TRANSIENT );
|
|
(void*&)_lwupdate = global( LWINSTUPDATE_GLOBAL, GFUSE_TRANSIENT );
|
|
(void*&)_xpanf = global( LWXPANELFUNCS_GLOBAL, GFUSE_TRANSIENT );
|
|
if ( !_colorpick || !_lwupdate || !_xpanf ) return AFUNC_BADGLOBAL;
|
|
|
|
local->panel = get_panel(local->inst);
|
|
local->options = NULL;
|
|
local->command = NULL;
|
|
|
|
if (local->panel==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
// for(SurfaceInstance *psi = _psiFirst; psi!=NULL; psi = psi->si_psiNext) {
|
|
// (*message->info)("surface: ", _srf->name(psi->si_idSurface));
|
|
// }
|
|
return(AFUNC_OK);
|
|
}
|
|
|
|
|
|
|
|
|
|
/*======================================================================
|
|
Modeler Exporter
|
|
|
|
The next part of the CPP is for the modeler exporter plugin
|
|
====================================================================== */
|
|
|
|
|
|
|
|
|
|
int msgbox_modeler( LWXPanelFuncs *xpanf, const char* msg )
|
|
{
|
|
|
|
LWXPanelID panel;
|
|
int ok = 0;
|
|
|
|
enum { ID_MSG = 0x8001 };
|
|
LWXPanelControl ctl[] = {
|
|
{ ID_MSG, "Message: ", "string", },
|
|
{ 0 }
|
|
};
|
|
LWXPanelDataDesc cdata[] = {
|
|
{ ID_MSG, "Message: ", "string", },
|
|
{ 0 }
|
|
};
|
|
LWXPanelHint hint[] = {
|
|
XpLABEL( 0, "SE Mesh Exporter master controls" ),
|
|
XpLABEL(ID_MSG, msg),
|
|
XpEND
|
|
};
|
|
|
|
|
|
panel = xpanf->create( LWXP_FORM, ctl );
|
|
if ( !panel ) return 0;
|
|
|
|
xpanf->describe( panel, cdata, NULL, NULL );
|
|
xpanf->hint( panel, 0, hint );
|
|
xpanf->formSet( panel, ID_MSG, (void*) msg );
|
|
|
|
|
|
ok = xpanf->post( panel );
|
|
|
|
xpanf->destroy( panel );
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_user_modeler( LWXPanelFuncs *xpanf )
|
|
{
|
|
|
|
LWXPanelID panel;
|
|
int ok = 0;
|
|
|
|
enum { ID_FACEFORWARD = 0x8001, ID_ANIM_ORDER};
|
|
LWXPanelControl ctl[] = {
|
|
{ ID_FACEFORWARD, "FaceForward", "iPopChoice", },
|
|
{ 0 }
|
|
};
|
|
LWXPanelDataDesc cdata[] = {
|
|
{ ID_FACEFORWARD, "FaceForward", "integer", },
|
|
{ 0 }
|
|
};
|
|
LWXPanelHint hint[] = {
|
|
XpLABEL( 0, "SE Mesh Exporter master controls" ),
|
|
XpSTRLIST(ID_FACEFORWARD, astrFaceForward),
|
|
XpEND
|
|
};
|
|
|
|
|
|
panel = xpanf->create( LWXP_FORM, ctl );
|
|
if ( !panel ) return 0;
|
|
|
|
xpanf->describe( panel, cdata, NULL, NULL );
|
|
xpanf->hint( panel, 0, hint );
|
|
xpanf->formSet( panel, ID_FACEFORWARD, 0 );
|
|
|
|
|
|
ok = xpanf->post( panel );
|
|
|
|
int iFaceForward = *(int*)_xpanf->formGet( panel, ID_FACEFORWARD);
|
|
if ( ok ) {
|
|
ExportMesh_modeler(iFaceForward);
|
|
}
|
|
|
|
xpanf->destroy( panel );
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
XCALL_ ( int ) Activate_ModelerMeshExporter( long version, GlobalFunc *global, MeshEditBegin *local, void *serverData ) {
|
|
|
|
_global = global ;
|
|
_serverData = serverData;
|
|
|
|
if ( version != LWINTERFACE_VERSION ) return AFUNC_BADVERSION;
|
|
|
|
|
|
_meshEditOperations = local(1,1,OPSEL_GLOBAL);
|
|
|
|
_xpanf = (LWXPanelFuncs *) _global( LWXPANELFUNCS_GLOBAL, GFUSE_TRANSIENT );
|
|
if (_xpanf==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
_msg = (LWMessageFuncs *) _global(LWMESSAGEFUNCS_GLOBAL, GFUSE_ACQUIRE );
|
|
if (_msg==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
|
|
_objfunc = (LWObjectFuncs *) _global( LWOBJECTFUNCS_GLOBAL, GFUSE_TRANSIENT );
|
|
if (_objfunc==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
_statequery = (LWStateQueryFuncs *) _global( LWSTATEQUERYFUNCS_GLOBAL, GFUSE_TRANSIENT );
|
|
if (_statequery==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
|
|
_srf = (LWSurfaceFuncs *) _global(LWSURFACEFUNCS_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_srf==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
get_user_modeler(_xpanf);
|
|
global( LWXPANELFUNCS_GLOBAL, GFUSE_RELEASE );
|
|
global( LWMESSAGEFUNCS_GLOBAL, GFUSE_RELEASE );
|
|
global( LWSURFACEFUNCS_GLOBAL, GFUSE_RELEASE );
|
|
|
|
_meshEditOperations->done( _meshEditOperations->state, EDERR_NONE, 0 );
|
|
|
|
return(AFUNC_OK);
|
|
};
|
|
|
|
|
|
|
|
|
|
/*===================================================================================
|
|
Surface to weights
|
|
|
|
The next part of the CPP is for the surface->weights modeler converter plugin
|
|
================================================================================== */
|
|
|
|
|
|
|
|
|
|
|
|
EDError AddToWeightmap (void *strSurf, const EDPolygonInfo *ppliPolyInfo)
|
|
{
|
|
static float fWeightOne[] = {1.0f};
|
|
|
|
if (strcmp(ppliPolyInfo->surface, (char*)strSurf)==0) {
|
|
for (int i=0;i<ppliPolyInfo->numPnts;i++) {
|
|
_meshEditOperations->pntVMap(_state,ppliPolyInfo->points[i],LWVMAP_WGHT,(char*)strSurf,1,fWeightOne);
|
|
}
|
|
}
|
|
return EDERR_NONE;
|
|
};
|
|
|
|
|
|
XCALL_(int) Activate_ModelerSurfaceToWeights( long version, GlobalFunc *global, MeshEditBegin *local, void *serverData )
|
|
{
|
|
LWSurfaceID *asurSurfaces;
|
|
int ctSurfs;
|
|
char *strFileName;
|
|
|
|
_global = global;
|
|
_serverData = serverData;
|
|
|
|
if ( version != LWINTERFACE_VERSION ) return AFUNC_BADVERSION;
|
|
|
|
|
|
_meshEditOperations = local(1,1,OPSEL_GLOBAL);
|
|
_state = _meshEditOperations->state;
|
|
|
|
_srf = (LWSurfaceFuncs *) _global(LWSURFACEFUNCS_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_srf==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
_statequery = (LWStateQueryFuncs *) _global( LWSTATEQUERYFUNCS_GLOBAL, GFUSE_TRANSIENT );
|
|
if (_statequery==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
strFileName = strdup(_statequery->object());
|
|
|
|
// get surfaces
|
|
asurSurfaces = _srf->byObject(strFileName);
|
|
|
|
// count the surfaces
|
|
ctSurfs = 0;
|
|
while(asurSurfaces[ctSurfs]!=NULL) {
|
|
ctSurfs++;
|
|
}
|
|
|
|
{for(int iSurf=0; iSurf<ctSurfs; iSurf++) {
|
|
|
|
const char *strSurf = _srf->name(asurSurfaces[iSurf]);
|
|
// for each polygon in the surface, add weight map values for all it's points
|
|
// this does the job a few times for each point, but it's the simplest way to do it
|
|
_meshEditOperations->polyScan(_state,AddToWeightmap,(void*)strSurf,OPLYR_FG);
|
|
}}
|
|
|
|
|
|
_meshEditOperations->done( _meshEditOperations->state, EDERR_NONE, 0 );
|
|
|
|
return(AFUNC_OK);
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*===================================================================================
|
|
Copy weight maps
|
|
|
|
The next part of the CPP is for the CopyWeightMaps plugin that copies weight maps
|
|
from the vertices in the background layers to the corresponding vertices in the
|
|
foreground layers. Vertices are matched by position.
|
|
================================================================================== */
|
|
|
|
|
|
XCALL_(int) Activate_CopyWeightMaps( long version, GlobalFunc *global, MeshEditBegin *local, void *serverData )
|
|
{
|
|
char *strFileName;
|
|
|
|
_global = global;
|
|
_serverData = serverData;
|
|
|
|
if ( version != LWINTERFACE_VERSION ) return AFUNC_BADVERSION;
|
|
|
|
|
|
_meshEditOperations = local(1,1,OPSEL_GLOBAL);
|
|
_state = _meshEditOperations->state;
|
|
|
|
_srf = (LWSurfaceFuncs *) _global(LWSURFACEFUNCS_GLOBAL, GFUSE_ACQUIRE);
|
|
if (_srf==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
_statequery = (LWStateQueryFuncs *) _global( LWSTATEQUERYFUNCS_GLOBAL, GFUSE_TRANSIENT );
|
|
if (_statequery==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
_objfunc = (LWObjectFuncs *) _global( LWOBJECTFUNCS_GLOBAL, GFUSE_TRANSIENT );
|
|
if (_objfunc==NULL) {
|
|
return AFUNC_BADGLOBAL;
|
|
}
|
|
|
|
strFileName = strdup(_statequery->object());
|
|
|
|
|
|
|
|
ListWeightMaps();
|
|
ScanBackground();
|
|
|
|
// for each point in the foreground layers, look for it's match in the
|
|
// background layer and copy the weight map value
|
|
_meshEditOperations->pointScan(_state,CopyWeightMaps,NULL,OPLYR_FG);
|
|
|
|
|
|
_meshEditOperations->done( _meshEditOperations->state, EDERR_NONE, 0 );
|
|
|
|
|
|
FreeMem();
|
|
|
|
return(AFUNC_OK);
|
|
|
|
};
|