IFFRESULT IFFParser::IFFDescendChunk(IFFCHUNK* lpck)
{
lpck->flags = 0; // Read
ULONG len = IFFReadChunkBytes(lpck, IFFCHUNKSIZE);
if (len == 0)
return IFF_EOF;
else if (len != IFFCHUNKSIZE)
return IFFERR_READWRITE;
lpck->ckID = BigEndian32(lpck->ckID);
lpck->ckSize = BigEndian32(lpck->ckSize);
lpck->dataOffset = SetFilePos(0, IO::STREAM_SEEK_CUR);
lpck->grpID = 0;
if (lpck->ckID == ID_FORM)
{
if (IFFReadChunkBytes(&lpck->grpID, sizeof(ID)) != sizeof(ID))
return IFFERR_READWRITE;
lpck->grpID = BigEndian32(lpck->grpID);
return IFF_EOC;
}
return IFF_OK;
}
static Att_List *do_read_sites_iff(struct opusftp_globals *og,char *filename,LONG *diskerr)
{
APTR iff;
BOOL err=FALSE;
Att_List *list;
D(bug("read sites\n"));
if (!(list=Att_NewList(LISTF_POOL)))
return(NULL);
// Open IFF file
if ((iff=IFFOpen(filename,IFF_READ,ID_OPUS)))
{
struct site_entry *e;
ULONG chunk;
while (!err && (chunk=IFFNextChunk(iff,0)))
{
if ((e=AllocVec(sizeof(struct site_entry),MEMF_CLEAR)))
{
int size;
int chunksize = 0;
if (chunk==ID_FTPSITE_SHORT)
size=SMALL_SIZE;
else if (chunk==ID_FTPSITE_LONG)
size=LARGE_SIZE;
else
{
*diskerr=212;
err=TRUE;
FreeVec(e);
break;
}
// Adjustment for changed ListFormat size
chunksize = (int)IFFChunkSize(iff);
if ((chunksize < size) && (size - chunksize == 84))
{
if (!(err=(chunksize!=IFFReadChunkBytes(iff,(char *)e,chunksize))));
{
char patterns[82] = {'\0'};
int i = 0;
CopyMem(e->se_listformat.show_pattern_p, patterns, 80);
memset(e->se_listformat.show_pattern_p, 0, 160);
for (i = 0; i < 40; i++)
{
e->se_listformat.show_pattern_p[i] = patterns[i];
e->se_listformat.hide_pattern_p[i] = patterns[i+40];
}
}
}
else
err=(size!=IFFReadChunkBytes(iff,(char *)e,size));
if (!err)
{
#ifdef __AROS__
e->se_anon = AROS_BE2WORD(e->se_anon);
e->se_port = AROS_BE2LONG(e->se_port);
e->se_has_custom_env = AROS_BE2WORD(e->se_has_custom_env);
if (size == LARGE_SIZE)
{
e->se_env_private.e_retry_count = AROS_BE2LONG(e->se_env_private.e_retry_count);
e->se_env_private.e_retry_delay = AROS_BE2LONG(e->se_env_private.e_retry_delay);
e->se_env_private.e_list_update = AROS_BE2LONG(e->se_env_private.e_list_update);
e->se_env_private.e_timeout = AROS_BE2LONG(e->se_env_private.e_timeout);
e->se_env_private.e_script_time = AROS_BE2LONG(e->se_env_private.e_script_time);
e->se_env_private.e_indexsize = AROS_BE2LONG(e->se_env_private.e_indexsize);
e->se_env_private.bitfield1 = AROS_BE2LONG(e->se_env_private.bitfield1);
e->se_env_private.bitfield2 = AROS_BE2LONG(e->se_env_private.bitfield2);
}
#endif
// adjust ptrs for environment
// if custom env then set ptr to internal private copy
// else set it to point to global ftp default
if (e->se_has_custom_env)
e->se_env=&e->se_env_private;
else
e->se_env=&og->og_oc.oc_env;
Att_NewNode(list, e->se_name ,(ULONG)e ,0 );
}
else
FreeVec(e);
}
else
err=TRUE;
}
// Close file
IFFClose(iff);
if (!err)
return(list);
}
Att_RemList(list,REMLIST_FREEDATA);
if (!*diskerr)
*diskerr=IoErr();
return(NULL);
}
static struct ftp_config *do_read_options_iff(char *filename,int opt_type,LONG *diskerr)
{
APTR iff;
BOOL ok=FALSE;
struct ftp_config *conf;
LONG chunk;
D(bug("read options\n"));
if ((conf=AllocVec(sizeof(struct ftp_config),MEMF_CLEAR)))
{
// Open IFF file
if ((iff=IFFOpen(filename,IFF_READ,ID_OPUS)))
{
chunk=IFFNextChunk(iff,0);
if (opt_type==WT_OPT && chunk!=ID_ENV)
*diskerr=212;
else
{
// Adjustment for changed ListFormat size
int chunksize = (int)IFFChunkSize(iff);
int size = sizeof(struct ftp_config);
if (chunk==ID_OPTIONS)
{
if ((chunksize < size) && (size - chunksize == 84))
{
if ((ok = (chunksize==IFFReadChunkBytes(iff,(char *)conf,chunksize))));
{
char patterns[82] = {'\0'};
int i = 0;
CopyMem(conf->oc_env.e_listformat.show_pattern_p, patterns, 80);
memset(conf->oc_env.e_listformat.show_pattern_p, 0, 160);
for (i = 0; i < 40; i++)
{
conf->oc_env.e_listformat.show_pattern_p[i] = patterns[i];
conf->oc_env.e_listformat.hide_pattern_p[i] = patterns[i+40];
}
}
}
else
ok = ((sizeof(struct ftp_config))==IFFReadChunkBytes(iff,(char *)conf,sizeof(struct ftp_config)));
}
else if (chunk==ID_ENV)
{
ok=((sizeof(struct ftp_environment))==IFFReadChunkBytes(iff,(char *)&conf->oc_env,sizeof(struct ftp_environment)));
}
else
*diskerr=212;
}
// Close file
IFFClose(iff);
if (ok)
{
#ifdef __AROS__
conf->bitfield1 = AROS_LONG2BE(conf->bitfield1);
conf->oc_env.e_retry_count = AROS_BE2LONG(conf->oc_env.e_retry_count);
conf->oc_env.e_retry_delay = AROS_BE2LONG(conf->oc_env.e_retry_delay);
conf->oc_env.e_list_update = AROS_BE2LONG(conf->oc_env.e_list_update);
conf->oc_env.e_timeout = AROS_BE2LONG(conf->oc_env.e_timeout);
conf->oc_env.e_script_time = AROS_BE2LONG(conf->oc_env.e_script_time);
conf->oc_env.e_indexsize = AROS_BE2LONG(conf->oc_env.e_indexsize);
conf->oc_env.bitfield1 = AROS_BE2LONG(conf->oc_env.bitfield1);
conf->oc_env.bitfield2 = AROS_BE2LONG(conf->oc_env.bitfield2);
#endif
return(conf);
}
}
FreeVec(conf);
}
if (!*diskerr)
*diskerr=IoErr();
return(NULL);
}
// Get backdrop pattern
short display_get_pattern(BOOL use_custom)
{
APTR iff;
BPTR file;
struct WBPatternPrefs pattern[NUM_PATTERNS];
short a;
char *data[NUM_PATTERNS],*filename;
short change=0;
ULONG flags=0;
// Copy from system fields to custom fields (if custom field is empty, or custom flag is not set)
for (a=0;a<4;a++)
{
if (!GUI->env_BackgroundPic[a][0] || !use_custom)
{
strcpy(GUI->env_BackgroundPic[a],environment->env->env_BackgroundPic[a]);
GUI->env_BackgroundFlags[a]=environment->env->env_BackgroundFlags[a];
GUI->env_BackgroundBorderColour[a]=environment->env->env_BackgroundBorderColour[a];
}
}
// Pattern disabled?
if (environment->env->display_options&DISPOPTF_NO_BACKDROP)
{
// Check both patterns are invalid
for (a=0;a<NUM_PATTERNS;a++)
{
// Is pattern valid?
if (GUI->pattern[a].valid)
{
// Clear existing pattern
display_update_pattern(a,0);
// Free pattern data
FreeVec(GUI->pattern[a].data);
GUI->pattern[a].data=0;
// Free pattern
FreePattern(&GUI->pattern[a]);
}
}
return 0;
}
// Use pattern prefs?
if (environment->env->display_options&DISPOPTF_USE_WBPATTERN)
{
// End pattern notification
stop_file_notify(GUI->pattern_notify);
// Get filename
filename=(IntuitionBase->LibNode.lib_Version<39)?"env:sys/wb.pat":"env:sys/wbpattern.prefs";
// User-specified file?
if (environment->env->backdrop_prefs[0])
{
BPTR lock;
// Does file exist?
if (lock=Lock(environment->env->backdrop_prefs,ACCESS_READ))
{
// Yep
UnLock(lock);
filename=environment->env->backdrop_prefs;
}
}
// Initialise pattern and data pointers
for (a=0;a<NUM_PATTERNS;a++)
{
pattern[a]=GUI->pattern[a].prefs;
data[a]=0;
}
// Try to open wbpattern prefs file
if (IntuitionBase->LibNode.lib_Version>=39 &&
(iff=IFFOpen(filename,IFF_READ,ID_PREF)))
{
ULONG id;
// Scan for chunks we know and love
while (id=IFFNextChunk(iff,0))
{
// FastIPrefs FIP0 chunk?
if (id==ID_FIP0)
{
// Get flags
IFFReadChunkBytes(iff,&flags,sizeof(flags));
}
// PTRN chunk?
else
if (id==ID_PTRN)
{
struct WBPatternPrefs *prefs;
// Allocate space for chunk
if (prefs=AllocVec(IFFChunkSize(iff),MEMF_CLEAR))
{
// Read chunk
IFFReadChunkBytes(iff,prefs,-1);
// Pattern we can handle?
if (prefs->wbp_Which==WBP_ROOT ||
prefs->wbp_Which==WBP_DRAWER)
{
// Copy data
CopyMem(
(char *)prefs,
(char *)&pattern[prefs->wbp_Which],
sizeof(struct WBPatternPrefs));
// Allocate pattern data
if (prefs->wbp_DataLength>0 &&
(data[prefs->wbp_Which]=AllocVec(prefs->wbp_DataLength+1,MEMF_CLEAR)))
{
// Copy pattern data
CopyMem((char *)(prefs+1),data[prefs->wbp_Which],prefs->wbp_DataLength);
}
}
// Free chunk
FreeVec(prefs);
}
}
}
// Close iff file
IFFClose(iff);
}
// Couldn't find it, try for wb.pat
else
if (IntuitionBase->LibNode.lib_Version<39 &&
(file=Open(filename,MODE_OLDFILE)))
{
// Allocate pattern data
if (data[PATTERN_MAIN]=AllocVec(96,MEMF_CLEAR))
{
// Skip forwards
Seek(file,20,OFFSET_CURRENT);
// Read pattern
if ((Read(file,data[PATTERN_MAIN],96))<96)
{
FreeVec(data[PATTERN_MAIN]);
data[PATTERN_MAIN]=0;
}
// Fill out WBPatternPrefs
else
{
pattern[PATTERN_MAIN].wbp_Flags=WBPF_PATTERN;
pattern[PATTERN_MAIN].wbp_Depth=GUI->screen_pointer->BitMap.Depth;
if (pattern[PATTERN_MAIN].wbp_Depth>MAXDEPTH)
pattern[PATTERN_MAIN].wbp_Depth=MAXDEPTH;
}
}
// Close file
Close(file);
}
// Start notification of wbpattern prefs
GUI->pattern_notify=start_file_notify(filename,NOTIFY_PATTERN_CHANGED,GUI->appmsg_port);
}
// Otherwise, under 39 user-defined pictures
else
if (GfxBase->LibNode.lib_Version>=39)
{
short pat;
// Do both patterns
for (pat=0;pat<NUM_PATTERNS;pat++)
{
// Got valid picture?
if (GUI->env_BackgroundPic[pat][0])
{
// Fill out WBPatternPrefs
pattern[pat].wbp_Flags=0;
pattern[pat].wbp_Which=pat;
pattern[pat].wbp_DataLength=strlen(GUI->env_BackgroundPic[pat]);
if (data[pat]=AllocVec(pattern[pat].wbp_DataLength+1,0))
strcpy(data[pat],GUI->env_BackgroundPic[pat]);
}
// Set to no pattern
else
{
// Fill out WBPatternPrefs
pattern[pat].wbp_Flags=WBPF_PATTERN;
pattern[pat].wbp_DataLength=0;
data[pat]=0;
}
}
}
// Otherwise, default to no pattern
else
{
short pat;
// Do both patterns
for (pat=0;pat<NUM_PATTERNS;pat++)
{
// Fill out WBPatternPrefs
pattern[pat].wbp_Flags=WBPF_PATTERN;
pattern[pat].wbp_DataLength=0;
data[pat]=0;
}
}
// Go through both patterns
for (a=0;a<NUM_PATTERNS;a++)
{
BOOL diff=0;
short precision=0;
// Using Opus settings?
if (!(environment->env->display_options&DISPOPTF_USE_WBPATTERN))
{
// Get precision
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_NONE)
precision=-1;
else
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_GUI)
precision=2;
else
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_ICON)
precision=1;
else
if (GUI->env_BackgroundFlags[a]&ENVBF_PRECISION_EXACT)
precision=3;
}
// Maybe set in prefs
else
{
// Get precision
precision=(a==0)?PATF_WB_MODE(flags):PATF_LISTER_MODE(flags);
}
// Valid data?
if (data[a])
{
// No last pattern?
if (!GUI->pattern[a].data)
{
diff=1;
}
// Changed from pattern to picture or vice versa?
else
if ((pattern[a].wbp_Flags&WBPF_PATTERN && !(GUI->pattern[a].prefs.wbp_Flags&WBPF_PATTERN)) ||
(!(pattern[a].wbp_Flags&WBPF_PATTERN) && GUI->pattern[a].prefs.wbp_Flags&WBPF_PATTERN))
{
diff=1;
}
// Pattern pattern?
else
if (pattern[a].wbp_Flags&WBPF_PATTERN)
{
// Different depth?
if (pattern[a].wbp_Depth!=GUI->pattern[a].prefs.wbp_Depth) diff=1;
// Has data changed from the last one?
else
{
short num,d;
// Get amount of data
num=PAT_HEIGHT*pattern[a].wbp_Depth;
// Compare data
for (d=0;d<num;d++)
{
if (((USHORT *)data[a])[d]!=((USHORT *)GUI->pattern[a].data)[d])
{
diff=1;
break;
}
}
}
}
// Picture?
else
{
// Different name for picture, or it's random?
if (strcmp(data[a],GUI->pattern[a].data)!=0 || GUI->pattern[a].random)
{
diff=1;
}
// Precision changed?
else
if (precision!=GUI->pattern[a].precision)
{
diff=1;
}
// Stretching changed?
else
if (a==0 &&
((GUI->env_BackgroundFlags[a]&ENVBF_STRETCH_PIC && !(GUI->pattern[a].flags&PATF_STRETCH)) ||
!(GUI->env_BackgroundFlags[a]&ENVBF_STRETCH_PIC) && (GUI->pattern[a].flags&PATF_STRETCH)))
{
diff=1;
}
// Centering changed?
else
if ((GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC && !(GUI->pattern[a].flags&PATF_CENTER)) ||
!(GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC) && (GUI->pattern[a].flags&PATF_CENTER))
{
diff=2;
}
}
}
// Had last data?
else
if (GUI->pattern[a].data) diff=1;
if (diff!=1)
{
// Border pen changed?
if ((GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR && GUI->pattern[a].border_pen==0) ||
(!(GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR) && GUI->pattern[a].border_pen!=0))
{
diff=3;
}
else
if (GUI->pattern[a].border_pen!=0 && GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR)
{
ULONG col[3];
GetPalette32(
&GUI->screen_pointer->ViewPort,
col,
1,
(GUI->pattern[a].border_pen==-1)?0:GUI->pattern[a].border_pen);
if (ENVBF_COL_R_GET(col[0])!=ENVBF_COL_R_GET(GUI->env_BackgroundBorderColour[a]) ||
ENVBF_COL_R_GET(col[1])!=ENVBF_COL_G_GET(GUI->env_BackgroundBorderColour[a]) ||
ENVBF_COL_R_GET(col[2])!=ENVBF_COL_B_GET(GUI->env_BackgroundBorderColour[a]))
{
diff=3;
}
}
}
// Has it changed?
if (diff)
{
// Existing pattern valid?
if (GUI->pattern[a].valid)
{
// Clear existing patterns
display_update_pattern(a,0);
}
// Change more than centering?
if (diff==1)
{
// Free existing pattern
FreePattern(&GUI->pattern[a]);
FreeVec(GUI->pattern[a].data);
// Copy pattern and data pointer
GUI->pattern[a].prefs=pattern[a];
GUI->pattern[a].data=data[a];
// Stretch?
if (a==0 && GUI->env_BackgroundFlags[a]&ENVBF_STRETCH_PIC)
{
flags|=PATF_STRETCH;
flags&=~PATF_CENTER;
}
else
{
flags&=~PATF_STRETCH;
if (!(environment->env->display_options&DISPOPTF_USE_WBPATTERN) &&
GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC)
flags|=PATF_CENTER;
else
flags&=~PATF_CENTER;
}
// Set flags and precision
GUI->pattern[a].flags=flags;
GUI->pattern[a].precision=precision;
// Initialise pattern
GetPattern(
&GUI->pattern[a],
GUI->screen_pointer,
GUI->env_BackgroundBorderColour[a]|(GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR));
}
// Change colour
else
if (diff==3)
{
// Initialise pattern colour
GetPatternBorder(
&GUI->pattern[a],
GUI->screen_pointer,
GUI->env_BackgroundBorderColour[a]|(GUI->env_BackgroundFlags[a]&ENVBF_USE_COLOUR));
}
// Centering changed
else
{
// Environment flags set for centering?
if (!(environment->env->display_options&DISPOPTF_USE_WBPATTERN) &&
GUI->env_BackgroundFlags[a]&ENVBF_CENTER_PIC)
GUI->pattern[a].flags|=PATF_CENTER;
else
GUI->pattern[a].flags&=~PATF_CENTER;
}
// Install new pattern
display_update_pattern(a,1);
}
// If not, free data
else FreeVec(data[a]);
}
return change;
}
HRESULT CLWOLoader::LoadLWOB(IStream* pStream, ILMFNode* children)
{
IFFRESULT iffresult;
#if 0
char filename[256];
_splitpath(pStream->GetFileName(), NULL, NULL, filename, NULL);
#endif
IFFCHUNK ck;
/*
CModel* pModel = new CModel;
pModel->type = OBJT_POLYGON;
MMLayerRef layerRef = NULL;
filterrec->layer->AddLayerTags(parentRef, NULL, 'SLER', 'OB3D', NULL,
(LAYER_Name), filename,
(LAYER_UserData), pModel,
(TAG_DONE));
if (!layerRef) return NULL;
*/
/*
CI3DLayer* pModel = (CI3DLayer*)sBasic->CreateCmdTarget("3DLAYER");
ASSERT(pModel);
if (!pModel) return NULL;
pModel->SetType(OBJT_POLYGON);
pModel->SetName(filename);
pModel->AddLayerParams();
parentRef->InsertObject(pModel, NULL);
*/
float (*m_points)[3] = NULL;
while ((iffresult = IFFDescendChunk(pStream, &ck)) == IFF_OK)
{
switch (ck.ckID)
{
case ID_PNTS:
{
ATLTRACE("PNTS\n");
int numpoints = ck.ckSize / 12; // 4*3 = 12
m_points = new float[numpoints][3];
#if 0
pModel->SetVertexDataSize(numpoints);
evec3* data = pModel->GetVertexData();
#endif
for (int i = 0; i < numpoints; i++)
{
DWORD v[3];
IFFReadChunkBytes(pStream, v, 12);
float vf[3];
*((DWORD*)&vf[0]) = ENDIANLONG(v[0]);
*((DWORD*)&vf[1]) = ENDIANLONG(v[1]);
*((DWORD*)&vf[2]) = ENDIANLONG(v[2]);
m_points[i][0] = vf[0];
m_points[i][1] = vf[1];
m_points[i][2] = vf[2];
// data[i].v[0] = vf[0];
// data[i].v[1] = vf[1];
// data[i].v[2] = vf[2];
}
}
break;
case ID_POLS:
{
ATLTRACE("POLS\n");
long size = ck.ckSize;
// Read all polygons
while (size > 0)
{
CComPtr<ILX3DNode> node;
m_scene->createNode(L"IndexedFaceSet", &node);
CComPtr<ILCoordinate> coordinateNode;
m_scene->createNode(L"Coordinate", (ILX3DNode**)&coordinateNode);
CComPtr<ILMFVec3f> pointField;
coordinateNode->getField(L"point", (ILX3DField**)&pointField);
CComPtr<ILSFNode> coordField;
node->getField(L"coord", (ILX3DField**)&coordField);
coordField->setValue(coordinateNode);
CComPtr<ILMFInt32> coordIndexField;
node->getField(L"coordIndex", (ILX3DField**)&coordIndexField);
WORD numvertices;
IFFReadChunkBytes(pStream, &numvertices, 2);
numvertices = ENDIANWORD(numvertices);
size -= 2;
//int* polydata = pModel->AddPoly(numvertices);
// Read all vertices of polygon
for (int j = 0; j < numvertices; j++)
{
UWORD vertex;
IFFReadChunkBytes(pStream, &vertex, 2);
vertex = ENDIANWORD(vertex);
size -= 2;
//polydata[j] = vertex;
pointField->append1Value(m_points[vertex]);
coordIndexField->append1Value(j);
}
// Surface properties of polygon
SHORT surface;
IFFReadChunkBytes(pStream, &surface, 2);
surface = ENDIANWORD(surface);
size -= 2;
if (surface < 0) // This polygon has detail polygons
{
MessageBox(NULL, "Detail polygons unsupported", "", MB_OK);
iffresult = -1;
break;
}
children->append1Value(node);
}
}
break;
case ID_SURF:
{
LPBYTE ckdata = (LPBYTE)GlobalAlloc(0, ck.ckSize);
IFFReadChunkBytes(pStream, ckdata, ck.ckSize);
//ParseSURF(pStream, ckdata, ck.ckSize);
GlobalFree(ckdata);
}
break;
default:
ATLTRACE("%4.4s\n", &ck.ckID);
}
if (iffresult < 0) break;
iffresult = IFFAscendChunk(pStream, &ck);
}
//pModel->BuildEdges();
return S_OK;//pModel;
}
ILX3DNode* CTDDDLoader::ParseDESC(IStream* pStream, ILMFNode* parentChildren)
{
/*
ProjectSuite* sPrj;
filterrec->basic->AcquireSuite(MMSX_Project_SuiteName, MMSX_Project_SuiteVersion, (void**)&sPrj);
ASSERT(sPrj);
*/
IFFRESULT iffresult;
IFFCHUNK ck;
/*
CModel* pModel = new CModel;
pModel->type = OBJT_POLYGON;
MMLayerRef layerRef = NULL;
filterrec->layer->AddLayerTags(parentLayer, NULL, 'SLER', 'OB3D', NULL,
(LAYER_UserData), pModel,
(TAG_DONE));
if (!layerRef) return NULL;
*/
#if 0
CI3DLayer* pModel = (CI3DLayer*)sBasic->CreateCmdTarget("3DLAYER");
ASSERT(pModel);
if (!pModel) return NULL;
pModel->SetType(OBJT_POLYGON);
pModel->AddLayerParams();
parentLayer->InsertObject(pModel, NULL);
#endif
CComPtr<ILShape> shapeNode;
m_scene->createNode(L"Shape", (ILX3DNode**)&shapeNode);
CComPtr<ILAppearance> appearanceNode;
m_scene->createNode(L"Appearance", (ILX3DNode**)&appearanceNode);
shapeNode->setAppearance(appearanceNode);
CComPtr<ILMaterial> materialNode;
m_scene->createNode(L"Material", (ILX3DNode**)&materialNode);
CComPtr<ILSFNode> materialField;
appearanceNode->getField(L"material", (ILX3DField**)&materialField);
materialField->setValue(materialNode);
CComPtr<ILX3DGeometryNode> geometryNode; // Not yet known what type of geometry
edge* edges = NULL;
float fposi[3] = {0, 0, 0};
do
{
IFFDescendChunk(pStream, &ck);
switch (ck.ckID)
{
case ID_NAME:
{
ATLASSERT(ck.ckSize == 18);
char name[19] = {0};
IFFReadChunkBytes(pStream, name, 18);
#if 0
pModel->SetName(name);
#endif
}
break;
case ID_SHAP:
{
ATLASSERT(ck.ckSize == 4);
WORD shape, lamp;
IFFReadChunkBytes(pStream, &shape, 2);
IFFReadChunkBytes(pStream, &lamp, 2);
shape = ENDIANWORD(shape);
lamp = ENDIANWORD(lamp);
if (shape == 0)
{
MessageBox(NULL, "Sphere", "", MB_OK);
}
else if (shape == 2)
{
MessageBox(NULL, "Axis", "", MB_OK);
}
else if (shape == 5)
{
MessageBox(NULL, "Ground", "", MB_OK);
}
else
{
ATLASSERT(0);
iffresult = -1;
}
}
break;
case ID_POSI:
{
ATLASSERT(ck.ckSize == sizeof(VECTOR));
VECTOR posi;
IFFReadChunkBytes(pStream, &posi, sizeof(VECTOR));
posi.X = ENDIANLONG(posi.X);
posi.Y = ENDIANLONG(posi.Y);
posi.Z = ENDIANLONG(posi.Z);
fposi[0] = posi.X/65536.0;
fposi[1] = posi.Y/65536.0;
fposi[2] = posi.Z/65536.0;
MessageBeep(-1); // TODO
#if 0
pModel->FindParam('posi', 0)->SetParamTags(
(PARAM_VECTOR_Value), fposi,
(TAG_DONE));
#endif
}
break;
/*
case ID_AXIS:
{
}
break;
*/
case ID_PNTS:
case ID_PNT2:
{
ATLASSERT(geometryNode == NULL);
m_scene->createNode(L"IndexedFaceSet", (ILX3DNode**)&geometryNode);
DWORD pcount = 0;
if (ck.ckID == ID_PNTS)
{
UWORD pcountw;
IFFReadChunkBytes(pStream, &pcountw, sizeof(UWORD));
pcount = ENDIANWORD(pcountw);
ATLASSERT(ck.ckSize == (2 + pcount*sizeof(VECTOR)));
}
else
{
DWORD pcountl;
IFFReadChunkBytes(pStream, &pcountl, sizeof(DWORD));
pcount = ENDIANLONG(pcountl);
ATLASSERT(ck.ckSize == (4 + pcount*sizeof(VECTOR)));
}
#if 0
pModel->SetVertexDataSize(pcount);
evec3* data = pModel->GetVertexData();
#endif
CComPtr<ILCoordinate> coordinateNode;
m_scene->createNode(L"Coordinate", (ILX3DNode**)&coordinateNode);
CComPtr<ILMFVec3f> pointField;
coordinateNode->getField(L"point", (ILX3DField**)&pointField);
CComPtr<ILSFNode> coordField;
geometryNode->getField(L"coord", (ILX3DField**)&coordField);
coordField->setValue(coordinateNode);
VECTOR* buf = (VECTOR*)malloc(sizeof(VECTOR)*pcount);
if (buf)
{
IFFReadChunkBytes(pStream, buf, sizeof(VECTOR)*pcount);
for (int i = 0; i < pcount; i++)
{
VECTOR* pnt = &buf[i];
pnt->X = ENDIANLONG(pnt->X);
pnt->Y = ENDIANLONG(pnt->Y);
pnt->Z = ENDIANLONG(pnt->Z);
float v[3];
v[0] = pnt->X / 65536.0;
v[1] = pnt->Y / 65536.0;
v[2] = pnt->Z / 65536.0;
pointField->append1Value(v);
#if 0
data[i].v[0] = x;
data[i].v[1] = y;
data[i].v[2] = z;
#endif
}
free(buf);
}
}
break;
case ID_EDGE:
{
UWORD ecount;
IFFReadChunkBytes(pStream, &ecount, sizeof(UWORD));
ecount = ENDIANWORD(ecount);
ATLASSERT(ck.ckSize == (2 + ecount*4));
edges = new edge[ecount];
edge* data = edges;//pModel->GetEdgeData();
for (int i = 0; i < ecount; i++)
{
UWORD edg[2];
IFFReadChunkBytes(pStream, edg, 4);
edg[0] = ENDIANWORD(edg[0]);
edg[1] = ENDIANWORD(edg[1]);
data[i].v[0] = edg[0];
data[i].v[1] = edg[1];
}
}
break;
case ID_EDG2:
{
ULONG ecount;
IFFReadChunkBytes(pStream, &ecount, sizeof(ULONG));
ecount = ENDIANLONG(ecount);
ATLASSERT(ck.ckSize == (4 + ecount*8));
// pModel->SetEdgeDataSize(ecount);
// edge* data = pModel->GetEdgeData();
edges = new edge[ecount];
edge* data = edges;//pModel->GetEdgeData();
for (int i = 0; i < ecount; i++)
{
ULONG edge[2];
IFFReadChunkBytes(pStream, edge, 8);
edge[0] = ENDIANLONG(edge[0]);
edge[1] = ENDIANLONG(edge[1]);
data[i].v[0] = edge[0];
data[i].v[1] = edge[1];
}
}
break;
case ID_FACE:
{
UWORD fcount;
IFFReadChunkBytes(pStream, &fcount, sizeof(UWORD));
fcount = ENDIANWORD(fcount);
//edge* edges = pModel->GetEdgeData();
CComPtr<ILMFInt32> coordIndex;
geometryNode->getField(L"coordIndex", (ILX3DField**)&coordIndex);
ATLASSERT(ck.ckSize == (2 + fcount*6));
for (int i = 0; i < fcount; i++)
{
int polyindex[3];// = pModel->AddPoly(3);
UWORD face[3];
IFFReadChunkBytes(pStream, face, 6);
face[0] = ENDIANWORD(face[0]);
face[1] = ENDIANWORD(face[1]);
face[2] = ENDIANWORD(face[2]);
int e0=face[0], e1=face[1], e2=face[2];
// Now you retrieve 3 pairs of points for the three edges
int p0 = edges[e0].v[0] ; int p1 = edges[e0].v[1];
int p2 = edges[e1].v[0] ; int p3 = edges[e1].v[1];
int p4 = edges[e2].v[0] ; int p5 = edges[e2].v[1];
if (p0 == p2 || p0 == p3) polyindex[0] = p0;
else if (p1 == p2 || p1 == p3) polyindex[0] = p1;
else ATLASSERT(0);
if (p2 == p4 || p2 == p5) polyindex[1] = p2;
else if (p3 == p4 || p3 == p5) polyindex[1] = p3;
else ATLASSERT(0);
if (p4 == p0 || p4 == p1) polyindex[2] = p4;
else if (p5 == p0 || p5 == p1) polyindex[2] = p5;
else ATLASSERT(0);
coordIndex->append1Value(polyindex[0]);
coordIndex->append1Value(polyindex[1]);
coordIndex->append1Value(polyindex[2]);
coordIndex->append1Value(-1);
}
}
break;
case ID_COLR:
{
BYTE pad;
IFFReadChunkBytes(pStream, &pad, 1);
COLOR color;
IFFReadChunkBytes(pStream, &color, sizeof(color));
CComPtr<ILSFColor> colorField;
materialNode->getField(L"diffuseColor", (ILX3DField**)&colorField);
float colorf[3] = {color[0]/255.0, color[1]/255.0, color[2]/255.0};
colorField->setValue(colorf);
}
break;
case ID_REFL:
{
BYTE pad;
IFFReadChunkBytes(pStream, &pad, 1);
COLOR color;
IFFReadChunkBytes(pStream, &color, sizeof(color));
//MessageBeep(-1);
}
break;
case ID_TRAN:
{
BYTE pad;
IFFReadChunkBytes(pStream, &pad, 1);
COLOR color;
IFFReadChunkBytes(pStream, &color, sizeof(color));
}
break;
case ID_SPC1:
{
BYTE pad;
IFFReadChunkBytes(pStream, &pad, 1);
COLOR color;
IFFReadChunkBytes(pStream, &color, sizeof(color));
}
break;
case ID_BRS5:
{
#if 0
BRS5 brs5;
char filename[258] = {0};
IFFReadChunkBytes(pStream, &brs5, sizeof(BRS5));
brs5.Type = ENDIANWORD(brs5.Type);
brs5.WFlags = ENDIANWORD(brs5.WFlags);
IFFReadChunkBytes(r, filename, brs5.FileLength);
// Import the texture as footage into project
if (sPrj)
{
MMPrjRef prjRef = filterrec->layer->GetProject(filterrec->layerRef);
ASSERT(prjRef);
MMPrjItemRef itemRef = sPrj->ImportFootage(prjRef, NULL, filename, 0, NULL);
if (itemRef)
{
; // Do something with it
}
}
#endif
}
break;
/* case ID_BRS3:
{
}
break;
*/
case ID_DESC: // Child description
{
#if 0 // ??
CComPtr<ILX3DField> field;
node->getField(L"children", &field);
CComQIPtr<ILMFNode> children = field;
#endif
ParseDESC(pStream, parentChildren);
}
break;
default:
IFFAscendChunk(pStream, &ck);
ATLTRACE("%4.4s\n", &ck.ckID);
}
}
while (ck.ckID != ID_TOBJ);
#if 0 // TODO have this
pModel->Move(-fposi[0], -fposi[1], -fposi[2]);
#endif
/*
if (sPrj)
{
filterrec->basic->ReleaseSuite(MMSX_Project_SuiteName, MMSX_Project_SuiteVersion);
}
*/
shapeNode->setGeometry(geometryNode);
parentChildren->append1Value(shapeNode);
delete edges;
return shapeNode;
}
