/*------------------------------------------------------------------------
|
| GetSpotlightCount3ds
|
+--------------------------------------------------------------------*/
ulong3ds GetSpotlightCount3ds(database3ds *db)
{
chunk3ds *dlite, *spotl;
ulong3ds spotcount = 0, i;
if (db == NULL)
SET_ERROR_RETURNR(ERR_INVALID_ARG, 0);
/* Update the index to named objects if the list has changed recently */
UpdateNamedObjectList3ds(db);
if (db->objlist == NULL) return 0;
/* Scan through the list of named objects looking for lights */
for (i = 0; i < db->objlist->count; i++)
{
/* Search each object for a light chunk */
FindChunk3ds(db->objlist->list[i].chunk, N_DIRECT_LIGHT, &dlite);
/* if one was found, check to see if its a spotlight */
if (dlite != NULL)
{
FindChunk3ds(dlite, DL_SPOTLIGHT, &spotl);
/* if it is a spotlight, then increment the count */
if (spotl != NULL)
spotcount++;
}
}
return spotcount;
}
/*--------------------------------------------------------------------------
|
| GetSpotlightByName3ds
|
| Fills out the **spot structure contained in *db that matches the
| name in *name.
|
+--------------------------------------------------------------------------*/
void GetSpotlightByName3ds(database3ds *db,
char3ds *name,
light3ds **spotlight)
{
chunk3ds *nobj, *lite, *spot;
if (db == NULL || spotlight == NULL) SET_ERROR_RETURN(ERR_INVALID_ARG);
if (db->topchunk == NULL) SET_ERROR_RETURN(ERR_INVALID_DATABASE);
if (!(db->topchunk->tag == M3DMAGIC || db->topchunk->tag == CMAGIC))
SET_ERROR_RETURN(ERR_WRONG_DATABASE);
/* Find the matching name */
FindNamedObject3ds(db, name, &nobj);
/* If a match was found */
if (nobj != NULL)
{
/* Verify that its a light */
FindChunk3ds(nobj, N_DIRECT_LIGHT, &lite);
/* if its a light then check to see if its a spot */
FindChunk3ds(lite, DL_SPOTLIGHT, &spot);
/* if it is a spot, then retreave the structure */
if (spot != NULL)
{
GetLightEntryChunk3ds(nobj, spotlight);
}
}
}
/* Sets the KFDATA release level */
void PutKfRelease3ds(database3ds *db, releaselevel3ds release)
{
KFHdr *d;
if (db == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
if (db->topchunk == NULL)
SET_ERROR_RETURN(ERR_INVALID_DATABASE);
if ((db->topchunk->tag == M3DMAGIC) || (db->topchunk->tag == CMAGIC))
{
chunk3ds *kfdata;
chunk3ds *kfhdr;
/* Find the KFDATA section */
FindChunk3ds(db->topchunk, KFDATA, &kfdata);
/* If one doesn't exist, then create it */
if (kfdata == NULL)
{
InitChunkAs3ds(&kfdata, KFDATA);
AddChildOrdered3ds(db->topchunk, kfdata);
}
/* Find the KFHDR */
FindChunk3ds(kfdata, KFHDR, &kfhdr);
/* If a KFHDR doesn't exist, then create it */
if (kfhdr == NULL)
{
d = InitChunkAndData3ds(&kfhdr, KFHDR);
d->filename = strdup("");
d->animlength = 30; /* Just a default */
AddChildOrdered3ds(kfdata, kfhdr);
} else /* Else, just get its data */
{
d = ReadChunkData3ds(kfhdr);
}
/* Set the revision level */
switch(release)
{
case Release13ds:
d->revision = 1;
break;
case Release23ds:
d->revision = 2;
break;
case Release33ds:
d->revision = 5;
break;
case ReleaseNotKnown3ds:
d->revision = 6;
break;
}
}
}
void CopyBackground3ds(database3ds *destdb, database3ds *srcdb)
{
chunk3ds *srcmdata, *destmdata, *srcchunk, *destchunk;
if ((destdb == NULL) || (srcdb == NULL))
SET_ERROR_RETURN(ERR_INVALID_ARG);
if ((srcdb->topchunk == NULL) || (destdb->topchunk == NULL))
SET_ERROR_RETURN(ERR_INVALID_DATABASE);
if ((srcdb->topchunk->tag != M3DMAGIC) && (srcdb->topchunk->tag != CMAGIC))
SET_ERROR_RETURN(ERR_WRONG_DATABASE);
if ((destdb->topchunk->tag != M3DMAGIC) && (destdb->topchunk->tag != CMAGIC))
SET_ERROR_RETURN(ERR_WRONG_DATABASE);
/* Find source mesh section */
FindChunk3ds(srcdb->topchunk, MDATA, &srcmdata);
/* If found */
if (srcmdata != NULL)
{
/* Find or create destination mesh section */
FindChunk3ds(destdb->topchunk, MDATA, &destmdata);
if (destmdata == NULL)
{
InitChunkAs3ds(&destmdata, MDATA);
AddChildOrdered3ds(destdb->topchunk, destmdata);
}
/* Scan the source mdata section looking for background setting chunks */
for (srcchunk = srcmdata->children; srcchunk != NULL; srcchunk = srcchunk->sibling)
{
switch(srcchunk->tag)
{
case V_GRADIENT:
case SOLID_BGND:
case BIT_MAP:
case USE_SOLID_BGND:
case USE_V_GRADIENT:
case USE_BIT_MAP:
/* if the same chunk exists in the destination, then delete it */
FindNextChunk3ds(destmdata->children, srcchunk->tag, &destchunk);
if (destchunk != NULL)
DeleteChunk3ds(destchunk);
/* Copy and add the chunk */
CopyChunk3ds(srcchunk, &destchunk);
AddChildOrdered3ds(destmdata, destchunk);
break;
default:
break;
}
}
}
}
/* Scans the database for MESH_VERSION chunk and returnes its release */
releaselevel3ds GetMeshRelease3ds(database3ds *db)
{
chunk3ds *c = NULL;
if (db == NULL)
ADD_ERROR_RETURNR(ERR_INVALID_ARG, ReleaseNotKnown3ds);
if (db->topchunk == NULL)
ADD_ERROR_RETURNR(ERR_INVALID_DATABASE, ReleaseNotKnown3ds);
/* If the database is a 3DS file */
if ((db->topchunk->tag == M3DMAGIC || db->topchunk->tag == CMAGIC))
{
FindChunk3ds(db->topchunk, MESH_VERSION, &c);
if (c != NULL)
{
MeshVersion *d;
d = ReadChunkData3ds(c);
if (d->version == 1) return Release13ds;
else
if (d->version == 2) return Release23ds;
else
if (d->version == 3) return Release33ds;
else
return ReleaseNotKnown3ds;
}
else
return ReleaseNotKnown3ds;
}
else
return ReleaseNotKnown3ds;
}
/*----------------------------------------------------------------------
|
| GetAmbientLightMotion3ds
|
| db: database to be searched
| kfambient: Ptr to the addr of kfambient3ds structure, if (*kfambient)
| is null, then memory will be allocated for the new
| structure, otherwise, the existing structure will be
| filled in with the new values. If no match is found, then
| kfambient remains unchanged.
|
| Ambient light a special case: only one ambient node per keyframe data
| chunk.
|
+----------------------------------------------------------------------*/
void GetAmbientLightMotion3ds(database3ds *db,
kfambient3ds **kfambient)
{
chunk3ds *pKfChunk, *pChunk = NULL;
if(db == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
/*--- Find Keyframe chunk */
FindChunk3ds(db->topchunk, KFDATA, &pKfChunk);
if (pKfChunk){
FindChunk3ds(pKfChunk, AMBIENT_NODE_TAG, &pChunk);
if (pChunk)
GetAmbientLightMotionChunk3ds(pChunk, kfambient);
}
}
/* Fills out the **mesh structure contained in *db with the name listed in *name */
void GetMeshByName3ds(database3ds *db, /* Chunk listing to be searched */
char3ds *name, /* Name of mesh being searched for */
mesh3ds **mesh /* A pointer to the address of the mesh
structure, if (*mesh) is null, then
memory will be allocated for the new
structure, otherwise, the existing
structure will be filled in with the new
values. If no match is found, then **mesh
remains unchanged */
)
{
chunk3ds *nobj = NULL, *ntri = NULL;
if (db == NULL || name == NULL || mesh == NULL) SET_ERROR_RETURN(ERR_INVALID_ARG);
if (db->topchunk == NULL) SET_ERROR_RETURN(ERR_INVALID_DATABASE);
if (!(db->topchunk->tag == M3DMAGIC || db->topchunk->tag == CMAGIC))
SET_ERROR_RETURN(ERR_WRONG_DATABASE);
UpdateNamedObjectList3ds(db);
/* Find the matching mesh name in the chunk list */
FindNamedObject3ds(db, name, &nobj);
/* if a match is found */
if (nobj != NULL)
{
/* See it the named object is a mesh object */
FindChunk3ds(nobj, N_TRI_OBJECT, &ntri);
/* If it is a mesh object, then fill in the mesh structure */
if (ntri != NULL)
GetMeshEntryChunk3ds(nobj, mesh);
}
}
/* Fills out the **mesh structure from the (index)th mesh reference found in *db */
void GetMeshByIndex3ds(database3ds *db, ulong3ds index, mesh3ds **mesh)
{
chunk3ds *ntri;
ulong3ds i, meshcount;
if (db == NULL || mesh == NULL) SET_ERROR_RETURN(ERR_INVALID_ARG);
if (db->topchunk == NULL) SET_ERROR_RETURN(ERR_INVALID_DATABASE);
if (!(db->topchunk->tag == M3DMAGIC || db->topchunk->tag == CMAGIC))
SET_ERROR_RETURN(ERR_WRONG_DATABASE);
/* Update the index to named objects if the list has changed recently */
UpdateNamedObjectList3ds(db);
/* Scan through the list of named objects */
for (i = 0, meshcount = 0; i < db->objlist->count; i++)
{
/* Search each named object for a mesh chunk */
FindChunk3ds(db->objlist->list[i].chunk, N_TRI_OBJECT, &ntri);
/* If a mesh chunk is found */
if (ntri != NULL)
{
/* Increment the running total */
meshcount++;
/* If this is the (index)th mesh, fill out the structure */
if (meshcount-1 == index)
{
GetMeshEntryChunk3ds(db->objlist->list[i].chunk, mesh);
break;
}
}
}
}
/*------------------------------------------------------------------------
|
| GetSpotlightByIndex3ds
| Fills out the **spot structure from the (index)th spot reference
| found in *db.
|
+------------------------------------------------------------------------*/
void GetSpotlightByIndex3ds(database3ds *db,
long3ds index,
light3ds **spotlight)
{
chunk3ds *lite, *spot;
ulong3ds i;
long3ds spotcount;
if (db == NULL || spotlight == NULL) SET_ERROR_RETURN(ERR_INVALID_ARG);
if (db->topchunk == NULL) SET_ERROR_RETURN(ERR_INVALID_DATABASE);
if (!(db->topchunk->tag == M3DMAGIC || db->topchunk->tag == CMAGIC))
SET_ERROR_RETURN(ERR_WRONG_DATABASE);
/* Update the list if it's changed recently */
UpdateNamedObjectList3ds(db);
/* Scan through the list */
for (i = 0, spotcount=0; i < db->objlist->count; i++)
{
/* Search for a light chunk */
FindChunk3ds(db->objlist->list[i].chunk, N_DIRECT_LIGHT, &lite);
/* if one was found, check to see if its a spot */
if (lite != NULL)
{
FindChunk3ds(lite, DL_SPOTLIGHT, &spot);
{
/* if its a spot then increment the count */
if (spot != NULL)
{
spotcount++;
/* If thisis the (index)th light, file out the structure */
if (spotcount-1 == index)
{
GetLightEntryChunk3ds(db->objlist->list[i].chunk,
spotlight);
break;
}
}
}
}
}
}
/*--------------------------------------------------------------------------
|
| GetOmnilightNameList3ds
| Searches *db to construct **list, a list of omnilight names within
| the database
|
| db: The database bing searched.
| list: The resulting namelist pairs, if *list is null, then a namelist
| structure will be allocated.
|
+--------------------------------------------------------------------------*/
void GetOmnilightNameList3ds(database3ds *db,
namelist3ds **list)
{
chunk3ds *lite, *spot;
ulong3ds omnilightcount, i, j;
if (db == NULL || list == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
/* Update the index to named objects if the list has changed recently */
UpdateNamedObjectList3ds(db);
/* Get the number of omnilights contained in the named object list */
omnilightcount = GetOmnilightCount3ds(db);
/* Initilize the namelist array */
InitNameList3ds(list, omnilightcount);
/* Scan through the list of named objects */
for (i = 0, j = 0; (i < db->objlist->count) && (j < omnilightcount); i++)
{
/* Search each named object for a light chunk */
FindChunk3ds(db->objlist->list[i].chunk, N_DIRECT_LIGHT, &lite);
/* if its a light chunk, check to see if its a spotlight */
if (lite != NULL)
{
FindChunk3ds(lite, DL_SPOTLIGHT, &spot);
/* If its not a spot */
if (spot == NULL)
{
/* Copy the name into the list */
(*list)->list[j].name = strdup(db->objlist->list[i].name);
j++; /* increment the omnilight counter */
}
}
}
}
ulong3ds GetMeshMatCount3ds(chunk3ds *current)
{
chunk3ds *datachunk;
ushort3ds meshmatcount=0;
FindChunk3ds(current, MSH_MAT_GROUP, &datachunk);
while(datachunk != NULL)
{
meshmatcount++;
FindNextChunk3ds(datachunk->sibling, MSH_MAT_GROUP, &datachunk);
}
return(meshmatcount);
}
/*--------------------------------------------------------------------------
|
| GetSpotlightNameList3ds
| Searches *db to construct **list, a list of spotlight names within
| the database
|
| db: The database bing searched.
| list: The resulting namelist pairs, if *list is null, then a namelist
| structure will be allocated.
|
+--------------------------------------------------------------------------*/
void GetSpotlightNameList3ds(database3ds *db,
namelist3ds **list)
{
chunk3ds *spot;
ulong3ds spotlightcount, i, j;
if (db == NULL || list == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
/* Update the index to named objects if the list has changed recently */
UpdateNamedObjectList3ds(db);
/* Get the number of spotlights contained in the named object list */
spotlightcount = GetSpotlightCount3ds(db);
/* Initilize the namelist array */
InitNameList3ds(list, spotlightcount);
/* Scan through the list of named objects */
for (i = 0, j = 0; (i < db->objlist->count) && (j < spotlightcount); i++)
{
/* Search each named object for a direct light chunk */
FindChunk3ds(db->objlist->list[i].chunk, N_DIRECT_LIGHT, &spot);
/* Search each direct light for a spotlight chunk */
if (spot != NULL)
FindChunk3ds(spot, DL_SPOTLIGHT, &spot);
/* If it is a spotlight chunk */
if (spot != NULL)
{
/* Copy the name into the list */
(*list)->list[j].name = strdup(db->objlist->list[i].name);
j++;
}
}
}
/* Scans the database for KFHDR chunk and returnes its release level */
releaselevel3ds GetKfRelease3ds(database3ds *db)
{
chunk3ds *c = NULL, *kfdata;
if (db == NULL)
SET_ERROR_RETURNR(ERR_INVALID_ARG, ReleaseNotKnown3ds);
if (db->topchunk == NULL)
SET_ERROR_RETURNR(ERR_INVALID_DATABASE, ReleaseNotKnown3ds);
/* If the database is a 3DS file */
if ((db->topchunk->tag == M3DMAGIC || db->topchunk->tag == CMAGIC))
{
FindChunk3ds(db->topchunk, KFDATA, &kfdata);
if (kfdata != NULL)
FindChunk3ds(db->topchunk, KFHDR, &c);
if (c != NULL)
{
KFHdr *d;
d = ReadChunkData3ds(c);
if (d->revision == 1) return Release13ds;
else
if (d->revision == 2) return Release23ds;
else
if (d->revision == 5) return Release33ds;
else
return ReleaseNotKnown3ds;
}
else
return ReleaseNotKnown3ds;
}
else
return ReleaseNotKnown3ds;
}
/* Sets the MeshRelease level */
void PutMeshRelease3ds(database3ds *db, releaselevel3ds release)
{
if (db == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
if (db->topchunk == NULL)
SET_ERROR_RETURN(ERR_INVALID_DATA);
if ((db->topchunk->tag == M3DMAGIC) || (db->topchunk->tag == CMAGIC))
{
chunk3ds *mdata;
chunk3ds *c;
M3dVersion *d;
FindChunk3ds(db->topchunk, MDATA, &mdata);
if (mdata == NULL)
{
InitChunkAs3ds(&mdata, MDATA);
AddChildOrdered3ds(db->topchunk, mdata);
}
ReplaceOrAddChild3ds(mdata, MESH_VERSION, &c);
d = InitChunkData3ds(c);
switch(release)
{
case Release13ds:
d->version = 1;
break;
case Release23ds:
d->version = 2;
break;
case Release33ds:
d->version = 3;
break;
case ReleaseNotKnown3ds:
d->version = 4;
}
}
}
/* Returns a count of mesh objects referenced in the chunk list */
ulong3ds GetMeshCount3ds(database3ds *db /* The chunk listing that is being searched */
)
{
chunk3ds *ntri; /* The possible pointer for the mesh chunk */
ulong3ds meshcount = 0, i;
/* Update the index to named objects if the list has changed recently */
UpdateNamedObjectList3ds(db);
ON_ERROR_RETURNR(0);
if (db->objlist == NULL) return 0;
/* Scan through the list of named objects */
for (i = 0; i < db->objlist->count; i++)
{
/* Search each named object for a mesh chunk */
FindChunk3ds(db->objlist->list[i].chunk, N_TRI_OBJECT, &ntri);
/* if a mesh chunk was found, increment the count */
if (ntri != NULL) meshcount++;
}
return meshcount;
}
/* Searches *db to construct **list, a list of mesh names associated with
their chunk definition. */
void GetMeshNameList3ds(database3ds *db, /* The chunk database being searched */
namelist3ds **list /* The resulting namelist pairs, if
*list is null, then a namelist
structure will be allocated */
)
{
chunk3ds *current=NULL, *nobj=NULL, *ntri;
ulong3ds meshcount, i, j;
if (db == NULL || list == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
/* Update the index to named objects if the list has changed recently */
UpdateNamedObjectList3ds(db);
/* Get the number of meshes contained in the named object list */
meshcount = GetMeshCount3ds(db);
/* Initilize the namelist array */
InitNameList3ds(list, meshcount);
/* Scan through the list of named objects */
for (i = 0, j = 0; (i < db->objlist->count) && (j < meshcount); i++)
{
/* Search each named object for a mesh chunk */
FindChunk3ds(db->objlist->list[i].chunk, N_TRI_OBJECT, &ntri);
/* If it is a mesh chunk */
if (ntri != NULL)
{
/* Copy the name into the list */
(*list)->list[j].name = strdup(db->objlist->list[i].name);
j++;
}
}
}
/*--------------------------------------------------------------------------
| GetCameraMotion3ds
|
| pCamChunk:CAMERA_NODE_TAG chunk to extract data from
| pTargetChunk: TARGET_NODE_TAG chunk to extract target data from
| kfcam: Structure to fill in with chunk data
|
| chunk----->kfcamera3ds
|
| Gets camera keyframe information from chunk
|
+--------------------------------------------------------------------------*/
void GetCameraMotion3ds(chunk3ds *pCamChunk,
chunk3ds *pTargetChunk,
kfcamera3ds **kfcam)
{
kfcamera3ds
*pKfCam;
chunk3ds
*pNodeHdrChunk, *pPosChunk, *pFovChunk,
*pRollChunk, *pTargetPosChunk = NULL, *pTargetHdrChunk = NULL;
ulong3ds
i, nPosKeys = 0, nFovKeys = 0, nRollKeys = 0, nTargetKeys = 0;
NodeHdr
*pNodeHdr, *pTargetHdr = NULL;
PosTrackTag
*pPosData = NULL, *pTargetData = NULL;
FovTrackTag
*pFovData = NULL;
RollTrackTag
*pRollData = NULL;
if(pCamChunk == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
/*-------------------------------
| Get information from chunks
+-------------------------------*/
/*--- Search children of camera chunk */
FindChunk3ds(pCamChunk, NODE_HDR, &pNodeHdrChunk);
FindChunk3ds(pCamChunk, POS_TRACK_TAG, &pPosChunk);
FindChunk3ds(pCamChunk, FOV_TRACK_TAG, &pFovChunk);
FindChunk3ds(pCamChunk, ROLL_TRACK_TAG, &pRollChunk);
ReadChunkData3ds(pNodeHdrChunk);
pNodeHdr = pNodeHdrChunk->data;
if(pPosChunk){
ReadChunkData3ds(pPosChunk);
pPosData = pPosChunk->data;
nPosKeys = pPosData->trackhdr.keycount;
}
if(pFovChunk){
ReadChunkData3ds(pFovChunk);
pFovData = pFovChunk->data;
nFovKeys = pFovData->trackhdr.keycount;
}
if(pRollChunk){
ReadChunkData3ds(pRollChunk);
pRollData = pRollChunk->data;
nRollKeys = pRollData->trackhdr.keycount;
}
if (pTargetChunk){
FindChunk3ds(pTargetChunk, NODE_HDR, &pTargetHdrChunk);
if (pTargetHdrChunk){
ReadChunkData3ds(pTargetHdrChunk);
pTargetHdr = pTargetHdrChunk->data;
}
FindChunk3ds(pTargetChunk, POS_TRACK_TAG, &pTargetPosChunk);
if (pTargetPosChunk){
ReadChunkData3ds(pTargetPosChunk);
pTargetData = pTargetPosChunk->data;
nTargetKeys = pTargetData->trackhdr.keycount;
}
}
/*--------------------------------------------
| Set-up and fill-in the kfcamera structure
+--------------------------------------------*/
InitCameraMotion3ds(kfcam,
nPosKeys,
nFovKeys,
nRollKeys,
nTargetKeys);
pKfCam = *kfcam;
/*--- Header Information */
strcpy(pKfCam->name, pNodeHdr->objname);
pKfCam->flags1 = pNodeHdr->flags1;
pKfCam->flags2 = pNodeHdr->flags2;
/*--- Parents */
kfGetParentName(pNodeHdrChunk, pKfCam->parent);
kfGetParentName(pTargetHdrChunk, pKfCam->tparent);
/*--- Target Information */
if (nTargetKeys){
pKfCam->ntflag = pTargetData->trackhdr.flags;
for(i=0; i<nTargetKeys; i++){
memcpy(&((pKfCam->tkeys)[i]),
&((pTargetData->keyhdrlist)[i]),
sizeof(keyheader3ds));
memcpy(&((pKfCam->tpos)[i]),
&((pTargetData->positionlist)[i]),
sizeof(point3ds));
}
}
if (pTargetHdr) {
pKfCam->tflags1 = pTargetHdr->flags1;
pKfCam->tflags2 = pTargetHdr->flags2;
}
/*--- Position Information */
if (nPosKeys){
pKfCam->npflag = pPosData->trackhdr.flags;
for (i=0; i<nPosKeys; i++){
memcpy(&((pKfCam->pkeys)[i]),
&((pPosData->keyhdrlist)[i]),
sizeof(keyheader3ds));
memcpy(&((pKfCam->pos)[i]),
&((pPosData->positionlist)[i]),
sizeof(point3ds));
}
}
/*--- Field of view Information */
if (nFovKeys){
pKfCam->nfflag = pFovData->trackhdr.flags;
for (i=0; i<nFovKeys; i++){
memcpy(&((pKfCam->fkeys)[i]),
&((pFovData->keyhdrlist)[i]),
sizeof(keyheader3ds));
memcpy(&((pKfCam->fov)[i]),
&((pFovData->fovanglelist)[i]),
sizeof(float3ds));
}
}
/*--- Roll Track Information */
if (nRollKeys){
pKfCam->nrflag = pRollData->trackhdr.flags;
for (i=0; i<nRollKeys; i++){
memcpy(&((pKfCam->rkeys)[i]),
&((pRollData->keyhdrlist)[i]),
sizeof(keyheader3ds));
memcpy(&((pKfCam->roll)[i]),
&((pRollData->rollanglelist)[i]),
sizeof(float3ds));
}
}
/*--- Free Chunk Data */
FreeFileChunkData3ds(pPosChunk);
FreeFileChunkData3ds(pFovChunk);
FreeFileChunkData3ds(pRollChunk);
FreeFileChunkData3ds(pNodeHdrChunk);
if (pTargetPosChunk)
FreeFileChunkData3ds(pTargetPosChunk);
if (pTargetHdrChunk)
FreeFileChunkData3ds(pTargetHdrChunk);
}
void PutBackground3ds(database3ds *db, background3ds *bgnd)
{
chunk3ds *mdata;
if(db == NULL || bgnd == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
if(db->topchunk == NULL)
SET_ERROR_RETURN(ERR_INVALID_DATABASE);
if (!(db->topchunk->tag == M3DMAGIC || db->topchunk->tag == CMAGIC))
SET_ERROR_RETURN(ERR_WRONG_DATABASE);
/* Search for a mesh data chunk */
FindChunk3ds(db->topchunk, MDATA, &mdata);
/* If one isn't found, add it to the list */
if (mdata == NULL)
{
InitChunkAs3ds(&mdata, MDATA);
AddChildOrdered3ds(db->topchunk, mdata);
}
/* if (1) */ /* Put bitmap background chunk. */
{
chunk3ds *c;
BitMap *d;
ReplaceOrAddChild3ds(mdata, BIT_MAP, &c);
d = InitChunkData3ds(c);
d->bitmap = (bgnd->bitmap.name)? strdup(bgnd->bitmap.name): strdup("");
}
/* if (1) */ /* Put the SOLID_BGND chunk */
{
chunk3ds *cs, *cc;
ColorF *dc;
ReplaceOrAddChild3ds(mdata, SOLID_BGND, &cs);
dc = InitChunkAndData3ds(&cc, COLOR_F);
dc->red = bgnd->solid.color.r;
dc->green = bgnd->solid.color.g;
dc->blue = bgnd->solid.color.b;
AddChild3ds(cs, cc);
dc = InitChunkAndData3ds(&cc, LIN_COLOR_F);
dc->red = bgnd->solid.color.r;
dc->green = bgnd->solid.color.g;
dc->blue = bgnd->solid.color.b;
AddChild3ds(cs, cc);
}
/* if (1) */ /* Put the V_GRADIENT chunk */
{
chunk3ds *cv, *cc;
VGradient *dv;
ColorF *dc;
ReplaceOrAddChild3ds(mdata, V_GRADIENT, &cv);
dv = InitChunkData3ds(cv);
dv->gradpercent = bgnd->vgradient.gradpercent;
dc = InitChunkAndData3ds(&cc, COLOR_F);
dc->red = bgnd->vgradient.top.r;
dc->green = bgnd->vgradient.top.g;
dc->blue = bgnd->vgradient.top.b;
AddChild3ds(cv, cc);
dc = InitChunkAndData3ds(&cc, LIN_COLOR_F);
dc->red = bgnd->vgradient.top.r;
dc->green = bgnd->vgradient.top.g;
dc->blue = bgnd->vgradient.top.b;
AddChild3ds(cv, cc);
dc = InitChunkAndData3ds(&cc, COLOR_F);
dc->red = bgnd->vgradient.mid.r;
dc->green = bgnd->vgradient.mid.g;
dc->blue = bgnd->vgradient.mid.b;
AddChild3ds(cv, cc);
dc = InitChunkAndData3ds(&cc, LIN_COLOR_F);
dc->red = bgnd->vgradient.mid.r;
dc->green = bgnd->vgradient.mid.g;
dc->blue = bgnd->vgradient.mid.b;
AddChild3ds(cv, cc);
dc = InitChunkAndData3ds(&cc, COLOR_F);
dc->red = bgnd->vgradient.bottom.r;
dc->green = bgnd->vgradient.bottom.g;
dc->blue = bgnd->vgradient.bottom.b;
AddChild3ds(cv, cc);
dc = InitChunkAndData3ds(&cc, LIN_COLOR_F);
dc->red = bgnd->vgradient.bottom.r;
dc->green = bgnd->vgradient.bottom.g;
dc->blue = bgnd->vgradient.bottom.b;
AddChild3ds(cv, cc);
}
/* if (1) */ /* Add a use_bitmap_bgnd, use_solid_bgnd, or use_v_gradient */
{
chunk3ds *chunk;
/* first, find any existing use_* chunks */
FindChunk3ds(mdata, USE_BIT_MAP, &chunk);
if (chunk == NULL)
{
FindChunk3ds(mdata, USE_SOLID_BGND, &chunk);
if (chunk == NULL)
{
FindChunk3ds(mdata, USE_V_GRADIENT, &chunk);
}
}
/* If one was found, delete it */
if (chunk != NULL)
{
DeleteChunk3ds(chunk);
}
if (bgnd->bgndused != NoBgnd)
{
if (chunk == NULL)
{
InitChunk3ds(&chunk);
chunk->tag = USE_BIT_MAP; /* just to help place in order */
AddChildOrdered3ds(mdata,chunk);
}
/* add the new use_* chunk */
switch (bgnd->bgndused)
{
case UseBitmapBgnd:
chunk->tag = USE_BIT_MAP;
break;
case UseSolidBgnd:
chunk->tag = USE_SOLID_BGND;
break;
case UseVGradientBgnd:
chunk->tag = USE_V_GRADIENT;
break;
case NoBgnd:
chunk->tag = NULL_CHUNK;
break;
}
}
}
}
/* Retreaves the background settings from the chunk database */
void GetBackground3ds(database3ds *db, /* the database being searched */
background3ds **bgnd /* the background settings
destination. If *atmo is NULL,
then a new structure will be
allocated */
)
{
chunk3ds *mdata, *chunk;
if (db == NULL || bgnd == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
/* Find the MDATA chunk */
FindChunk3ds(db->topchunk, MDATA, &mdata);
/* only continue with structure filling if an MDATA chunk is found */
if (mdata != NULL)
{
InitBackground3ds(bgnd);
/* Search for bitmap chunk */
FindChunk3ds(mdata, BIT_MAP, &chunk);
if (chunk != NULL)
{
BitMap *bitmap;
/* Read the chunk information */
ReadChunkData3ds(chunk);
/* Alias the data */
bitmap = chunk->data;
/* Copy the bitmap filename to the structure */
if (bitmap->bitmap != NULL) (*bgnd)->bitmap.name = strdup(bitmap->bitmap);
else (*bgnd)->bitmap.name = strdup("");
}
FindChunk3ds(mdata, SOLID_BGND, &chunk);
if (chunk != NULL)
{
chunk3ds *cc;
FindChunk3ds(chunk, COLOR_F, &cc);
if (cc != NULL)
{
ColorF *cd;
cd = ReadChunkData3ds(cc);
(*bgnd)->solid.color.r = cd->red;
(*bgnd)->solid.color.g = cd->green;
(*bgnd)->solid.color.b = cd->blue;
}
FindChunk3ds(chunk, LIN_COLOR_F, &cc);
if (cc != NULL)
{
LinColorF *cd;
cd = ReadChunkData3ds(cc);
(*bgnd)->solid.color.r = cd->red;
(*bgnd)->solid.color.g = cd->green;
(*bgnd)->solid.color.b = cd->blue;
}
}
FindChunk3ds(mdata, V_GRADIENT, &chunk);
if (chunk != NULL)
{
chunk3ds *topcolor, *midcolor, *botcolor;
/* The COLOR_F chunks are the old, non-gamma corrected colors */
ReadChunkData3ds(chunk);
(*bgnd)->vgradient.gradpercent = ((VGradient *)(chunk->data))->gradpercent;
FindChunk3ds(chunk, COLOR_F, &topcolor);
if (topcolor != NULL)
{
ReadChunkData3ds(topcolor);
(*bgnd)->vgradient.top.r = ((ColorF *)(topcolor->data))->red;
(*bgnd)->vgradient.top.g = ((ColorF *)(topcolor->data))->green;
(*bgnd)->vgradient.top.b = ((ColorF *)(topcolor->data))->blue;
FindNextChunk3ds(topcolor->sibling, COLOR_F, &midcolor);
if (midcolor != NULL)
{
ReadChunkData3ds(midcolor);
(*bgnd)->vgradient.mid.r = ((ColorF *)(midcolor->data))->red;
(*bgnd)->vgradient.mid.g = ((ColorF *)(midcolor->data))->green;
(*bgnd)->vgradient.mid.b = ((ColorF *)(midcolor->data))->blue;
FindNextChunk3ds(midcolor->sibling, COLOR_F, &botcolor);
if (botcolor != NULL)
{
ReadChunkData3ds(botcolor);
(*bgnd)->vgradient.bottom.r = ((ColorF *)(botcolor->data))->red;
(*bgnd)->vgradient.bottom.g = ((ColorF *)(botcolor->data))->green;
(*bgnd)->vgradient.bottom.b = ((ColorF *)(botcolor->data))->blue;
}
}
}
/* If the newer, gamma correct colors are available, then use them instead */
FindChunk3ds(chunk, LIN_COLOR_F, &topcolor);
if (topcolor != NULL)
{
ReadChunkData3ds(topcolor);
(*bgnd)->vgradient.top.r = ((ColorF *)(topcolor->data))->red;
(*bgnd)->vgradient.top.g = ((ColorF *)(topcolor->data))->green;
(*bgnd)->vgradient.top.b = ((ColorF *)(topcolor->data))->blue;
FindNextChunk3ds(topcolor->sibling, LIN_COLOR_F, &midcolor);
if (midcolor != NULL)
{
ReadChunkData3ds(midcolor);
(*bgnd)->vgradient.mid.r = ((ColorF *)(midcolor->data))->red;
(*bgnd)->vgradient.mid.g = ((ColorF *)(midcolor->data))->green;
(*bgnd)->vgradient.mid.b = ((ColorF *)(midcolor->data))->blue;
FindNextChunk3ds(midcolor->sibling, LIN_COLOR_F, &botcolor);
if (botcolor != NULL)
{
ReadChunkData3ds(botcolor);
(*bgnd)->vgradient.bottom.r = ((ColorF *)(botcolor->data))->red;
(*bgnd)->vgradient.bottom.g = ((ColorF *)(botcolor->data))->green;
(*bgnd)->vgradient.bottom.b = ((ColorF *)(botcolor->data))->blue;
}
}
}
}
/* Search for use_bitmap, use_solid_bgnd, or use_v_gradient */
FindChunk3ds(mdata, USE_BIT_MAP, &chunk);
if (chunk != NULL)
{
(*bgnd)->bgndused = UseBitmapBgnd;
} else
{
FindChunk3ds(mdata, USE_SOLID_BGND, &chunk);
if (chunk != NULL)
{
(*bgnd)->bgndused = UseSolidBgnd;
} else
{
FindChunk3ds(mdata, USE_V_GRADIENT, &chunk);
if (chunk != NULL)
{
(*bgnd)->bgndused = UseVGradientBgnd;
} else
{
(*bgnd)->bgndused = NoBgnd;
}
}
}
}
}
/*--------------------------------------------------------------------------
| GetAmbientLightMotionChunk3ds
|
| pAmbientChunk:SPOTAMBIENT_NODE_TAG chunk to extract data from
| pTargetChunk: L_TARGET_NODE_TAG chunk to extract target data from
| kfspot: Structure to fill in with chunk data
|
| chunk----->kfAmbient3ds
|
| Gets AmbientLight keyframe information from chunk
|
| L_TARGET
| ...
| NODE_HDR
| APP_DATA
| COL_TRACK
|
+--------------------------------------------------------------------------*/
void GetAmbientLightMotionChunk3ds(chunk3ds *pAmbientChunk,
kfambient3ds **kfambient)
{
kfambient3ds
*pKfAmbient;
chunk3ds
*pNodeHdrChunk, *pColChunk;
ulong3ds i,
nColKeys = 0;
NodeHdr
*pNodeHdr = NULL;
ColTrackTag
*pColData = NULL;
if (pAmbientChunk == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
/*-------------------------------
| Get information from chunks
+-------------------------------*/
/*--- Search children of AmbientLight chunk */
FindChunk3ds(pAmbientChunk, NODE_HDR, &pNodeHdrChunk);
FindChunk3ds(pAmbientChunk, COL_TRACK_TAG, &pColChunk);
if (pNodeHdrChunk){
ReadChunkData3ds(pNodeHdrChunk);
pNodeHdr = pNodeHdrChunk->data;
}
if(pColChunk){
ReadChunkData3ds(pColChunk);
pColData = pColChunk->data;
nColKeys = pColData->trackhdr.keycount;
}
/*--------------------------------------------
| Set-up and fill-in the kfambient3ds structure
+--------------------------------------------*/
InitAmbientLightMotion3ds(kfambient, nColKeys);
pKfAmbient = *kfambient;
/*--- Header Information */
if (pNodeHdr){
pKfAmbient->flags1 = pNodeHdr->flags1;
pKfAmbient->flags2 = pNodeHdr->flags2;
}
/*--- Color Information */
if (pColData){
if (nColKeys){
pKfAmbient->ncflag = pColData->trackhdr.flags;
for(i=0; i<nColKeys; i++){
memcpy(&((pKfAmbient->ckeys)[i]),
&((pColData->keyhdrlist)[i]),
sizeof(keyheader3ds));
memcpy(&((pKfAmbient->color)[i]),
&((pColData->colorlist)[i]),
sizeof(fcolor3ds));
}
}
}
/*--- Free Chunk Data */
if (pNodeHdrChunk)
FreeFileChunkData3ds(pNodeHdrChunk);
if (pColChunk)
FreeFileChunkData3ds(pColChunk);
}
void GetMeshEntryChunk3ds(chunk3ds *chunk, mesh3ds **mesh)
{
chunk3ds *nobj=NULL, *datachunk=NULL, *ntrichunk, *current;
void *data = NULL;
ushort3ds meshmatcount=0;
if (chunk == NULL || mesh == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
FindNextChunk3ds(chunk->children, N_TRI_OBJECT, &ntrichunk);
if (ntrichunk == NULL)
SET_ERROR_RETURN(ERR_WRONG_OBJECT);
InitMeshObj3ds(mesh,0,0,0);
/* Copy the mesh chunk into a temporary chunk */
CopyChunk3ds(chunk, &nobj);
ON_ERROR_RETURN;
/* Get the N_TRI_OBJECT part out of it. */
FindNextChunk3ds(nobj->children, N_TRI_OBJECT, &ntrichunk);
/* Get the mesh name. */
{
NamedObject *d;
d = ReadChunkData3ds(nobj);
strcpy((*mesh)->name, d->name);
}
for (current = ntrichunk->children; current != NULL; current = current->sibling)
{
switch(current->tag)
{
case POINT_ARRAY:
{
PointArray *d;
d = ReadChunkData3ds(current);
(*mesh)->nvertices = d->vertices;
(*mesh)->vertexarray = d->pointlist;
d->pointlist = NULL;
break;
}
case POINT_FLAG_ARRAY:
{
PointFlagArray *flags;
flags = ReadChunkData3ds(current);
(*mesh)->nvflags = flags->flags;
(*mesh)->vflagarray = flags->flaglist;
flags->flaglist = NULL;
break;
}
case FACE_ARRAY:
{
FaceArray *d;
d = ReadChunkData3ds(current);
(*mesh)->nfaces = d->faces;
(*mesh)->facearray = d->facelist;
d->facelist = NULL;
if (current->children != NULL)
{
/* begin search for MESH_MAT_GROUP and SMOOTH_GROUP */
chunk3ds *facearraychunk=current;
/* create a list of all mesh mat groups */
FindChunk3ds(facearraychunk, MSH_MAT_GROUP, &datachunk);
if (datachunk != NULL)
{
ulong3ds index;
meshmatcount = (ushort3ds)GetMeshMatCount3ds(datachunk);
(*mesh)->nmats = meshmatcount;
(*mesh)->matarray = calloc(meshmatcount, sizeof(objmat3ds));
for (index = 0; index < (*mesh)->nmats; index++)
{
MshMatGroup *omat = NULL;
omat = ReadChunkData3ds(datachunk);
strcpy((*mesh)->matarray[index].name, omat->matname);
(*mesh)->matarray[index].nfaces = omat->faces;
(*mesh)->matarray[index].faceindex = omat->facelist;
omat->facelist = NULL;
FindNextChunk3ds(datachunk->sibling, MSH_MAT_GROUP, &datachunk);
}
}
FindNextChunk3ds(facearraychunk->children, SMOOTH_GROUP, &datachunk);
if (datachunk != NULL) {
SmoothGroup *sm;
long3ds smelements;
sm = ReadChunkData3ds(datachunk);
smelements = (datachunk->size - 6)/LongSize3ds;
(*mesh)->smootharray = sm->grouplist;
sm->grouplist = NULL;
}
FindNextChunk3ds(facearraychunk->children, MSH_BOXMAP, &datachunk);
if (datachunk != NULL)
{
MshBoxmap *bm;
ushort3ds i;
ReadChunkData3ds(datachunk);
bm = datachunk->data;
for (i = 0; i < 6; i++) strcpy((*mesh)->boxmap[i], bm->matnames[i]);
(*mesh)->useboxmap = True3ds;
}
}
break;
}
case TEX_VERTS:
{
TexVerts *tv;
ReadChunkData3ds(current);
tv = current->data;
(*mesh)->ntextverts = tv->numcoords;
(*mesh)->textarray = tv->textvertlist;
tv->textvertlist = NULL;
break;
}
case MESH_MATRIX:
{
ReadChunkData3ds(current);
data = current->data;
memcpy((*mesh)->locmatrix ,((MeshMatrix *)data)->xmatrix, 12*sizeof(float3ds));
break;
}
case MESH_TEXTURE_INFO:
{
(*mesh)->usemapinfo = True3ds;
ReadChunkData3ds(current);
data = current->data;
(*mesh)->map.maptype = ((MeshTextureInfo *)data)->maptype;
(*mesh)->map.tilex = ((MeshTextureInfo *)data)->xtiling;
(*mesh)->map.tiley = ((MeshTextureInfo *)data)->ytiling;
(*mesh)->map.cenx = ((MeshTextureInfo *)data)->iconpos.x;
(*mesh)->map.ceny = ((MeshTextureInfo *)data)->iconpos.y;
(*mesh)->map.cenz = ((MeshTextureInfo *)data)->iconpos.z;
(*mesh)->map.scale = ((MeshTextureInfo *)data)->iconscaling;
memcpy((*mesh)->map.matrix , ((MeshTextureInfo *)data)->xmatrix, 12*sizeof(float3ds));
(*mesh)->map.pw = ((MeshTextureInfo *)data)->iconwidth;
(*mesh)->map.ph = ((MeshTextureInfo *)data)->iconheight;
(*mesh)->map.ch = ((MeshTextureInfo *)data)->cyliconheight;
break;
}
case PROC_NAME:
{
ReadChunkData3ds(current);
data = current->data;
strcpy((*mesh)->procname, ((ProcName *)data)->name);
break;
}
case PROC_DATA:
{
IpasData *d;
d = ReadChunkData3ds(current);
(*mesh)->procsize = d->size;
(*mesh)->procdata = d->data;
d->data = NULL; /* CCJ */
break;
}
case MESH_COLOR:
{
ReadChunkData3ds(current);
(*mesh)->meshcolor = ((MeshColor *)(current->data))->color;
break;
}
}
}
FindNextChunk3ds(nobj->children, OBJ_HIDDEN, ¤t);
if (current != NULL) (*mesh)->ishidden = True3ds;
else (*mesh)->ishidden = False3ds;
FindNextChunk3ds(nobj->children, OBJ_VIS_LOFTER, ¤t);
if (current != NULL) (*mesh)->isvislofter = True3ds;
else (*mesh)->isvislofter = False3ds;
FindNextChunk3ds(nobj->children, OBJ_DOESNT_CAST, ¤t);
if (current != NULL) (*mesh)->isnocast = True3ds;
else (*mesh)->isnocast = False3ds;
FindNextChunk3ds(nobj->children, OBJ_MATTE, ¤t);
if (current != NULL) (*mesh)->ismatte = True3ds;
else (*mesh)->ismatte = False3ds;
FindNextChunk3ds(nobj->children, OBJ_FAST, ¤t);
if (current != NULL) (*mesh)->isfast = True3ds;
else (*mesh)->isfast = False3ds;
FindNextChunk3ds(nobj->children, OBJ_FROZEN, ¤t);
if (current != NULL) (*mesh)->isfrozen = True3ds;
else (*mesh)->isfrozen = False3ds;
FindNextChunk3ds(nobj->children, OBJ_DONT_RCVSHADOW, ¤t);
if (current != NULL) (*mesh)->isnorcvshad = True3ds;
else (*mesh)->isnorcvshad = False3ds;
FindNextChunk3ds(nobj->children, OBJ_PROCEDURAL, ¤t);
if (current != NULL) (*mesh)->useproc = True3ds;
else (*mesh)->useproc = False3ds;
ReleaseChunk3ds(&nobj);
}
/*----------------------------------------------------------------
|
| PutLight3ds
|
| Put chunks in database from light3ds structure.
|
+-----------------------------------------------------------------*/
void PutLight3ds(database3ds *db, light3ds *light)
{
chunk3ds *pMdata, *pNamed, *pLight, *pSpot, *current, *xdata;
if (db == NULL || light == NULL) SET_ERROR_RETURN(ERR_INVALID_ARG);
if (db->topchunk == NULL) SET_ERROR_RETURN(ERR_INVALID_DATABASE);
if (!(db->topchunk->tag == M3DMAGIC || db->topchunk->tag == CMAGIC))
SET_ERROR_RETURN(ERR_WRONG_DATABASE);
FindChunk3ds(db->topchunk, MDATA, &pMdata);
if (pMdata == NULL)
{
InitChunk3ds(&pMdata);
pMdata->tag = MDATA;
AddChildOrdered3ds(db->topchunk, pMdata);
}
/* Discover if the named object already exists */
FindNamedObject3ds(db, light->name, &pNamed);
/* If it does, then delete it */
if (pNamed != NULL)
{
/* First, rescue the xdata chunk if there is one */
FindChunk3ds(pNamed, XDATA_SECTION, ¤t);
/* If there is one */
if (current != NULL)
{
/* Then make a copy of it to reintroduce later */
CopyChunk3ds(current, &xdata);
}
/* Delete the chunk's children and data,
leaving it in the same list order */
DeleteChunk3ds(pNamed);
pNamed->tag = NAMED_OBJECT; /* retag the chunk */
} else /* else pNamed needs to be initialized and added */
{
InitChunkAs3ds(&pNamed, NAMED_OBJECT);
AddChildOrdered3ds(pMdata, pNamed);
}
{ /*--- NAME */
NamedObject *d;
d = InitChunkData3ds(pNamed);
d->name = strdup(light->name);
MakeNamedObjectListDirty3ds(db);
}
{ /*--- N_DIRECT_LIGHT & POSITION */
NDirectLight *d;
pLight = kfPutGenericNode(N_DIRECT_LIGHT, pNamed);
d = InitChunkData3ds(pLight);
memcpy(&(d->lightpos), &(light->pos), sizeof(point3ds));
}
/*
| Add children to DIRECT_LIGHT
*/
/*--- COLOR */
{
ColorF *d;
chunk3ds *pChunk;
pChunk = kfPutGenericNode(COLOR_F, pLight);
d = InitChunkData3ds(pChunk);
d->red = light->color.r;
d->green = light->color.g;
d->blue = light->color.b;
}
putTagFloat(pLight, DL_OUTER_RANGE, &light->attenuation.outer);
ON_ERROR_RETURN;
putTagFloat(pLight, DL_INNER_RANGE, &light->attenuation.inner);
ON_ERROR_RETURN;
putTagFloat(pLight, DL_MULTIPLIER, &light->multiplier);
ON_ERROR_RETURN;
if (light->dloff == True3ds)
kfPutGenericNode(DL_OFF, pLight);
if (light->attenuation.on == True3ds)
kfPutGenericNode(DL_ATTENUATE, pLight);
/*--- DL_EXCLUDE */
if (light->exclude != NULL && light->exclude->count > 0){
chunk3ds *pChunk;
ulong3ds i;
DlExclude *d;
for(i=0; i<light->exclude->count; i++){
pChunk = kfPutGenericNode(DL_EXCLUDE, pLight);
d = InitChunkData3ds(pChunk);
d->name = strdup((light->exclude->list)[i].name);
}
}
/*-----------------------
| SPOTLIGHT SECTION
+-----------------------*/
if (light->spot == NULL)
return;
{
DlSpotlight *d;
pSpot = kfPutGenericNode(DL_SPOTLIGHT, pLight);
d = InitChunkData3ds(pSpot);
memcpy(&d->spotlighttarg, &light->spot->target, sizeof(point3ds));
d->hotspotangle = light->spot->hotspot;
d->falloffangle = light->spot->falloff;
}
putTagFloat(pSpot, DL_SPOT_ROLL, &light->spot->roll);
if (light->spot->aspect != 1.0F)
putTagFloat(pSpot, DL_SPOT_ASPECT, &light->spot->aspect);
/*--- SHADOWS */
if (light->spot->shadows.cast == True3ds)
kfPutGenericNode(DL_SHADOWED, pSpot);
if (light->spot->shadows.type == UseRayTraceShadow)
kfPutGenericNode(DL_RAYSHAD, pSpot);
putTagFloat(pSpot, DL_RAY_BIAS, &light->spot->shadows.raybias);
/*--- DL_LOCAL_SHADOW2 */
if (light->spot->shadows.local == True3ds)
{
DlLocalShadow2 *d;
chunk3ds *pChunk;
kfPutGenericNode(DL_LOCAL_SHADOW, pSpot);
pChunk = kfPutGenericNode(DL_LOCAL_SHADOW2, pSpot);
d = InitChunkData3ds(pChunk);
d->localshadowbias = light->spot->shadows.bias;
d->localshadowfilter = light->spot->shadows.filter;
d->localshadowmapsize = light->spot->shadows.mapsize;
}
/*--- CONE */
if (light->spot->cone.type == Rectangular)
kfPutGenericNode(DL_SPOT_RECTANGULAR, pSpot);
if (light->spot->cone.show == True3ds)
kfPutGenericNode(DL_SEE_CONE, pSpot);
if (light->spot->cone.overshoot == True3ds)
kfPutGenericNode(DL_SPOT_OVERSHOOT, pSpot);
/*--- PROJECTOR */
if (light->spot->projector.use == True3ds)
{
DlSpotProjector *d;
chunk3ds *pChunk;
pChunk = kfPutGenericNode(DL_SPOT_PROJECTOR, pSpot);
d = InitChunkData3ds(pChunk);
d->name = strdup(light->spot->projector.bitmap);
}
}
/*------------------------------------------------------------------------
|
| GetLightEntryChunk3ds
| Fills out the *light structure with the light pointed to
| by *chunk
|
+-----------------------------------------------------------------------*/
void GetLightEntryChunk3ds(chunk3ds *chunk, light3ds **light)
{
chunk3ds *nobj, *dlite, *spot, *current;
if (light == NULL) SET_ERROR_RETURN(ERR_INVALID_ARG);
FindNextChunk3ds(chunk->children, N_DIRECT_LIGHT, &dlite);
if (dlite == NULL) SET_ERROR_RETURN(ERR_WRONG_OBJECT);
CopyChunk3ds(chunk, &nobj);
FindChunk3ds(nobj, N_DIRECT_LIGHT, &dlite);
FindChunk3ds(nobj, DL_SPOTLIGHT, &spot);
if (dlite != NULL)
{
NamedObject *nobjd;
NDirectLight *ndl;
/* Initilize **light properly */
if (spot == NULL)
InitLight3ds(light);
else
InitSpotlight3ds(light);
/* Copy the object name */
nobjd = ReadChunkData3ds(nobj);
strcpy((*light)->name, nobjd->name);
/* Copy the light postion */
ndl = ReadChunkData3ds(dlite);
(*light)->pos = ndl->lightpos;
/* scan all the chunks the light contains */
for (current = dlite->children; current != NULL; current = current->sibling)
{
switch(current->tag)
{
case COLOR_F: /* The color of the light */
{
ColorF *d;
d = ReadChunkData3ds(current);
(*light)->color.r = d->red;
(*light)->color.g = d->green;
(*light)->color.b = d->blue;
}
break;
case COLOR_24: /* The color of the (*light) */
{
Color24 *d;
d = ReadChunkData3ds(current);
(*light)->color.r = (float3ds)d->red / 255.0F;
(*light)->color.g = (float3ds)d->green / 255.0F;
(*light)->color.b = (float3ds)d->blue / 255.0F;
}
break;
case DL_MULTIPLIER: /* The light intensity */
{
DlMultiplier *d;
d = ReadChunkData3ds(current);
(*light)->multiplier = d->multiple;
}
break;
case DL_INNER_RANGE:
{
DlInnerRange *d;
d = ReadChunkData3ds(current);
/* assuming since there is a value it is on */
(*light)->attenuation.inner = d->range;
}
break;
case DL_OUTER_RANGE:
{
DlOuterRange *d;
d = ReadChunkData3ds(current);
/* assuming since there is a value it is on */
(*light)->attenuation.outer = d->range;
}
break;
case DL_EXCLUDE:
{
DlExclude *d;
char3ds *name;
d = ReadChunkData3ds(current);
if ((*light)->exclude == NULL)
InitNameList3ds(&((*light)->exclude), 0);
name = d->name;
d->name = NULL;
AddToNameList3ds(&((*light)->exclude), name);
free(name);
}
break;
case DL_OFF:
(*light)->dloff = True3ds;
break;
case DL_ATTENUATE:
(*light)->attenuation.on = True3ds;
break;
}
}
/*--- DL_SPOTLIGHT chunk */
if (spot != NULL){
DlSpotlight *d;
/*--- Read spotlight data */
d = ReadChunkData3ds(spot);
(*light)->spot->target = d->spotlighttarg;
(*light)->spot->hotspot = d->hotspotangle;
(*light)->spot->falloff = d->falloffangle;
/* scan all the chunks the spotlight contains */
for (current = spot->children;
current != NULL;
current = current->sibling)
{
switch(current->tag)
{
case DL_SPOT_ROLL:
{
DlSpotRoll *d;
d = ReadChunkData3ds(current);
(*light)->spot->roll = d->angle;
}
break;
case DL_LOCAL_SHADOW:
(*light)->spot->shadows.cast = True3ds;
break;
case DL_LOCAL_SHADOW2:
{
DlLocalShadow2 *d;
d = ReadChunkData3ds(current);
(*light)->spot->shadows.bias = d->localshadowbias;
(*light)->spot->shadows.filter = d->localshadowfilter;
(*light)->spot->shadows.mapsize = d->localshadowmapsize;
(*light)->spot->shadows.local = True3ds;
}
break;
case DL_SHADOWED:
(*light)->spot->shadows.cast = True3ds;
break;
case DL_SPOT_RECTANGULAR:
(*light)->spot->cone.type = Rectangular;
break;
case DL_SEE_CONE:
(*light)->spot->cone.show = True3ds;
break;
case DL_SPOT_OVERSHOOT:
(*light)->spot->cone.overshoot = True3ds;
break;
case DL_SPOT_ASPECT:
{
DlSpotAspect *d;
d = ReadChunkData3ds(current);
(*light)->spot->aspect = d->aspect;
}
break;
case DL_RAY_BIAS:
{
DlRayBias *d;
d = ReadChunkData3ds(current);
(*light)->spot->shadows.raybias = d->bias;
}
break;
case DL_RAYSHAD:
{
(*light)->spot->shadows.type = UseRayTraceShadow;
break;
}
case DL_SPOT_PROJECTOR:
{
DlSpotProjector *d;
d = ReadChunkData3ds(current);
(*light)->spot->projector.bitmap = d->name;
(*light)->spot->projector.use = True3ds;
d->name = NULL;
}
break;
}
}
}
}
ReleaseChunk3ds(&nobj);
}
/* Puts a mesh3ds into the chunk database. Note that this routine will clobber
named objects of the same name, except that it will transfer the old xdata onto
the new object. If the developer wants to wipe out the XDATA too, he'll have
to explicitly delete using the DeleteMesh3ds function */
void PutMesh3ds(database3ds *db, mesh3ds *mesh)
{
chunk3ds *mdata, *nobj, *ntri, *current;
NamedObject *nobjdata;
chunk3ds *xdata = NULL;
long3ds i;
if (db == NULL || mesh == NULL) SET_ERROR_RETURN(ERR_INVALID_ARG);
if (db->topchunk == NULL) SET_ERROR_RETURN(ERR_INVALID_DATABASE);
if (!(db->topchunk->tag == M3DMAGIC || db->topchunk->tag == CMAGIC))
SET_ERROR_RETURN(ERR_WRONG_DATABASE);
FindChunk3ds(db->topchunk, MDATA, &mdata);
if (mdata == NULL)
{
InitChunk3ds(&mdata);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
mdata->tag = MDATA;
AddChildOrdered3ds(db->topchunk, mdata);
}
/* Discover if the named object already exists */
FindNamedObject3ds(db, mesh->name, &nobj);
ON_ERROR_RETURN;
/* If it does, then delete it */
if (nobj != NULL)
{
/* First, rescue the xdata chunk if there is one */
FindChunk3ds(nobj, XDATA_SECTION, ¤t);
/* If there is one */
if (current != NULL)
{
/* Then make a copy of it to reintroduce later */
CopyChunk3ds(current, &xdata);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
}
/* Delete the chunk's children and data, leaving it in the same list order */
DeleteChunk3ds(nobj);
nobj->tag = NAMED_OBJECT; /* retag the chunk */
} else /* else nobj needs to be initialized and added */
{
InitChunkAs3ds(&nobj, NAMED_OBJECT);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
AddChildOrdered3ds(mdata, nobj);
}
/* Copy the mesh name into the chunk */
nobjdata = InitChunkData3ds(nobj);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
nobjdata->name = strdup(mesh->name);
MakeNamedObjectListDirty3ds(db);
InitChunk3ds(&ntri);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
ntri->tag = N_TRI_OBJECT;
AddChildOrdered3ds(nobj, ntri);
if ((mesh->nvertices > 0) && (mesh->vertexarray != NULL))
{ /* Add the point array */
PointArray *d;
chunk3ds *temp = NULL;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = POINT_ARRAY;
d = InitChunkData3ds(temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
d->vertices = mesh->nvertices;
d->pointlist = malloc(sizeof(point3ds)*d->vertices);
if (d->pointlist == NULL) SET_ERROR_RETURN(ERR_NO_MEM);
memcpy(d->pointlist, mesh->vertexarray, sizeof(point3ds)*d->vertices);
AddChildOrdered3ds(ntri, temp);
}
if (mesh->ntextverts > 0)
{
TexVerts *d;
chunk3ds *temp = NULL;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = TEX_VERTS;
d = InitChunkData3ds(temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
d->numcoords = mesh->ntextverts;
d->textvertlist = malloc(sizeof(textvert3ds)*d->numcoords);
if (d->textvertlist == NULL) SET_ERROR_RETURN(ERR_NO_MEM);
memcpy(d->textvertlist, mesh->textarray, sizeof(textvert3ds)*d->numcoords);
AddChildOrdered3ds(ntri, temp);
}
if (mesh->usemapinfo)
{
MeshTextureInfo *d;
chunk3ds *temp;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = MESH_TEXTURE_INFO;
d = InitChunkData3ds(temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
d->maptype = mesh->map.maptype;
d->xtiling = mesh->map.tilex;
d->ytiling = mesh->map.tiley;
d->iconpos.x = mesh->map.cenx;
d->iconpos.y = mesh->map.ceny;
d->iconpos.z = mesh->map.cenz;
d->iconscaling = mesh->map.scale;
memcpy(d->xmatrix, mesh->map.matrix, sizeof(float3ds)*12);
d->iconwidth = mesh->map.pw;
d->iconheight = mesh->map.ph;
d->cyliconheight = mesh->map.ch;
AddChildOrdered3ds(ntri, temp);
}
if ((mesh->nvflags > 0) && (mesh->vflagarray != NULL))
{
PointFlagArray *d;
chunk3ds *temp = NULL;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = POINT_FLAG_ARRAY;
d = InitChunkData3ds(temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
d->flags = mesh->nvflags;
d->flaglist = malloc(sizeof(ushort3ds)*d->flags);
if (d->flaglist == NULL) SET_ERROR_RETURN(ERR_NO_MEM);
memcpy(d->flaglist, mesh->vflagarray, sizeof(ushort3ds)*d->flags);
AddChildOrdered3ds(ntri, temp);
}
{
MeshMatrix *d;
chunk3ds *temp = NULL;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = MESH_MATRIX;
d = InitChunkData3ds(temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
memcpy(d->xmatrix, mesh->locmatrix, sizeof(float3ds)*12);
AddChildOrdered3ds(ntri, temp);
}
{
chunk3ds *temp = NULL;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = MESH_COLOR;
InitChunkData3ds(temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
((MeshColor *)(temp->data))->color = mesh->meshcolor;
AddChildOrdered3ds(ntri, temp);
}
if (mesh->nfaces > 0)
{
chunk3ds *farr = NULL;
FaceArray *d;
InitChunk3ds(&farr);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
farr->tag = FACE_ARRAY;
d = InitChunkData3ds(farr);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
farr->data = d;
d->faces = mesh->nfaces;
d->facelist = malloc(sizeof(face3ds)*d->faces);
if (d->facelist == NULL) SET_ERROR_RETURN(ERR_NO_MEM);
memcpy(d->facelist, mesh->facearray, sizeof(face3ds)*d->faces);
AddChildOrdered3ds(ntri, farr);
if (mesh->nmats > 0)
{
chunk3ds *matgroup;
ushort3ds x;
MshMatGroup *d;
for (x = 0; x < mesh->nmats; x++)
{
matgroup = NULL;
InitChunk3ds(&matgroup);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
matgroup->tag = MSH_MAT_GROUP;
d = InitChunkData3ds(matgroup);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
d->matname = strdup(mesh->matarray[x].name);
d->faces = mesh->matarray[x].nfaces;
if (d->faces > 0)
{
d->facelist = malloc(sizeof(short3ds)*d->faces);
if (d->facelist == NULL) SET_ERROR_RETURN(ERR_NO_MEM);
memcpy(d->facelist, mesh->matarray[x].faceindex, sizeof(short3ds)*d->faces);
} else
{
d->facelist = NULL;
}
AddChildOrdered3ds(farr, matgroup);
}
}
if (mesh->smootharray != NULL)
{
chunk3ds *smooth = NULL;
SmoothGroup *d;
InitChunk3ds(&smooth);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
smooth->tag = SMOOTH_GROUP;
d = InitChunkData3ds(smooth);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
d->groups = mesh->nfaces;
d->grouplist = malloc(sizeof(long3ds)*d->groups);
if (d->grouplist == NULL) SET_ERROR_RETURN(ERR_NO_MEM);
memcpy(d->grouplist, mesh->smootharray, sizeof(long3ds)*d->groups);
AddChildOrdered3ds(farr, smooth);
}
if (mesh->useboxmap)
{
chunk3ds *boxmap = NULL;
MshBoxmap *d;
InitChunk3ds(&boxmap);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
boxmap->tag = MSH_BOXMAP;
d = InitChunkData3ds(boxmap);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
for (i = 0; i < 6; i++)
{
d->matnames[i] = strdup(mesh->boxmap[i]);
}
AddChildOrdered3ds(farr, boxmap);
}
}
if (mesh->procdata != NULL)
{
chunk3ds *procname, *procdata;
ProcName *pname;
IpasData *pdata;
InitChunk3ds(&procname);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
InitChunk3ds(&procdata);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
procname->tag = PROC_NAME;
procdata->tag = PROC_DATA;
pname = InitChunkData3ds(procname);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
pdata = InitChunkData3ds(procdata);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
pname->name = strdup(mesh->procname);
pdata->size = mesh->procsize;
pdata->data = malloc(pdata->size);
if (pdata->data == NULL) SET_ERROR_RETURN(ERR_NO_MEM);
memcpy(pdata->data, mesh->procdata, pdata->size);
AddChildOrdered3ds(ntri, procname);
AddChildOrdered3ds(ntri, procdata);
}
if (mesh->ishidden)
{
chunk3ds *temp;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = OBJ_HIDDEN;
AddChildOrdered3ds(nobj, temp);
}
if (mesh->isvislofter)
{
chunk3ds *temp;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = OBJ_VIS_LOFTER;
AddChildOrdered3ds(nobj, temp);
}
if (mesh->ismatte)
{
chunk3ds *temp;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = OBJ_MATTE;
AddChildOrdered3ds(nobj, temp);
}
if (mesh->isnocast)
{
chunk3ds *temp;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = OBJ_DOESNT_CAST;
AddChildOrdered3ds(nobj, temp);
}
if (mesh->isfast)
{
chunk3ds *temp;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = OBJ_FAST;
AddChildOrdered3ds(nobj, temp);
}
if (mesh->isnorcvshad)
{
chunk3ds *temp;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = OBJ_DONT_RCVSHADOW;
AddChildOrdered3ds(nobj, temp);
}
if (mesh->isfrozen)
{
chunk3ds *temp;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = OBJ_FROZEN;
AddChildOrdered3ds(nobj, temp);
}
if ((mesh->useproc==True3ds) && (mesh->procdata != NULL))
{
chunk3ds *temp;
InitChunk3ds(&temp);
ADD_ERROR_RETURN(ERR_PUT_FAIL);
temp->tag = OBJ_PROCEDURAL;
AddChildOrdered3ds(nobj, temp);
}
if (xdata != NULL)
{
AddChildOrdered3ds(ntri, xdata);
}
}
/*--------------------------------------------------------------------------
| GetOmnilightMotion3ds
|
| pOmniChunk:SPOTLIGHT_NODE_TAG chunk to extract data from
| pTargetChunk: L_TARGET_NODE_TAG chunk to extract target data from
| kfspot: Structure to fill in with chunk data
|
| chunk----->kfOmni3ds
|
| Gets Omnilight keyframe information from chunk
|
| L_TARGET
| NODE_ID
| NODE_HDR
| APP_DATA
| POS_TRACK
| COL_TRACK
| HOT_TRACK
| FALL_TRACK
| ROLL_TRACK
|
+--------------------------------------------------------------------------*/
void GetOmnilightMotion3ds(chunk3ds *pOmniChunk,
kfomni3ds **kfomni)
{
kfomni3ds *pKfOmni;
chunk3ds *pNodeHdrChunk, *pPosChunk, *pColChunk;
ulong3ds i, nPosKeys = 0, nColKeys = 0;
NodeHdr *pNodeHdr;
PosTrackTag *pPosData = NULL;
ColTrackTag *pColData = NULL;
if (pOmniChunk == NULL)
SET_ERROR_RETURN(ERR_INVALID_ARG);
/*-------------------------------
| Get information from chunks
+-------------------------------*/
/*--- Search children of OmniLight chunk */
FindChunk3ds(pOmniChunk, NODE_HDR, &pNodeHdrChunk);
FindChunk3ds(pOmniChunk, POS_TRACK_TAG, &pPosChunk);
FindChunk3ds(pOmniChunk, COL_TRACK_TAG, &pColChunk);
ReadChunkData3ds(pNodeHdrChunk);
pNodeHdr = pNodeHdrChunk->data;
if(pPosChunk){
ReadChunkData3ds(pPosChunk);
pPosData = pPosChunk->data;
nPosKeys = pPosData->trackhdr.keycount;
}
if(pColChunk){
ReadChunkData3ds(pColChunk);
pColData = pColChunk->data;
nColKeys = pColData->trackhdr.keycount;
}
/*--------------------------------------------
| Set-up and fill-in the kfomni3ds structure
+--------------------------------------------*/
InitOmnilightMotion3ds(kfomni, nPosKeys, nColKeys);
pKfOmni = *kfomni;
/*--- Header Information */
strcpy(pKfOmni->name, pNodeHdr->objname);
pKfOmni->flags1 = pNodeHdr->flags1;
pKfOmni->flags2 = pNodeHdr->flags2;
kfGetParentName(pNodeHdrChunk, pKfOmni->parent);
/*--- Position Information */
if (nPosKeys){
pKfOmni->npflag = pPosData->trackhdr.flags;
for (i=0; i<nPosKeys; i++){
memcpy(&((pKfOmni->pkeys)[i]), &((pPosData->keyhdrlist)[i]),
sizeof(keyheader3ds));
memcpy(&((pKfOmni->pos)[i]), &((pPosData->positionlist)[i]),
sizeof(point3ds));
}
}
/*--- Color Information */
if (nColKeys){
pKfOmni->ncflag = pColData->trackhdr.flags;
for (i=0; i<nColKeys; i++){
memcpy(&((pKfOmni->ckeys)[i]), &((pColData->keyhdrlist)[i]),
sizeof(keyheader3ds));
memcpy(&((pKfOmni->color)[i]), &((pColData->colorlist)[i]),
sizeof(fcolor3ds));
}
}
/*--- Free Chunk Data */
if (pNodeHdrChunk)
FreeFileChunkData3ds(pNodeHdrChunk);
if (pPosChunk)
FreeFileChunkData3ds(pPosChunk);
if (pColChunk)
FreeFileChunkData3ds(pColChunk);
}