mirror of
https://github.com/UberGames/GtkRadiant.git
synced 2024-11-10 06:31:41 +00:00
1016 lines
26 KiB
C
1016 lines
26 KiB
C
/* -----------------------------------------------------------------------------
|
|
|
|
PicoModel Library
|
|
|
|
Copyright (c) 2002, Randy Reddig & seaw0lf
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted provided that the following conditions are met:
|
|
|
|
Redistributions of source code must retain the above copyright notice, this list
|
|
of conditions and the following disclaimer.
|
|
|
|
Redistributions in binary form must reproduce the above copyright notice, this
|
|
list of conditions and the following disclaimer in the documentation and/or
|
|
other aseMaterialList provided with the distribution.
|
|
|
|
Neither the names of the copyright holders nor the names of its contributors may
|
|
be used to endorse or promote products derived from this software without
|
|
specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
|
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
/* marker */
|
|
#define PM_ASE_C
|
|
|
|
/* uncomment when debugging this module */
|
|
//#define DEBUG_PM_ASE
|
|
//#define DEBUG_PM_ASE_EX
|
|
|
|
|
|
/* dependencies */
|
|
#include "picointernal.h"
|
|
|
|
#ifdef DEBUG_PM_ASE
|
|
#include "time.h"
|
|
#endif
|
|
|
|
/* plain white */
|
|
static picoColor_t white = { 255, 255, 255, 255 };
|
|
|
|
/* jhefty - multi-subobject material support */
|
|
|
|
/* Material/SubMaterial management */
|
|
/* A material should have 1..n submaterials assigned to it */
|
|
|
|
typedef struct aseSubMaterial_s
|
|
{
|
|
struct aseSubMaterial_s* next;
|
|
int subMtlId;
|
|
picoShader_t* shader;
|
|
|
|
} aseSubMaterial_t;
|
|
|
|
typedef struct aseMaterial_s
|
|
{
|
|
struct aseMaterial_s* next;
|
|
struct aseSubMaterial_s* subMtls;
|
|
int mtlId;
|
|
} aseMaterial_t;
|
|
|
|
/* Material/SubMaterial management functions */
|
|
static aseMaterial_t* _ase_get_material( aseMaterial_t* list, int mtlIdParent ){
|
|
aseMaterial_t* mtl = list;
|
|
|
|
while ( mtl )
|
|
{
|
|
if ( mtlIdParent == mtl->mtlId ) {
|
|
break;
|
|
}
|
|
mtl = mtl->next;
|
|
}
|
|
return mtl;
|
|
}
|
|
|
|
static aseSubMaterial_t* _ase_get_submaterial( aseMaterial_t* list, int mtlIdParent, int subMtlId ){
|
|
aseMaterial_t* parent = _ase_get_material( list, mtlIdParent );
|
|
aseSubMaterial_t* subMtl = NULL;
|
|
|
|
if ( !parent ) {
|
|
_pico_printf( PICO_ERROR, "No ASE material exists with id %i\n", mtlIdParent );
|
|
return NULL;
|
|
}
|
|
|
|
subMtl = parent->subMtls;
|
|
while ( subMtl )
|
|
{
|
|
if ( subMtlId == subMtl->subMtlId ) {
|
|
break;
|
|
}
|
|
subMtl = subMtl->next;
|
|
}
|
|
return subMtl;
|
|
}
|
|
|
|
static aseMaterial_t* _ase_add_material( aseMaterial_t **list, int mtlIdParent ){
|
|
aseMaterial_t *mtl = _pico_calloc( 1, sizeof( aseMaterial_t ) );
|
|
mtl->mtlId = mtlIdParent;
|
|
mtl->subMtls = NULL;
|
|
mtl->next = *list;
|
|
*list = mtl;
|
|
|
|
return mtl;
|
|
}
|
|
|
|
static aseSubMaterial_t* _ase_add_submaterial( aseMaterial_t **list, int mtlIdParent, int subMtlId, picoShader_t* shader ){
|
|
aseMaterial_t *parent = _ase_get_material( *list, mtlIdParent );
|
|
aseSubMaterial_t *subMtl = _pico_calloc( 1, sizeof( aseSubMaterial_t ) );
|
|
|
|
if ( !parent ) {
|
|
parent = _ase_add_material( list, mtlIdParent );
|
|
}
|
|
|
|
subMtl->shader = shader;
|
|
subMtl->subMtlId = subMtlId;
|
|
subMtl->next = parent->subMtls;
|
|
parent->subMtls = subMtl;
|
|
|
|
return subMtl;
|
|
}
|
|
|
|
static void _ase_free_materials( aseMaterial_t **list ){
|
|
aseMaterial_t* mtl = *list;
|
|
aseSubMaterial_t* subMtl = NULL;
|
|
|
|
aseMaterial_t* mtlTemp = NULL;
|
|
aseSubMaterial_t* subMtlTemp = NULL;
|
|
|
|
while ( mtl )
|
|
{
|
|
subMtl = mtl->subMtls;
|
|
while ( subMtl )
|
|
{
|
|
subMtlTemp = subMtl->next;
|
|
_pico_free( subMtl );
|
|
subMtl = subMtlTemp;
|
|
}
|
|
mtlTemp = mtl->next;
|
|
_pico_free( mtl );
|
|
mtl = mtlTemp;
|
|
}
|
|
( *list ) = NULL;
|
|
}
|
|
|
|
#ifdef DEBUG_PM_ASE
|
|
static void _ase_print_materials( aseMaterial_t *list ){
|
|
aseMaterial_t* mtl = list;
|
|
aseSubMaterial_t* subMtl = NULL;
|
|
|
|
while ( mtl )
|
|
{
|
|
_pico_printf( PICO_NORMAL, "ASE Material %i", mtl->mtlId );
|
|
subMtl = mtl->subMtls;
|
|
while ( subMtl )
|
|
{
|
|
_pico_printf( PICO_NORMAL, " -- ASE SubMaterial %i - %s\n", subMtl->subMtlId, subMtl->shader->name );
|
|
subMtl = subMtl->next;
|
|
}
|
|
mtl = mtl->next;
|
|
}
|
|
}
|
|
#endif //DEBUG_PM_ASE
|
|
|
|
/* ASE Face management */
|
|
/* These are used to keep an association between a submaterial and a face definition */
|
|
/* They are kept in parallel with the current picoSurface, */
|
|
/* and are used by _ase_submit_triangles to lookup the proper material/submaterial IDs */
|
|
typedef struct aseFace_s
|
|
{
|
|
struct aseFace_s* next;
|
|
int mtlId;
|
|
int subMtlId;
|
|
int index[9];
|
|
} aseFace_t;
|
|
|
|
/* ASE Face management functions */
|
|
void _ase_add_face( aseFace_t **list, aseFace_t **tail, aseFace_t *newFace ){
|
|
/* insert as head of list */
|
|
if ( !( *list ) ) {
|
|
*list = newFace;
|
|
}
|
|
else
|
|
{
|
|
( *tail )->next = newFace;
|
|
}
|
|
|
|
*tail = newFace;
|
|
newFace->next = NULL;
|
|
|
|
//tag the color indices so we can detect them and apply the default color to them
|
|
newFace->index[6] = -1;
|
|
newFace->index[7] = -1;
|
|
newFace->index[8] = -1;
|
|
}
|
|
|
|
aseFace_t* _ase_get_face_for_index( aseFace_t *list, int index ){
|
|
int counter = 0;
|
|
aseFace_t* face = list;
|
|
|
|
while ( counter < index )
|
|
{
|
|
face = face->next;
|
|
counter++;
|
|
}
|
|
return face;
|
|
}
|
|
static void _ase_free_faces( aseFace_t** list, aseFace_t** tail ){
|
|
aseFace_t* face = *list;
|
|
aseFace_t* tempFace = NULL;
|
|
|
|
while ( face )
|
|
{
|
|
tempFace = face->next;
|
|
_pico_free( face );
|
|
face = tempFace;
|
|
}
|
|
|
|
( *list ) = NULL;
|
|
( *tail ) = NULL;
|
|
}
|
|
|
|
/* todo:
|
|
* - apply material specific uv offsets to uv coordinates
|
|
*/
|
|
|
|
/* _ase_canload:
|
|
* validates a 3dsmax ase model file.
|
|
*/
|
|
static int _ase_canload( PM_PARAMS_CANLOAD ){
|
|
picoParser_t *p;
|
|
|
|
|
|
/* quick data length validation */
|
|
if ( bufSize < 80 ) {
|
|
return PICO_PMV_ERROR_SIZE;
|
|
}
|
|
|
|
/* keep the friggin compiler happy */
|
|
*fileName = *fileName;
|
|
|
|
/* create pico parser */
|
|
p = _pico_new_parser( (picoByte_t*) buffer, bufSize );
|
|
if ( p == NULL ) {
|
|
return PICO_PMV_ERROR_MEMORY;
|
|
}
|
|
|
|
/* get first token */
|
|
if ( _pico_parse_first( p ) == NULL ) {
|
|
return PICO_PMV_ERROR_IDENT;
|
|
}
|
|
|
|
/* check first token */
|
|
if ( _pico_stricmp( p->token, "*3dsmax_asciiexport" ) ) {
|
|
_pico_free_parser( p );
|
|
return PICO_PMV_ERROR_IDENT;
|
|
}
|
|
|
|
/* free the pico parser object */
|
|
_pico_free_parser( p );
|
|
|
|
/* file seems to be a valid ase file */
|
|
return PICO_PMV_OK;
|
|
}
|
|
|
|
|
|
|
|
/* _ase_submit_triangles - jhefty
|
|
use the surface and the current face list to look up material/submaterial IDs
|
|
and submit them to the model for proper processing
|
|
|
|
The following still holds from ydnar's _ase_make_surface:
|
|
indexes 0 1 2 = vert indexes
|
|
indexes 3 4 5 = st indexes
|
|
indexes 6 7 8 = color indexes (new)
|
|
*/
|
|
|
|
static void _ase_submit_triangles( picoSurface_t* surface, picoModel_t* model, aseMaterial_t* materials, aseFace_t* faces ){
|
|
aseFace_t* face;
|
|
aseSubMaterial_t* subMtl;
|
|
picoVec3_t* xyz[3];
|
|
picoVec3_t* normal[3];
|
|
picoVec2_t* st[3];
|
|
picoColor_t* color[3];
|
|
int i;
|
|
|
|
face = faces;
|
|
while ( face != NULL )
|
|
{
|
|
/* look up the shader for the material/submaterial pair */
|
|
subMtl = _ase_get_submaterial( materials, face->mtlId, face->subMtlId );
|
|
if ( subMtl == NULL ) {
|
|
/* ydnar: trying default submaterial */
|
|
subMtl = _ase_get_submaterial( materials, face->mtlId, 0 );
|
|
if ( subMtl == NULL ) {
|
|
_pico_printf( PICO_ERROR, "Could not find material/submaterial for id %d/%d\n", face->mtlId, face->subMtlId );
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* we pull the data from the surface using the facelist data */
|
|
for ( i = 0 ; i < 3 ; i++ )
|
|
{
|
|
xyz[i] = (picoVec3_t*) PicoGetSurfaceXYZ( surface, face->index[ i ] );
|
|
normal[i] = (picoVec3_t*) PicoGetSurfaceNormal( surface, face->index[ i ] );
|
|
st[i] = (picoVec2_t*) PicoGetSurfaceST( surface, 0, face->index[ i + 3 ] );
|
|
|
|
if ( face->index [ i + 6] >= 0 ) {
|
|
color[i] = (picoColor_t*)PicoGetSurfaceColor( surface, 0, face->index[ i + 6 ] );
|
|
}
|
|
else
|
|
{
|
|
color[i] = &white;
|
|
}
|
|
|
|
}
|
|
|
|
/* submit the triangle to the model */
|
|
PicoAddTriangleToModel( model, xyz, normal, 1, st, 1, color, subMtl->shader );
|
|
|
|
/* advance to the next face */
|
|
face = face->next;
|
|
}
|
|
}
|
|
|
|
/* _ase_load:
|
|
* loads a 3dsmax ase model file.
|
|
*/
|
|
static picoModel_t *_ase_load( PM_PARAMS_LOAD ){
|
|
picoModel_t *model;
|
|
picoSurface_t *surface = NULL;
|
|
picoParser_t *p;
|
|
char lastNodeName[ 1024 ];
|
|
|
|
aseFace_t* faces = NULL;
|
|
aseFace_t* facesTail = NULL;
|
|
aseMaterial_t* materials = NULL;
|
|
|
|
#ifdef DEBUG_PM_ASE
|
|
clock_t start, finish;
|
|
double elapsed;
|
|
start = clock();
|
|
#endif
|
|
|
|
/* helper */
|
|
#define _ase_error_return( m ) \
|
|
{ \
|
|
_pico_printf( PICO_ERROR,"%s in ASE, line %d.",m,p->curLine ); \
|
|
_pico_free_parser( p ); \
|
|
PicoFreeModel( model ); \
|
|
return NULL; \
|
|
}
|
|
/* create a new pico parser */
|
|
p = _pico_new_parser( (picoByte_t *)buffer,bufSize );
|
|
if ( p == NULL ) {
|
|
return NULL;
|
|
}
|
|
|
|
/* create a new pico model */
|
|
model = PicoNewModel();
|
|
if ( model == NULL ) {
|
|
_pico_free_parser( p );
|
|
return NULL;
|
|
}
|
|
/* do model setup */
|
|
PicoSetModelFrameNum( model, frameNum );
|
|
PicoSetModelName( model, fileName );
|
|
PicoSetModelFileName( model, fileName );
|
|
|
|
/* initialize some stuff */
|
|
memset( lastNodeName,0,sizeof( lastNodeName ) );
|
|
|
|
/* parse ase model file */
|
|
while ( 1 )
|
|
{
|
|
/* get first token on line */
|
|
if ( _pico_parse_first( p ) == NULL ) {
|
|
break;
|
|
}
|
|
|
|
/* we just skip empty lines */
|
|
if ( p->token == NULL || !strlen( p->token ) ) {
|
|
continue;
|
|
}
|
|
|
|
/* we skip invalid ase statements */
|
|
if ( p->token[0] != '*' && p->token[0] != '{' && p->token[0] != '}' ) {
|
|
_pico_parse_skip_rest( p );
|
|
continue;
|
|
}
|
|
/* remember node name */
|
|
if ( !_pico_stricmp( p->token,"*node_name" ) ) {
|
|
/* read node name */
|
|
char *ptr = _pico_parse( p,0 );
|
|
if ( ptr == NULL ) {
|
|
_ase_error_return( "Node name parse error" );
|
|
}
|
|
|
|
/* remember node name */
|
|
strncpy( lastNodeName,ptr,sizeof( lastNodeName ) );
|
|
}
|
|
/* model mesh (originally contained within geomobject) */
|
|
else if ( !_pico_stricmp( p->token,"*mesh" ) ) {
|
|
/* finish existing surface */
|
|
//_ase_make_surface( model, &surface );
|
|
_ase_submit_triangles( surface, model,materials,faces );
|
|
_ase_free_faces( &faces,&facesTail );
|
|
|
|
/* allocate new pico surface */
|
|
surface = PicoNewSurface( NULL );
|
|
if ( surface == NULL ) {
|
|
PicoFreeModel( model );
|
|
return NULL;
|
|
}
|
|
}
|
|
/* mesh material reference. this usually comes at the end of */
|
|
/* geomobjects after the mesh blocks. we must assume that the */
|
|
/* new mesh was already created so all we can do here is assign */
|
|
/* the material reference id (shader index) now. */
|
|
else if ( !_pico_stricmp( p->token,"*material_ref" ) ) {
|
|
int mtlId;
|
|
aseFace_t* face;
|
|
|
|
/* we must have a valid surface */
|
|
if ( surface == NULL ) {
|
|
_ase_error_return( "Missing mesh for material reference" );
|
|
}
|
|
|
|
/* get the material ref (0..n) */
|
|
if ( !_pico_parse_int( p,&mtlId ) ) {
|
|
_ase_error_return( "Missing material reference ID" );
|
|
}
|
|
|
|
/* fix up all of the aseFaceList in the surface to point to the parent material */
|
|
/* we've already saved off their subMtl */
|
|
face = faces;
|
|
while ( face != NULL )
|
|
{
|
|
face->mtlId = mtlId;
|
|
face = face->next;
|
|
}
|
|
}
|
|
/* model mesh vertex */
|
|
else if ( !_pico_stricmp( p->token,"*mesh_vertex" ) ) {
|
|
picoVec3_t v;
|
|
int index;
|
|
|
|
/* we must have a valid surface */
|
|
if ( surface == NULL ) {
|
|
continue;
|
|
}
|
|
|
|
/* get vertex data (orig: index +y -x +z) */
|
|
if ( !_pico_parse_int( p,&index ) ) {
|
|
_ase_error_return( "Vertex parse error" );
|
|
}
|
|
if ( !_pico_parse_vec( p,v ) ) {
|
|
_ase_error_return( "Vertex parse error" );
|
|
}
|
|
|
|
/* set vertex */
|
|
PicoSetSurfaceXYZ( surface,index,v );
|
|
}
|
|
/* model mesh vertex normal */
|
|
else if ( !_pico_stricmp( p->token,"*mesh_vertexnormal" ) ) {
|
|
picoVec3_t v;
|
|
int index;
|
|
|
|
/* we must have a valid surface */
|
|
if ( surface == NULL ) {
|
|
continue;
|
|
}
|
|
|
|
/* get vertex data (orig: index +y -x +z) */
|
|
if ( !_pico_parse_int( p,&index ) ) {
|
|
_ase_error_return( "Vertex parse error" );
|
|
}
|
|
if ( !_pico_parse_vec( p,v ) ) {
|
|
_ase_error_return( "Vertex parse error" );
|
|
}
|
|
|
|
/* set vertex */
|
|
PicoSetSurfaceNormal( surface,index,v );
|
|
}
|
|
/* model mesh face */
|
|
else if ( !_pico_stricmp( p->token,"*mesh_face" ) ) {
|
|
picoIndex_t indexes[3];
|
|
int index;
|
|
|
|
/* we must have a valid surface */
|
|
if ( surface == NULL ) {
|
|
continue;
|
|
}
|
|
|
|
/* get face index */
|
|
if ( !_pico_parse_int( p,&index ) ) {
|
|
_ase_error_return( "Face parse error" );
|
|
}
|
|
|
|
/* get 1st vertex index */
|
|
_pico_parse( p,0 );
|
|
if ( !_pico_parse_int( p,&indexes[0] ) ) {
|
|
_ase_error_return( "Face parse error" );
|
|
}
|
|
|
|
/* get 2nd vertex index */
|
|
_pico_parse( p,0 );
|
|
if ( !_pico_parse_int( p,&indexes[1] ) ) {
|
|
_ase_error_return( "Face parse error" );
|
|
}
|
|
|
|
/* get 3rd vertex index */
|
|
_pico_parse( p,0 );
|
|
if ( !_pico_parse_int( p,&indexes[2] ) ) {
|
|
_ase_error_return( "Face parse error" );
|
|
}
|
|
|
|
/* set face indexes (note interleaved offset!) */
|
|
PicoSetSurfaceIndex( surface, ( index * 9 + 0 ), indexes[2] );
|
|
PicoSetSurfaceIndex( surface, ( index * 9 + 1 ), indexes[1] );
|
|
PicoSetSurfaceIndex( surface, ( index * 9 + 2 ), indexes[0] );
|
|
|
|
/* parse to the subMaterial ID */
|
|
while ( 1 )
|
|
{
|
|
_pico_parse( p,0 );
|
|
if ( !_pico_stricmp( p->token,"*MESH_MTLID" ) ) {
|
|
aseFace_t* newFace;
|
|
int subMtlId;
|
|
|
|
_pico_parse_int( p, &subMtlId );
|
|
newFace = _pico_calloc( 1, sizeof( aseFace_t ) );
|
|
|
|
/* we fix up the mtlId later when we parse the material_ref */
|
|
newFace->mtlId = 0;
|
|
newFace->subMtlId = subMtlId;
|
|
newFace->index[0] = indexes[2];
|
|
newFace->index[1] = indexes[1];
|
|
newFace->index[2] = indexes[0];
|
|
|
|
_ase_add_face( &faces,&facesTail,newFace );
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
/* model texture vertex */
|
|
else if ( !_pico_stricmp( p->token,"*mesh_tvert" ) ) {
|
|
picoVec2_t uv;
|
|
int index;
|
|
|
|
/* we must have a valid surface */
|
|
if ( surface == NULL ) {
|
|
continue;
|
|
}
|
|
|
|
/* get uv vertex index */
|
|
if ( !_pico_parse_int( p,&index ) ) {
|
|
_ase_error_return( "UV vertex parse error" );
|
|
}
|
|
|
|
/* get uv vertex s */
|
|
if ( !_pico_parse_float( p,&uv[0] ) ) {
|
|
_ase_error_return( "UV vertex parse error" );
|
|
}
|
|
|
|
/* get uv vertex t */
|
|
if ( !_pico_parse_float( p,&uv[1] ) ) {
|
|
_ase_error_return( "UV vertex parse error" );
|
|
}
|
|
|
|
/* ydnar: invert t */
|
|
uv[ 1 ] = 1.0f - uv[ 1 ];
|
|
|
|
/* set texture vertex */
|
|
PicoSetSurfaceST( surface,0,index,uv );
|
|
}
|
|
/* ydnar: model mesh texture face */
|
|
else if ( !_pico_stricmp( p->token, "*mesh_tface" ) ) {
|
|
picoIndex_t indexes[3];
|
|
int index;
|
|
aseFace_t* face;
|
|
|
|
/* we must have a valid surface */
|
|
if ( surface == NULL ) {
|
|
continue;
|
|
}
|
|
|
|
/* get face index */
|
|
if ( !_pico_parse_int( p,&index ) ) {
|
|
_ase_error_return( "Texture face parse error" );
|
|
}
|
|
|
|
/* get 1st vertex index */
|
|
if ( !_pico_parse_int( p,&indexes[0] ) ) {
|
|
_ase_error_return( "Texture face parse error" );
|
|
}
|
|
|
|
/* get 2nd vertex index */
|
|
if ( !_pico_parse_int( p,&indexes[1] ) ) {
|
|
_ase_error_return( "Texture face parse error" );
|
|
}
|
|
|
|
/* get 3rd vertex index */
|
|
if ( !_pico_parse_int( p,&indexes[2] ) ) {
|
|
_ase_error_return( "Texture face parse error" );
|
|
}
|
|
|
|
/* set face indexes (note interleaved offset!) */
|
|
PicoSetSurfaceIndex( surface, ( index * 9 + 3 ), indexes[2] );
|
|
PicoSetSurfaceIndex( surface, ( index * 9 + 4 ), indexes[1] );
|
|
PicoSetSurfaceIndex( surface, ( index * 9 + 5 ), indexes[0] );
|
|
|
|
face = _ase_get_face_for_index( faces,index );
|
|
face->index[3] = indexes[2];
|
|
face->index[4] = indexes[1];
|
|
face->index[5] = indexes[0];
|
|
}
|
|
/* model color vertex */
|
|
else if ( !_pico_stricmp( p->token,"*mesh_vertcol" ) ) {
|
|
picoColor_t color;
|
|
int index;
|
|
float colorInput;
|
|
|
|
/* we must have a valid surface */
|
|
if ( surface == NULL ) {
|
|
continue;
|
|
}
|
|
|
|
/* get color vertex index */
|
|
if ( !_pico_parse_int( p,&index ) ) {
|
|
_ase_error_return( "UV vertex parse error" );
|
|
}
|
|
|
|
/* get R component */
|
|
if ( !_pico_parse_float( p,&colorInput ) ) {
|
|
_ase_error_return( "color vertex parse error" );
|
|
}
|
|
color[0] = (picoByte_t)( colorInput * 255 );
|
|
|
|
/* get G component */
|
|
if ( !_pico_parse_float( p,&colorInput ) ) {
|
|
_ase_error_return( "color vertex parse error" );
|
|
}
|
|
color[1] = (picoByte_t)( colorInput * 255 );
|
|
|
|
/* get B component */
|
|
if ( !_pico_parse_float( p,&colorInput ) ) {
|
|
_ase_error_return( "color vertex parse error" );
|
|
}
|
|
color[2] = (picoByte_t)( colorInput * 255 );
|
|
|
|
/* leave alpha alone since we don't get any data from the ASE format */
|
|
color[3] = 255;
|
|
|
|
/* set texture vertex */
|
|
PicoSetSurfaceColor( surface,0,index,color );
|
|
}
|
|
/* model color face */
|
|
else if ( !_pico_stricmp( p->token,"*mesh_cface" ) ) {
|
|
picoIndex_t indexes[3];
|
|
int index;
|
|
aseFace_t* face;
|
|
|
|
/* we must have a valid surface */
|
|
if ( surface == NULL ) {
|
|
continue;
|
|
}
|
|
|
|
/* get face index */
|
|
if ( !_pico_parse_int( p,&index ) ) {
|
|
_ase_error_return( "Face parse error" );
|
|
}
|
|
|
|
/* get 1st cvertex index */
|
|
// _pico_parse( p,0 );
|
|
if ( !_pico_parse_int( p,&indexes[0] ) ) {
|
|
_ase_error_return( "Face parse error" );
|
|
}
|
|
|
|
/* get 2nd cvertex index */
|
|
// _pico_parse( p,0 );
|
|
if ( !_pico_parse_int( p,&indexes[1] ) ) {
|
|
_ase_error_return( "Face parse error" );
|
|
}
|
|
|
|
/* get 3rd cvertex index */
|
|
// _pico_parse( p,0 );
|
|
if ( !_pico_parse_int( p,&indexes[2] ) ) {
|
|
_ase_error_return( "Face parse error" );
|
|
}
|
|
|
|
/* set face indexes (note interleaved offset!) */
|
|
PicoSetSurfaceIndex( surface, ( index * 9 + 6 ), indexes[2] );
|
|
PicoSetSurfaceIndex( surface, ( index * 9 + 7 ), indexes[1] );
|
|
PicoSetSurfaceIndex( surface, ( index * 9 + 8 ), indexes[0] );
|
|
|
|
face = _ase_get_face_for_index( faces,index );
|
|
face->index[6] = indexes[2];
|
|
face->index[7] = indexes[1];
|
|
face->index[8] = indexes[0];
|
|
}
|
|
/* model material */
|
|
else if ( !_pico_stricmp( p->token, "*material" ) ) {
|
|
aseSubMaterial_t* subMaterial = NULL;
|
|
picoShader_t *shader = NULL;
|
|
int level = 1, index;
|
|
char materialName[ 1024 ];
|
|
float transValue = 0.0f, shineValue = 1.0f;
|
|
picoColor_t ambientColor, diffuseColor, specularColor;
|
|
char *mapname = NULL;
|
|
int subMtlId, subMaterialLevel = -1;
|
|
|
|
|
|
/* get material index */
|
|
_pico_parse_int( p,&index );
|
|
|
|
/* check brace */
|
|
if ( !_pico_parse_check( p,1,"{" ) ) {
|
|
_ase_error_return( "Material missing opening brace" );
|
|
}
|
|
|
|
/* parse material block */
|
|
while ( 1 )
|
|
{
|
|
/* get next token */
|
|
if ( _pico_parse( p,1 ) == NULL ) {
|
|
break;
|
|
}
|
|
if ( !strlen( p->token ) ) {
|
|
continue;
|
|
}
|
|
|
|
/* handle levels */
|
|
if ( p->token[0] == '{' ) {
|
|
level++;
|
|
}
|
|
if ( p->token[0] == '}' ) {
|
|
level--;
|
|
}
|
|
if ( !level ) {
|
|
break;
|
|
}
|
|
|
|
if ( level == subMaterialLevel ) {
|
|
/* set material name */
|
|
PicoSetShaderName( shader, materialName );
|
|
|
|
/* set shader's transparency */
|
|
PicoSetShaderTransparency( shader,transValue );
|
|
|
|
/* set shader's ambient color */
|
|
PicoSetShaderAmbientColor( shader,ambientColor );
|
|
|
|
/* set diffuse alpha to transparency */
|
|
diffuseColor[3] = (picoByte_t)( transValue * 255.0 );
|
|
|
|
/* set shader's diffuse color */
|
|
PicoSetShaderDiffuseColor( shader,diffuseColor );
|
|
|
|
/* set shader's specular color */
|
|
PicoSetShaderSpecularColor( shader,specularColor );
|
|
|
|
/* set shader's shininess */
|
|
PicoSetShaderShininess( shader,shineValue );
|
|
|
|
/* set material map name */
|
|
PicoSetShaderMapName( shader, mapname );
|
|
|
|
subMaterial = _ase_add_submaterial( &materials, index, subMtlId, shader );
|
|
subMaterialLevel = -1;
|
|
}
|
|
|
|
/* parse submaterial index */
|
|
if ( !_pico_stricmp( p->token,"*submaterial" ) ) {
|
|
/* allocate new pico shader */
|
|
_pico_parse_int( p, &subMtlId );
|
|
|
|
shader = PicoNewShader( model );
|
|
if ( shader == NULL ) {
|
|
PicoFreeModel( model );
|
|
return NULL;
|
|
}
|
|
subMaterialLevel = level;
|
|
}
|
|
/* parse material name */
|
|
else if ( !_pico_stricmp( p->token,"*material_name" ) ) {
|
|
char* name = _pico_parse( p,0 );
|
|
if ( name == NULL ) {
|
|
_ase_error_return( "Missing material name" );
|
|
}
|
|
|
|
strcpy( materialName, name );
|
|
/* skip rest and continue with next token */
|
|
_pico_parse_skip_rest( p );
|
|
continue;
|
|
}
|
|
/* parse material transparency */
|
|
else if ( !_pico_stricmp( p->token,"*material_transparency" ) ) {
|
|
/* get transparency value from ase */
|
|
if ( !_pico_parse_float( p,&transValue ) ) {
|
|
_ase_error_return( "Material transparency parse error" );
|
|
}
|
|
|
|
/* skip rest and continue with next token */
|
|
_pico_parse_skip_rest( p );
|
|
continue;
|
|
}
|
|
/* parse material shininess */
|
|
else if ( !_pico_stricmp( p->token,"*material_shine" ) ) {
|
|
/* remark:
|
|
* - not sure but instead of '*material_shine' i might
|
|
* need to use '*material_shinestrength' */
|
|
|
|
/* get shine value from ase */
|
|
if ( !_pico_parse_float( p,&shineValue ) ) {
|
|
_ase_error_return( "Material shine parse error" );
|
|
}
|
|
|
|
/* scale ase shine range 0..1 to pico range 0..127 */
|
|
shineValue *= 128.0;
|
|
|
|
/* skip rest and continue with next token */
|
|
_pico_parse_skip_rest( p );
|
|
continue;
|
|
}
|
|
/* parse ambient material color */
|
|
else if ( !_pico_stricmp( p->token,"*material_ambient" ) ) {
|
|
picoVec3_t vec;
|
|
/* get r,g,b float values from ase */
|
|
if ( !_pico_parse_vec( p,vec ) ) {
|
|
_ase_error_return( "Material color parse error" );
|
|
}
|
|
|
|
/* setup 0..255 range color values */
|
|
ambientColor[ 0 ] = (int)( vec[ 0 ] * 255.0 );
|
|
ambientColor[ 1 ] = (int)( vec[ 1 ] * 255.0 );
|
|
ambientColor[ 2 ] = (int)( vec[ 2 ] * 255.0 );
|
|
ambientColor[ 3 ] = (int)( 255 );
|
|
|
|
/* skip rest and continue with next token */
|
|
_pico_parse_skip_rest( p );
|
|
continue;
|
|
}
|
|
/* parse diffuse material color */
|
|
else if ( !_pico_stricmp( p->token,"*material_diffuse" ) ) {
|
|
picoVec3_t vec;
|
|
|
|
/* get r,g,b float values from ase */
|
|
if ( !_pico_parse_vec( p,vec ) ) {
|
|
_ase_error_return( "Material color parse error" );
|
|
}
|
|
|
|
/* setup 0..255 range color */
|
|
diffuseColor[ 0 ] = (int)( vec[ 0 ] * 255.0 );
|
|
diffuseColor[ 1 ] = (int)( vec[ 1 ] * 255.0 );
|
|
diffuseColor[ 2 ] = (int)( vec[ 2 ] * 255.0 );
|
|
diffuseColor[ 3 ] = (int)( 255 );
|
|
|
|
/* skip rest and continue with next token */
|
|
_pico_parse_skip_rest( p );
|
|
continue;
|
|
}
|
|
/* parse specular material color */
|
|
else if ( !_pico_stricmp( p->token,"*material_specular" ) ) {
|
|
picoVec3_t vec;
|
|
|
|
/* get r,g,b float values from ase */
|
|
if ( !_pico_parse_vec( p,vec ) ) {
|
|
_ase_error_return( "Material color parse error" );
|
|
}
|
|
|
|
/* setup 0..255 range color */
|
|
specularColor[ 0 ] = (int)( vec[ 0 ] * 255 );
|
|
specularColor[ 1 ] = (int)( vec[ 1 ] * 255 );
|
|
specularColor[ 2 ] = (int)( vec[ 2 ] * 255 );
|
|
specularColor[ 3 ] = (int)( 255 );
|
|
|
|
/* skip rest and continue with next token */
|
|
_pico_parse_skip_rest( p );
|
|
continue;
|
|
}
|
|
/* material diffuse map */
|
|
else if ( !_pico_stricmp( p->token,"*map_diffuse" ) ) {
|
|
int sublevel = 0;
|
|
|
|
/* parse material block */
|
|
while ( 1 )
|
|
{
|
|
/* get next token */
|
|
if ( _pico_parse( p,1 ) == NULL ) {
|
|
break;
|
|
}
|
|
if ( !strlen( p->token ) ) {
|
|
continue;
|
|
}
|
|
|
|
/* handle levels */
|
|
if ( p->token[0] == '{' ) {
|
|
sublevel++;
|
|
}
|
|
if ( p->token[0] == '}' ) {
|
|
sublevel--;
|
|
}
|
|
if ( !sublevel ) {
|
|
break;
|
|
}
|
|
|
|
/* parse diffuse map bitmap */
|
|
if ( !_pico_stricmp( p->token,"*bitmap" ) ) {
|
|
char* name = _pico_parse( p,0 );
|
|
if ( name == NULL ) {
|
|
_ase_error_return( "Missing material map bitmap name" );
|
|
}
|
|
mapname = _pico_alloc( strlen( name ) + 1 );
|
|
strcpy( mapname, name );
|
|
/* skip rest and continue with next token */
|
|
_pico_parse_skip_rest( p );
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
/* end map_diffuse block */
|
|
}
|
|
/* end material block */
|
|
|
|
if ( subMaterial == NULL ) {
|
|
/* allocate new pico shader */
|
|
shader = PicoNewShader( model );
|
|
if ( shader == NULL ) {
|
|
PicoFreeModel( model );
|
|
return NULL;
|
|
}
|
|
|
|
/* set material name */
|
|
PicoSetShaderName( shader,materialName );
|
|
|
|
/* set shader's transparency */
|
|
PicoSetShaderTransparency( shader,transValue );
|
|
|
|
/* set shader's ambient color */
|
|
PicoSetShaderAmbientColor( shader,ambientColor );
|
|
|
|
/* set diffuse alpha to transparency */
|
|
diffuseColor[3] = (picoByte_t)( transValue * 255.0 );
|
|
|
|
/* set shader's diffuse color */
|
|
PicoSetShaderDiffuseColor( shader,diffuseColor );
|
|
|
|
/* set shader's specular color */
|
|
PicoSetShaderSpecularColor( shader,specularColor );
|
|
|
|
/* set shader's shininess */
|
|
PicoSetShaderShininess( shader,shineValue );
|
|
|
|
/* set material map name */
|
|
PicoSetShaderMapName( shader, mapname );
|
|
|
|
/* this is just a material with 1 submaterial */
|
|
subMaterial = _ase_add_submaterial( &materials, index, 0, shader );
|
|
}
|
|
|
|
/* ydnar: free mapname */
|
|
if ( mapname != NULL ) {
|
|
_pico_free( mapname );
|
|
}
|
|
} // !_pico_stricmp ( "*material" )
|
|
|
|
/* skip unparsed rest of line and continue */
|
|
_pico_parse_skip_rest( p );
|
|
}
|
|
|
|
/* ydnar: finish existing surface */
|
|
// _ase_make_surface( model, &surface );
|
|
_ase_submit_triangles( surface, model,materials,faces );
|
|
_ase_free_faces( &faces,&facesTail );
|
|
|
|
#ifdef DEBUG_PM_ASE
|
|
_ase_print_materials( materials );
|
|
finish = clock();
|
|
elapsed = (double)( finish - start ) / CLOCKS_PER_SEC;
|
|
_pico_printf( PICO_NORMAL, "Loaded model in in %-.2f second(s)\n", elapsed );
|
|
#endif //DEBUG_PM_ASE
|
|
|
|
_ase_free_materials( &materials );
|
|
|
|
/* return allocated pico model */
|
|
return model;
|
|
}
|
|
|
|
/* pico file format module definition */
|
|
const picoModule_t picoModuleASE =
|
|
{
|
|
"1.0", /* module version string */
|
|
"Autodesk 3DSMAX ASCII", /* module display name */
|
|
"Jared Hefty, seaw0lf", /* author's name */
|
|
"2003 Jared Hefty, 2002 seaw0lf", /* module copyright */
|
|
{
|
|
"ase",NULL,NULL,NULL /* default extensions to use */
|
|
},
|
|
_ase_canload, /* validation routine */
|
|
_ase_load, /* load routine */
|
|
NULL, /* save validation routine */
|
|
NULL /* save routine */
|
|
};
|