void read_scene(tokenizer& t,document_type& doc)
{
//std::cerr << "unsupported data: Scene" << std::endl;
OutputDebugStringA("Scene>>>>");
t.expect_literal( "{" );
for( ;; ) {
substr token = t();
OutputDebugStringA((token.str() + "\n").c_str());
if( token == "}" ) { break; }
if( token == "amb" ) {
doc.scene.ambient.red = t.expect_float(0,1);
doc.scene.ambient.green = t.expect_float(0,1);
doc.scene.ambient.blue = t.expect_float(0,1);
doc.scene.ambient.alpha = 1;
t.expect_linefeed();
} else if( token == "dirlights" ) {
t();
skip_chunk(t);
skip_to_linefeed(t);
} else {
skip_to_linefeed(t);
}
}
OutputDebugStringA("Scene<<<<");
}
static inline mpeg2_state_t seek_chunk (mpeg2dec_t * mpeg2dec)
{
int size, skipped;
size = mpeg2dec->buf_end - mpeg2dec->buf_start;
skipped = skip_chunk (mpeg2dec, size);
if (!skipped) {
mpeg2dec->bytes_since_tag += size;
return STATE_BUFFER;
}
mpeg2dec->bytes_since_tag += skipped;
mpeg2dec->code = mpeg2dec->buf_start[-1];
return STATE_INTERNAL_NORETURN;
}
int
get_mapdata_chunk(FILE *stream, int tag, MapData *md) {
switch (tag) {
case MAT_MAPNAME:
strlimit=13;
if (!get_mtlchunk(stream,md->name)) {
return(0);
}
#ifdef DBGLDMLI
if (dbgldmli)
printf(" get_map : mapname: %s \n",md->name);
#endif
return(1);
case MAT_MAP_TILING:
return(get_mtlchunk(stream,&md->p.tex.texflags));
case MAT_MAP_TILINGOLD:
if (!get_mtlchunk(stream,&md->p.tex.texflags)) {
return(0);
}
if (md->p.tex.texflags&TEX_DECAL)
md->p.tex.texflags|=TEX_NOWRAP;
return(1);
case MAT_MAP_TEXBLUR:
return(get_mtlchunk(stream,&md->p.tex.texblur));
case MAT_MAP_TEXBLUR_OLD:
return(get_mtlchunk(stream,&md->p.tex.texblur));
case MAT_MAP_USCALE:
return(get_mtlchunk(stream,&md->p.tex.uscale));
case MAT_MAP_VSCALE:
return(get_mtlchunk(stream,&md->p.tex.vscale));
case MAT_MAP_UOFFSET:
return(get_mtlchunk(stream,&md->p.tex.uoffset));
case MAT_MAP_VOFFSET:
return(get_mtlchunk(stream,&md->p.tex.voffset));
case MAT_MAP_ANG:
return(get_mtlchunk(stream,&md->p.tex));
case MAT_MAP_COL1:
return(get_mtlchunk(stream,&md->p.tex.col1));
case MAT_MAP_COL2:
return(get_mtlchunk(stream,&md->p.tex.col2));
case MAT_MAP_RCOL:
return(get_mtlchunk(stream,&md->p.tex.rcol));
case MAT_MAP_GCOL:
return(get_mtlchunk(stream,&md->p.tex.gcol));
case MAT_MAP_BCOL:
return(get_mtlchunk(stream,&md->p.tex.bcol));
default:
return(skip_chunk(stream));
}
}
void read_backimage(tokenizer& t,document_type& doc)
{
//std::cerr << "unsupported data: BackImage" << std::endl;
skip_chunk(t);
}
int
get_mtlchunk(FILE *stream,void *data)
{
/* Grab a chunk from the file and process all its subsets */
Chunk_hdr chunk;
Chunk_hdr nxt;
uint thistag,nexttag;
char *string;
short *pshort;
RDERR(&chunk,6);
thistag=chunk.tag;
#ifdef DBGLDMLI
if (dbgldmli)
printf(" get_mtlchunk: tag=%X, size=%d \n",thistag,chunk.size);
#endif
/* Update chunk size to account for header */
chunk.size-=6L;
/* Find chunk type and go process it */
switch(thistag)
{
case MLIBMAGIC:
while(chunk.size)
{
if(get_next_chunk(stream,&nxt)==0)
return(0);
nexttag=nxt.tag;
switch(nexttag)
{
case MAT_ENTRY:
loadmtl= &inmtl;
/* Zero out data structure first */
init_mtl_struct(loadmtl);
if(get_mtlchunk(stream,NULL)==0)
return(0);
if(put_lib_mtl(loadmtl)==0)
return(0);
break;
default:
if(skip_chunk(stream)==0){
MtlError();
return(0);
}
break;
}
chunk.size-=nxt.size;
}
break;
case MAT_ENTRY:
case MATMAGIC:
while(chunk.size)
{
if(get_next_chunk(stream,&nxt)==0)
return(0);
nexttag=nxt.tag;
switch(nexttag)
{
case MAT_NAME:
strlimit=17;
if(get_mtlchunk(stream,loadmtl->name)==0)
return(0);
#ifdef DBGLDMLI
if (dbgldmli)
printf(" **** Loading material : %s \n", loadmtl->name);
#endif
if(just_name) /* If all we need is the name, return */
return(1);
break;
case MAT_AMBIENT:
if(get_mtlchunk(stream,&loadmtl->amb)==0)
return(0);
break;
case MAT_DIFFUSE:
if(get_mtlchunk(stream,&loadmtl->diff)==0)
return(0);
break;
case MAT_SPECULAR:
if(get_mtlchunk(stream,&loadmtl->spec)==0)
return(0);
break;
case MAT_ACUBIC:
{
Mapping *m = loadmtl->map[Nrefl];
if (m==NULL) goto skip_mtl_chunk;
if (get_mtlchunk(stream,&m->map.p.ref.acb)==0)
return(0);
}
break;
case MAT_SXP_TEXT_DATA:
case MAT_SXP_TEXT2_DATA:
case MAT_SXP_OPAC_DATA:
case MAT_SXP_BUMP_DATA:
case MAT_SXP_SPEC_DATA:
case MAT_SXP_SELFI_DATA:
case MAT_SXP_SHIN_DATA:
case MAT_SXP_TEXT_MASKDATA:
case MAT_SXP_TEXT2_MASKDATA:
case MAT_SXP_OPAC_MASKDATA:
case MAT_SXP_BUMP_MASKDATA:
case MAT_SXP_SPEC_MASKDATA:
case MAT_SXP_SELFI_MASKDATA:
case MAT_SXP_SHIN_MASKDATA:
case MAT_SXP_REFL_MASKDATA:
if(get_mtlchunk(stream,NULL)==0)
return(0);
break;
case MAT_TEXMAP:
case MAT_TEX2MAP:
case MAT_OPACMAP:
case MAT_BUMPMAP:
case MAT_SPECMAP:
case MAT_SHINMAP:
case MAT_SELFIMAP:
case MAT_REFLMAP:
case MAT_TEXMASK:
case MAT_TEX2MASK:
case MAT_OPACMASK:
case MAT_BUMPMASK:
case MAT_SPECMASK:
case MAT_SHINMASK:
case MAT_SELFIMASK:
case MAT_REFLMASK:
if(get_mtlchunk(stream,NULL)==0)
return(0);
break;
case MAT_SHININESS:
case MAT_SHIN2PCT:
case MAT_TRANSPARENCY:
case MAT_XPFALL:
case MAT_REFBLUR:
case MAT_SELF_ILPCT:
case MAT_SHADING:
case MAT_TWO_SIDE:
case MAT_SUPERSMP:
case MAT_SELF_ILLUM:
case MAT_DECAL:
case MAT_ADDITIVE:
case MAT_WIRE:
case MAT_FACEMAP:
case MAT_XPFALLIN:
case MAT_PHONGSOFT:
case MAT_WIREABS:
case MAT_USE_XPFALL:
case MAT_USE_REFBLUR:
case MAT_WIRESIZE:
if(get_mtlchunk(stream,NULL)==0)
return(0);
break;
case APP_DATA:
if(get_mtlchunk(stream,&loadmtl->appdata)==0)
return(0);
break;
default:
skip_mtl_chunk:
if(skip_chunk(stream)==0) {
MtlError();
return(0);
}
break;
}
chunk.size-=nxt.size;
}
#ifdef DBGLDMLI
if (dbgldmli)
printf(" finished loading mtl %s, flags = %X\n",
loadmtl->name, loadmtl->flags);
#endif
/* convert old data formats to new */
if (loadmtl->shading==REND_WIRE) {
loadmtl->shading = REND_FLAT;
loadmtl->flags |= MF_WIRE;
loadmtl->flags |= MF_TWOSIDE;
loadmtl->shininess=0;
loadmtl->shin2pct=0;
loadmtl->transparency=0;
}
if (loadmtl->xpfall<0.0) {
loadmtl->flags|= MF_XPFALLIN;
loadmtl->xpfall = -loadmtl->xpfall;
}
if (loadmtl->flags&MF_DECAL) {
set_mtl_decal(loadmtl);
loadmtl->flags &= ~MF_DECAL;
}
if (loadmtl->shin2pct==255) {
float shin = (((float)(loadmtl->shininess))/100.0f);
float atten = (float)sin(1.5707*shin);
loadmtl->shin2pct = (int)((atten)*100.0f+0.5f);
}
break;
case MAT_SXP_TEXT_DATA: GET_SXP(Ntex,0); break;
case MAT_SXP_TEXT2_DATA: GET_SXP(Ntex2,0); break;
case MAT_SXP_OPAC_DATA: GET_SXP(Nopac,0); break;
case MAT_SXP_BUMP_DATA: GET_SXP(Nbump,0); break;
case MAT_SXP_SPEC_DATA: GET_SXP(Nspec,0); break;
case MAT_SXP_SELFI_DATA: GET_SXP(Nselfi,0); break;
case MAT_SXP_SHIN_DATA: GET_SXP(Nshin,0); break;
case MAT_SXP_TEXT_MASKDATA: GET_SXP(Ntex,1); break;
case MAT_SXP_TEXT2_MASKDATA: GET_SXP(Ntex2,1); break;
case MAT_SXP_OPAC_MASKDATA: GET_SXP(Nopac,1); break;
case MAT_SXP_BUMP_MASKDATA: GET_SXP(Nbump,1); break;
case MAT_SXP_SPEC_MASKDATA: GET_SXP(Nspec,1); break;
case MAT_SXP_SELFI_MASKDATA: GET_SXP(Nselfi,1); break;
case MAT_SXP_SHIN_MASKDATA: GET_SXP(Nshin,1); break;
case MAT_SXP_REFL_MASKDATA: GET_SXP(Nrefl,1); break;
case MAT_TEXMAP: GET_MAP(Ntex); break;
case MAT_TEX2MAP: GET_MAP(Ntex2); break;
case MAT_OPACMAP: GET_MAP(Nopac); break;
case MAT_BUMPMAP: GET_MAP(Nbump); break;
case MAT_SPECMAP: GET_MAP(Nspec); break;
case MAT_SHINMAP: GET_MAP(Nshin); break;
case MAT_SELFIMAP: GET_MAP(Nselfi); break;
case MAT_REFLMAP: GET_MAP(Nrefl); break;
case MAT_TEXMASK: GET_MASK(Ntex); break;
case MAT_TEX2MASK: GET_MASK(Ntex2); break;
case MAT_OPACMASK: GET_MASK(Nopac); break;
case MAT_BUMPMASK: GET_MASK(Nbump); break;
case MAT_SPECMASK: GET_MASK(Nspec); break;
case MAT_SHINMASK: GET_MASK(Nshin); break;
case MAT_SELFIMASK: GET_MASK(Nselfi); break;
case MAT_REFLMASK: GET_MASK(Nrefl); break;
case MAT_AMBIENT:
case MAT_DIFFUSE:
case MAT_SPECULAR:
{
int got_lin,got_gam;
got_lin = got_gam = 0;
while(chunk.size)
{
if(get_next_chunk(stream,&nxt)==0)
return(0);
nexttag=nxt.tag;
switch(nexttag) {
case COLOR_F:
case COLOR_24:
got_gam = 1;
if(get_mtlchunk(stream,NULL)==0) return(0);
break;
case LIN_COLOR_24:
got_lin = 1;
if(get_mtlchunk(stream,NULL)==0) return(0);
break;
default:
if(skip_chunk(stream)==0) {
MtlError();
return(0);
}
break;
}
chunk.size-=nxt.size;
}
if (got_lin) {
memcpy((char *)data,(char *)&LC24,sizeof(Color_24));
}
else {
if (!got_gam) {
MtlError();
return(0);
}
if (gammaMgr.enable) {
Color_24 gc;
gc.r = gammaMgr.file_in_degamtab[C24.r]>>8;
gc.g = gammaMgr.file_in_degamtab[C24.g]>>8;
gc.b = gammaMgr.file_in_degamtab[C24.b]>>8;
memcpy((char *)data,(char *)&gc,sizeof(Color_24));
}
else {
memcpy((char *)data,(char *)&C24,sizeof(Color_24));
}
}
}
/*
* Complete the reading of the status byte. The parsed midi
* command will be added to the specified track .
*
* Arguments:
* msp - Current midi file status
* track - Current track
* status - Status byte, ie. current command
*/
static void
handle_status(struct midistate *msp, struct trackElement *track, int status)
{
int ch;
int type;
int device;
int length;
short note, vel, control;
int val;
unsigned char *data;
struct element *el;
ch = status & 0x0f;
type = status & 0xf0;
/*
* Do not set the device if the type is 0xf0 as these commands are
* not channel specific
*/
device = 0;
if (type != 0xf0)
device = (msp->port<<4) + ch;
msp->device = device;
el = NULL;
switch (type) {
case MIDI_NOTE_OFF:
note = read_int(msp, 1);
vel = read_int(msp, 1);
finish_note(msp, note, vel);
break;
case MIDI_NOTE_ON:
note = read_int(msp, 1);
vel = read_int(msp, 1);
if (vel == 0) {
/* This is really a note off */
finish_note(msp, note, vel);
} else {
/* Save the start, so it can be matched with the note off */
el = save_note(msp, note, vel);
}
break;
case MIDI_KEY_AFTERTOUCH:
note = read_int(msp, 1);
vel = read_int(msp, 1);
/* new aftertouchElement */
el = MD_ELEMENT(md_keytouch_new(note, vel));
break;
case MIDI_CONTROLER:
control = read_int(msp, 1);
val = read_int(msp, 1);
el = MD_ELEMENT(md_control_new(control, val));
break;
case MIDI_PATCH:
val = read_int(msp, 1);
el = MD_ELEMENT(md_program_new(val));
break;
case MIDI_CHANNEL_AFTERTOUCH:
val = read_int(msp, 1);
el = MD_ELEMENT(md_pressure_new(val));
break;
case MIDI_PITCH_WHEEL:
{
val = read_int(msp, 1);
int val2 = read_int(msp, 1);
val |= val2 << 7;
val -= 0x2000; /* Center it around zero */
el = MD_ELEMENT(md_pitch_new(val));
break;
}
/* Now for all the non-channel specific ones */
case 0xf0:
/* Deal with the end of track event first */
if (ch == 0x0f) {
type = read_int(msp, 1);
if (type == 0x2f) {
/* End of track - skip to end of real track */
track->final_time = msp->current_time;
skip_chunk(msp);
return;
}
}
/* Get the length of the following data */
length = read_var(msp);
data = read_data(msp, length);
if (ch == 0x0f) {
el = (struct element *)handle_meta(msp, type, data);
} else {
el = (struct element *)md_sysex_new(status, data, length);
}
break;
default:
except(formatError, "Bad status type 0x%x", type);
/*NOTREACHED*/
}
if (el != NULL) {
el->element_time = msp->current_time;
el->device_channel = device;
md_add(MD_CONTAINER(track), el);
}
}
