3dspm.c

一个高性能的3D游戏引擎源代码

// Animation driver for 3ds4 files
// Stolen form code of Jare/Iguana


#define debug(x) //x

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <malloc.h>
#include <ctype.h>
//#include <unistd.h>           // Needed on SunOS
#include "pmotion.h"
#include "pvision.h"
#include "3dspm.h"
#include "indian.inc"

char *_3DS_ANIM_READER_VERSION="0.2b";

static PMotion *zemotion;
static PVWorld *zeworld;
static int CurrentID;
static unsigned CurrentType;
static PMNode *CurrentNode;

typedef unsigned char  byte;
typedef unsigned short word;
typedef unsigned long  dword;

#pragma pack(2)

typedef struct {
    word    id;
    dword   len;
} TChunkHeader, *PChunkHeader;

#pragma pack()

enum {
    CHUNK_MAIN      = 0x4D4D,
        CHUNK_KEYFRAMER = 0xB000,
                    CHUNK_AMBIENTKEY    = 0xB001,
                    CHUNK_TRACKINFO = 0xB002,
                        CHUNK_TRACKOBJNAME  = 0xB010,
                        CHUNK_TRACKPIVOT    = 0xB013,
                        CHUNK_TRACKPOS      = 0xB020,
                        CHUNK_TRACKROTATE   = 0xB021,
                        CHUNK_TRACKSCALE    = 0xB022,
                        CHUNK_OBJNUMBER     = 0xB030,
                    CHUNK_TRACKCAMERA = 0xB003,
                        CHUNK_TRACKFOV  = 0xB023,
                        CHUNK_TRACKROLL = 0xB024,
                    CHUNK_TRACKCAMTGT = 0xB004,
                    CHUNK_TRACKLIGHT  = 0xB005,
                    CHUNK_TRACKLIGTGT = 0xB006,
                    CHUNK_TRACKSPOTL  = 0xB007,
                    CHUNK_FRAMES    = 0xB008,
};

/////////////////////////////////////////////////////////////////////////
// Lecture 3ds
/////////////////////////////////////////////////////////////////////////

// Util pour tout le monde
static void ReadASCIIZ(FILE *f,char *name)
{
   char c[2];

   c[1]='\0';

     // Read ASCIIZ object name
   while ( (c[0] = fgetc(f)) != EOF && c[0] != '\0')
   {
       c[0]=toupper(c[0]);
       strcat(name,c);
   }
   debug(printf("%s\"\n",name););
}

// Forward declaration.
static int ChunkReader(FILE *f, long p);

static int SkipReader(FILE *f, long p) {
    return COOL;
}

// ------------------------------------ KeyFraming
static int FramesReader(FILE *f, long p) {
    dword c[2];
    int i;

    if (fread(&c, sizeof(c), 1, f) != 1) return BIZAR_ERROR;
    for(i=0;i<2;i++) c[i]=Indiani(c[i]);

    debug(printf("    Anim Start: %ld, End: %ld\n",c[0], c[1]););
    zemotion->MaxTime=c[1];
    return COOL;
}

static int TrackObjNameReader(FILE *f, long p) {
    int i;
    word w[2];
    word parent;
    char name[255]="\0";
    PMNode *n,*m;
    void *t;

    // Read ASCIIZ name
    debug(printf("Track object name \""););
    ReadASCIIZ(f, &name[0]);
    if (fread(&w, sizeof(w), 1, f) != 1) return BIZAR_ERROR;
    for(i=0;i<2;i++) w[i]=Indians(w[i]);

    if (fread(&parent, sizeof(parent), 1, f) != 1) return BIZAR_ERROR;
    parent=Indians(parent);
    debug(printf("Object name data: Flags 0x%X, 0x%X, Parent %d\n",w[0], w[1], parent););

    // Search mesh in the world
    debug(printf("Processing Node %s\n",name););

    switch(CurrentType)
    {
        case MESH:
            t=PV_GetMeshPtr(zeworld,name);
            debug(if(t!=NULL) printf("Linked with mesh %s from world\n",((PVMesh*)t)->Name););
            if(t==NULL) CurrentType=UNKNOW;
            break;
        case CAM_TARGET:
        case CAM_POS:
            t=(void*)PV_GetCurrentCam();
            debug(if(t!=NULL) printf("Linked with camera %s\n",((PVCam*)t)->Name););
            break;
        case LIGHT_TARGET:
        case LIGHT_POS:
            t=PV_GetLightPtr(zeworld,name);
            debug(if(t!=NULL) printf("Linked with light %s from world\n",((PVLight*)t)->Name););
            if(t==NULL) CurrentType=UNKNOW;
            break;
    }


    if((n=PM_CreateNode(CurrentID))==NULL) return NO_MEMORY;
    n->Type=CurrentType;
    n->Object=t;
    CurrentType=UNKNOW;

    // Add to the tree
    m=PM_GetNodePtrByID(zemotion->RootObj,parent==65535?-1:parent);
    if(m==NULL) return OBJ_ID_NOT_FOUND;
    PM_AddChild(m,n);

    CurrentNode=n;
    return COOL;
}

static int PivotPointReader(FILE *f, long p) {
    float pos[3];
    int i;

    if (fread(&pos, sizeof(pos), 1, f) != 1) return BIZAR_ERROR;
    for(i=0;i<3;i++) pos[i]=Indianf(pos[i]);

    debug(printf("  Pivot at X: %f, Y: %f, Z: %f\n",pos[0], pos[1], pos[2]););
    if(CurrentNode->Type==MESH)
    {
        ((PVMesh*)(CurrentNode->Object))->Pivot.xf+=pos[0];
        ((PVMesh*)(CurrentNode->Object))->Pivot.yf+=-pos[2];
        ((PVMesh*)(CurrentNode->Object))->Pivot.zf+=-pos[1];

        ((PVMesh*)(CurrentNode->Object))->Pivot.bf=((PVMesh*)(CurrentNode->Object))->Pivot.xf*((PVMesh*)(CurrentNode->Object))->Pivot.yf;

    }
    return COOL;
}

static void SplineFlagsReader(FILE *f, word flags) {
    int i;
    float dat;
/* Key info flags for position, rotation and scaling:
    Until I know the meaning of each bit in flags I assume all mean
    a following float data.
*/

    // NOTE THIS IS NOT A CHUNK, but A PART OF SEVERAL CHUNKS

    for (i = 0; i < 16; i++) {
        static const char *flagnames[] = {
            "Tension",
            "Continuity",
            "Bias",
            "Ease To",
            "Ease From",
        };
        if (flags & (1 << i)) {
            if (fread(&dat, sizeof(dat), 1, f) != 1) return;
            dat=Indianf(dat);
            if (i < sizeof(flagnames)/sizeof(*flagnames))
                printf("             %-15s = %f\n",flagnames[i], dat);
            else
                printf("             %-15s = %f\n","Unknown", dat);
        }
    }
}

static int TrackReader(FILE *f, long p) {
    debug(printf("