>.lwo c’est indispensable
Bon voilà ce que j’ai sur LWO : je fais mon père Noël…
(implémenter ReOrderBytes si on passe sur AROS x86)
Alain
/*==========================================================================*/
#define SKIPBYTES(n) L.pt=L.pt+n;
/*==========================================================================*/
void GetNameLWO(UBYTE *name)
{
LONG n;
strcpy(name,L.pt);
n=strlen(name)+1;
if(n AND 1) n++;
SKIPBYTES(n);
}
/*==========================================================================*/
void GetNameC4D(UBYTE *name)
{
LONG size,n;
size=L.pt[0];
NLOOP(size)
name[n]=L.pt[n+1];
name=0;
n=size+1;
if(n AND 1) n++;
SKIPBYTES(n);
}
/*==========================================================================*/
BYTE GetByte()
{
BYTE *pt;
pt=(BYTE *)L.pt;
SKIPBYTES(1);
return(*pt);
}
/*==========================================================================*/
WORD GetWord()
{
WORD *pt;
pt=(WORD *)L.pt;
ReOrderBytes(L.pt,2,0,1,1);
SKIPBYTES(2);
return(*pt);
}
/*==========================================================================*/
LONG GetLong()
{
LONG *pt;
pt=(LONG *)L.pt;
ReOrderBytes(L.pt,4,0,1,1);
SKIPBYTES(4);
return(*pt);
}
/*==========================================================================*/
float GetFloat()
{
float *fpt;
LONG *pt;
pt=(LONG *)L.pt;
ReOrderBytes(L.pt,4,0,1,1);
fpt=(float *)pt;
SKIPBYTES(4);
return(*fpt);
}
/*==========================================================================*/
void GetVector(float *f)
{
UBYTE n;
NLOOP(3)
f[n]=GetFloat();
}
/*==========================================================================*/
void GetID(UBYTE *ID)
{
ID[0]=L.pt[0];
ID[1]=L.pt[1];
ID[2]=L.pt[2];
ID[3]=L.pt[3];
ID[4]=0;
L.pt=L.pt+4;
}
/*==========================================================================*/
WBOOL LoadNextChunck(FILE *fp)
{
LONG size;
/* REM(LoadNextChunck) */
size=fread(&ChunckHeader,4*2,1,fp);
if(size==0) {REM(cant load ChunckHeader!!!);return(FALSE);}
L.pt =&ChunckHeader;
GetID(&ChunckID);
ChunckSize=GetLong();
if(ChunckSize AND 1) ChunckSize++; /* IFF spec: pad byte if odd chunk length*/
ChunckBuffer=MYmalloc(ChunckSize, »ChunckBuffer »);
if(ChunckBuffer==NULL) return(FALSE);
REMP(« IFF CHUNCK [%s] %d bytes ==================n »,ChunckID,ChunckSize);
size=fread(ChunckBuffer,ChunckSize,1,fp);
if(size==0) {REM(cant load ChunckBuffer!!!);return(FALSE);}
L.pt=ChunckBuffer;
DumpMemHex(L.pt,80);
ChunckBufferEnd=ChunckBuffer+ChunckSize;
return(TRUE);
}
/*==========================================================================*/
void LoadLWO()
{
FILE *fp=NULL;
LONG PInb,Fnb,Fnum,Tnum,Onb,Vnb,Inum,Onum,m,n,i,UVi,MAnb;
struct object3D *O;
struct texture3D *T;
struct objectTMP *OT;
struct faceTMP *FT;
LONG *UVI;
WORD level;
float x,y,z,u,v;
UBYTE *datas;
struct uv3D *UV;
struct material3D *MA;
UBYTE name[256];
LONG size;
LONG color;
UBYTE *RGBA;
REM(loadLWO)
Engine.FileByteOrder=’M’;
if(L.VersionFormat==0) return;
/*
*/
while (GetHeaderIFF()==TRUE)
{
/*
*/
IFCHUNCK(LAYR) /* object chunck */
{
SKIPBYTES(2+2);
x=GetFloat();
y=GetFloat();
z=GetFloat();
level=0;
GetNameLWO(&name);
if ((ChunckSize-16-strlen(name)-1) >= 2)
{
Onum=GetWord(); /* still a parent object in chunck*/
if(Onum!=-1)
{ OT=GET(&Engine.PAT.OT,Onum); level=OT->FR.level+1; }
}
Onum=AddObjectTmp(name,level);
OT=GET(&Engine.PAT.OT,Onum);
}
/*
*/
IFCHUNCK(BBOX)
{
GetVector((float *)&OT->min.x);
GetVector((float *)&OT->max.x);
}
/*
*/
IFCHUNCK(PNTS)
{
Onb=GETNB(&Engine.PAT.OT);
if(Onb==0)
{
strcpy(name,L.filename);
name[strlen(name) – 4]=0; /* cut .lwo */
Onum=AddObjectTmp(name,0);
OT=GET(&Engine.PAT.OT,Onum);
}
Vnb=ChunckSize/12;
VOIR(Vnb)
NLOOP(Vnb)
{
x=GetFloat();
y=GetFloat();
z=GetFloat();
u=0.0;
v=0.0;
AddV(x,y,z);
AddUV(u,v); /* define also an UV mapping per point */
}
GO
}
/*
*/
if(L.VersionFormat==1)
IFCHUNCK(POLS)
{
REM(Faces – L.VersionFormat 1.0)
while(L.ptVnb))
AddVIUVI(i,i); /* use also fake UV */
}
Tnum=GetWord();
if(Tnum<0) {Tnum=-Tnum; Fnb=GetWord();}
FT=LAST(&Engine.PAT.FT);
FT->Tnum=Tnum-1;
VOIR(FT->Tnum)
}
}
/*
*/
if(L.VersionFormat==6)
IFCHUNCK(POLS)
IFSUBCHUNCK(FACE) /* faces */
{
REM(Faces – L.VersionFormat 6.0)
while(L.pt
*/
IFCHUNCK(SRFS)
{
REM(Surfaces names…)
while(L.pt
*/
IFCHUNCK(SURF)
{
REM(Materials…)
MAnb=GETNB(&Engine.PAV.MA);
MA=NEW(&Engine.PAV.MA);
GetNameLWO(MA->name);
REMP(« MATERIAL[%d] <%s>n »,MAnb,MA->name);
while(L.ptbase.RGBA[0]=GetByte();
MA->base.RGBA[1]=GetByte();
MA->base.RGBA[2]=GetByte();
MA->base.RGBA[3]=GetByte();
Tnum=GETNB(&Engine.PAV.T);
T=NEW(&Engine.PAV.T);
InitializeT(T, » »,2,2,32,MA->name);
RGBA=T->pt;
MLOOP(2*2)
{
RGBA[0]=m+MA->base.RGBA[0];
RGBA[1]=m+MA->base.RGBA[1];
RGBA[2]=m+MA->base.RGBA[2];
RGBA[3]=255;
RGBA=&(RGBA[4]);
}
}
IFSUBCHUNCK(FLAG)
MA->MaterialMode =GetWord();
IFSUBCHUNCK(LUMI)
MA->luminosity.value =1.0/256.0*(float)GetWord();
IFSUBCHUNCK(DIFF)
MA->diffuse.value =1.0/256.0*(float)GetWord();
IFSUBCHUNCK(SPEC)
MA->specular.value =1.0/256.0*(float)GetWord();
IFSUBCHUNCK(REFL)
MA->reflection.value =1.0/256.0*(float)GetWord();
IFSUBCHUNCK(TRAN)
MA->transparency.value =1.0/256.0*(float)GetWord();
IFSUBCHUNCK(VLUM)
MA->luminosity.value =GetFloat();
IFSUBCHUNCK(VDIF)
MA->diffuse.value =GetFloat();
IFSUBCHUNCK(VSPC)
MA->specular.value =GetFloat();
IFSUBCHUNCK(VRFL)
MA->reflection.value =GetFloat();
IFSUBCHUNCK(VTRN)
MA->transparency.value =GetFloat();
IFSUBCHUNCK(3DOS)
MA->glossiness.value =1.0/1024.0*(float)GetWord();
}
GO
}
/*
*/
IFCHUNCK(PTAG)
IFSUBCHUNCK(SURF)
{
REM(Texture per face…)
SKIPBYTES(4);
Fnb=(ChunckSize-4)/4;
NLOOP(Fnb)
{
Fnum=GetWord();
Tnum=GetWord();
FT=(struct faceTMP *)OT->FT;
FT[Fnum].Tnum=Tnum-1;
}
}
/*
*/
IFCHUNCK(VMAP)
IFSUBCHUNCK(TXUV)
{
REM(UV texturing…)
SKIPBYTES(4);
n=GetWord(); /*dimension=2*/
GetNameLWO(name);
SKIPBYTES(2);
Vnb=(ChunckSize -4 -2 -n)/10;
VOIR(Vnb)
NLOOP(Vnb)
{
i=GetWord();
u =GetFloat();
v =GetFloat();
if (u < 0.0) u=0.0; if (1.0 <= u) u=0.9999;
if (v < 0.0) v=0.0; if (1.0 <= v) v=0.9999;
UV=OT->UV;
UV.u=u;
UV.v=v;
SKIPBYTES(10);
}
}
/*
*/
IFCHUNCK(VMAD)
IFSUBCHUNCK(TXUV)
{
REM(UV texturing…)
SKIPBYTES(4);
n=GetWord(); /*dimension=2*/
GetNameLWO(name);
SKIPBYTES(2);
Vnb=(ChunckSize -4 -2 -n)/12;
VOIR(Vnb)
NLOOP(Vnb)
{
i =GetWord();
Fnum =GetWord();
u =GetFloat();
v =GetFloat();
AddUV(u,v); /* define also a new UV mapping per face/point */
UVi=OT->UVnb;
FT=(struct faceTMP *)OT->FT;
UVI=FT[Fnum].UVI;
UVI=UVi; /* index on this new UV value */
SKIPBYTES(12);
}
}
/*
*/
}
Fnum=GETNB(&Engine.PAT.FT);
if(Fnum==0)
{
AddFaceTmp(0);
NLOOP(OT->Pnb)
AddVIUVI(n,n); /* use also fake UV */
}
}
/*==========================================================================*/
