gmueller/gremlin
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

initial mesh and physics support

Browse Source
This commit is contained in:
gmueller
2011-01-19 23:20:08 +01:00
parent 6fcb3dbff4
commit 12153ffbea
16 changed files with 4231 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
libs/trimeshloader/CMakeLists.txt Normal file
View File

@ -0,0 +1,7 @@
include_directories (include)
add_library (trimeshloader
src/tl3ds
src/tlobj
src/trimeshloader
)

36
libs/trimeshloader/Changelog.txt Normal file
View File

@ -0,0 +1,36 @@
*** RELEASE 0.0.12
2007/05/28 - Cirdan
* again bug fixes in obj code
*** RELEASE 0.0.11
2007/05/28 - Cirdan
* relative indices
* bug fix in new obj code
*** RELEASE 0.0.10
2007/05/28 - Cirdan
* use a faster lookup method in obj code
2007/04/24 - Cirdan
* fixed a memory leak in tlLoad3DS/tlLoadObj functions
* added flexible vertex formats for high level loading
2007/04/17 - Cirdan
* renamed tlTrimeshFrom[3ds|Obj]State to tlCreateTrimeshFrom[3ds|Obj]State
* changed license from MIT to zlib
2007/04/17 - Cirdan
* replaced "0" with NULL
2007/04/16 - Cirdan
* added tl3dsCheckFileExtension and tlObjCheckFileExtension functions.

1252
libs/trimeshloader/Doxyfile Normal file
View File

File diff suppressed because it is too large Load Diff

21
libs/trimeshloader/Readme.txt Normal file
View File

@ -0,0 +1,21 @@
Authors
-------
Gero Müller <gero.mueller@cloo.de>
Contributions
-------------
Paolo Manna (many good ideas and feedback)
Website
-------
http://trimeshloader.sourceforge.net
Versioning
----------
[Major].[Minor].[Patchlevel] e.g. 1.0.1
Where all releases with the same Major revision need to be API compatible.

135
libs/trimeshloader/include/tl3ds.h Normal file
View File

@ -0,0 +1,135 @@
/*
* Copyright (c) 2007 Gero Mueller <gero.mueller@cloo.de>
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source
* distribution.
*/
#ifndef TRIMESH_LOADER_3DS_H
#define TRIMESH_LOADER_3DS_H
/**
@file tl3ds.h
@brief Trimeshloader 3DS parser public header file
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef TRIMESH_LOADER_EXPORT
#define TRIMESH_LOADER_API
#else
#define TRIMESH_LOADER_API extern
#endif
/** @defgroup low_level_3ds_api Trimeshloader low level 3DS API
* @{
*/
/** Structure describing the parsing state. the user has no direkt access to it. */
typedef struct tl3dsState tl3dsState;
/** Create a new parsing state.
* \return A new parsing state, which needs to be deleted after parsing. NULL on error.
*/
TRIMESH_LOADER_API tl3dsState *tl3dsCreateState();
/** Reset the parsing state
* \param state pointer to an previously created state.
*/
TRIMESH_LOADER_API int tl3dsResetState( tl3dsState *state );
/** Destroy a previously created state.
* \param state pointer to an previously created state.
*/
TRIMESH_LOADER_API void tl3dsDestroyState( tl3dsState *state );
/** Parse a chunk of data.
* \param state a previously created state.
* \param buffer pointer to the chunk of data to be parsed
* \param length number of bytes to be parsed
* \param last indicator if this is the last chunk. 1 = yes, 0 = no.
* \return Returns 0 on success, 1 on error.
*/
TRIMESH_LOADER_API int tl3dsParse(
tl3dsState *state,
const char *buffer,
unsigned int length,
int last );
/* data access */
TRIMESH_LOADER_API unsigned int tl3dsObjectCount( tl3dsState *state );
TRIMESH_LOADER_API const char *tl3dsObjectName(
tl3dsState *state,
unsigned int object );
TRIMESH_LOADER_API unsigned int tl3dsObjectFaceCount(
tl3dsState *state,
unsigned int object );
TRIMESH_LOADER_API unsigned int tl3dsObjectFaceIndex(
tl3dsState *state,
unsigned int object );
TRIMESH_LOADER_API unsigned int tl3dsVertexCount( tl3dsState *state );
TRIMESH_LOADER_API int tl3dsGetVertexDouble(
tl3dsState *state,
unsigned int index,
double *x, double *y, double *z,
double *tu, double *tv,
double *nx, double *ny, double *nz );
TRIMESH_LOADER_API int tl3dsGetVertex(
tl3dsState *state,
unsigned int index,
float *x, float *y, float *z,
float *tu, float *tv,
float *nx, float *ny, float *nz );
TRIMESH_LOADER_API unsigned int tl3dsFaceCount(
tl3dsState *state );
TRIMESH_LOADER_API int tl3dsGetFaceInt(
tl3dsState *state,
unsigned int index,
unsigned int *a,
unsigned int *b,
unsigned int *c );
TRIMESH_LOADER_API int tl3dsGetFace(
tl3dsState *state,
unsigned int index,
unsigned short *a,
unsigned short *b,
unsigned short *c );
TRIMESH_LOADER_API int tl3dsCheckFileExtension( const char *filename );
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif

120
libs/trimeshloader/include/tlobj.h Normal file
View File

@ -0,0 +1,120 @@
/*
* Copyright (c) 2007 Gero Mueller <gero.mueller@cloo.de>
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source
* distribution.
*/
#ifndef TRIMESH_LOADER_OBJ_H
#define TRIMESH_LOADER_OBJ_H
/**
@file tlobj.h
@brief Trimeshloader OBJ parser public header file
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef TRIMESH_LOADER_EXPORT
#define TRIMESH_LOADER_API
#else
#define TRIMESH_LOADER_API extern
#endif
/** @defgroup low_level_obj_api Trimeshloader low level OBJ API
* @{
*/
typedef struct tlObjState tlObjState;
/* state handling */
TRIMESH_LOADER_API tlObjState *tlObjCreateState();
TRIMESH_LOADER_API int tlObjResetState( tlObjState *state );
TRIMESH_LOADER_API void tlObjDestroyState( tlObjState *state );
/* parsing */
TRIMESH_LOADER_API int tlObjParse(
tlObjState *state,
const char *buffer,
unsigned int length,
int last );
/* data access */
TRIMESH_LOADER_API unsigned int tlObjObjectCount( tlObjState *state );
TRIMESH_LOADER_API const char *tlObjObjectName(
tlObjState *state,
unsigned int object );
TRIMESH_LOADER_API unsigned int tlObjObjectFaceCount(
tlObjState *state,
unsigned int object );
TRIMESH_LOADER_API unsigned int tlObjObjectFaceIndex(
tlObjState *state,
unsigned int object );
TRIMESH_LOADER_API unsigned int tlObjVertexCount( tlObjState *state );
TRIMESH_LOADER_API int tlObjGetVertexDouble(
tlObjState *state,
unsigned int index,
double *x, double *y, double *z,
double *tu, double *tv,
double *nx, double *ny, double *nz );
TRIMESH_LOADER_API int tlObjGetVertex(
tlObjState *state,
unsigned int index,
float *x, float *y, float *z,
float *tu, float *tv,
float *nx, float *ny, float *nz );
TRIMESH_LOADER_API unsigned int tlObjFaceCount(
tlObjState *state );
TRIMESH_LOADER_API int tlObjGetFaceInt(
tlObjState *state,
unsigned int index,
unsigned int *a,
unsigned int *b,
unsigned int *c );
TRIMESH_LOADER_API int tlObjGetFace(
tlObjState *state,
unsigned int index,
unsigned short *a,
unsigned short *b,
unsigned short *c );
TRIMESH_LOADER_API int tlObjCheckFileExtension( const char *filename );
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif

159
libs/trimeshloader/include/trimeshloader.h Normal file
View File

@ -0,0 +1,159 @@
/*
* Copyright (c) 2007 Gero Mueller <gero.mueller@cloo.de>
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source
* distribution.
*/
/** \mainpage trimeshloader-0.1
* \section project_page Project Page
* \url http://sourceforge.net/projects/trimeshloader
* \section website Website with tutorials
* \url http://trimeshloader.sourceforge.net
*/
/**
@file trimeshloader.h
@brief Trimeshloader public header file
*/
#ifndef TRIMESH_LOADER_H
#define TRIMESH_LOADER_H
#include "tlobj.h"
#include "tl3ds.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifndef TRIMESH_LOADER_EXPORT
#define TRIMESH_LOADER_API
#else
#define TRIMESH_LOADER_API extern
#endif
/** @defgroup high_level_api Trimeshloader high level API
* @{
*/
/** Structure describing an Object (or SubMesh, Batch) */
typedef struct tlObject
{
/** Name of the Object */
char *name;
/** First face in the index list */
unsigned int face_index;
/** Face count */
unsigned int face_count;
} tlObject;
/** Used as format flag in loading functions: load the position of the vertex */
#define TL_FVF_XYZ 1
/** Used as format flag in loading functions: load the texturecoordinate of the vertex */
#define TL_FVF_UV 2
/** Used as format flag in loading functions: load the normal of the vertex */
#define TL_FVF_NORMAL 4
/** Structure describing an Trimesh (index triangle list) containing objects, vertices (point, texture coordinate and normal) and triangle indices */
typedef struct tlTrimesh
{
/** pointer to the vertex data */
float *vertices;
/** number of vertices */
unsigned int vertex_count;
/** format of the vertices */
unsigned int vertex_format;
/** size/stride of each vertex, in bytes */
unsigned int vertex_size;
/** pointer to the face (triangle) indices (3 unsigned shorts) */
unsigned short *faces;
/** number of faces */
unsigned int face_count;
/** list of objects in this trimesh */
tlObject *objects;
/** number of objects */
unsigned int object_count;
} tlTrimesh;
/** Load an 3DS file in an tlTrimesh structure
* \param filename Pointer to NULL-terminated string containing the filename
* \param vertex_format Defines the vertex format. any format combination of TL_FVF_XYZ, TL_FVF_UV, TL_FVF_NORMAL
* \return Returns a new tlTrimesh object, which needs to be deleted with tlDeleteTrimesh. NULL on error.
*/
TRIMESH_LOADER_API tlTrimesh *tlLoad3DS( const char*filename, unsigned int vertex_format );
/** Load an OBJ file in an tlTrimesh structure
* \param filename Pointer to NULL-terminated string containing the filename
* \param vertex_format Defines the vertex format. any format combination of TL_FVF_XYZ, TL_FVF_UV, TL_FVF_NORMAL
* \return Returns a new tlTrimesh object, which needs to be deleted with tlDeleteTrimesh. NULL on error.
*/
TRIMESH_LOADER_API tlTrimesh *tlLoadOBJ( const char*filename, unsigned int vertex_format );
/** Create an a tlTrimesh structure from a tlObjState
* \param state Pointer to state after parsing.
* \param vertex_format Defines the vertex format. any format combination of TL_FVF_XYZ, TL_FVF_UV, TL_FVF_NORMAL
* \return Returns a new tlTrimesh object, which needs to be deleted with tlDeleteTrimesh. NULL on error.
*/
TRIMESH_LOADER_API tlTrimesh *tlCreateTrimeshFromObjState( tlObjState *state, unsigned int vertex_format );
/** Create an a tlTrimesh structure from a tl3dsState
* \param state Pointer to state after parsing.
* \param vertex_format Defines the vertex format. any format combination of TL_FVF_XYZ, TL_FVF_UV, TL_FVF_NORMAL
* \return Returns a new tlTrimesh object, which needs to be deleted with tlDeleteTrimesh. NULL on error.
*/
TRIMESH_LOADER_API tlTrimesh *tlCreateTrimeshFrom3dsState( tl3dsState *state, unsigned int vertex_format );
/** Load an 3DS or OBJ file in an tlTrimesh structure. Automatic extension parsing is done.
* \param filename Pointer to NULL-terminated string containing the filename
* \param vertex_format Defines the vertex format. any format combination of TL_FVF_XYZ, TL_FVF_UV, TL_FVF_NORMAL
* \return Returns a new tlTrimesh object, which needs to be deleted with tlDeleteTrimesh. NULL on error.
*/
TRIMESH_LOADER_API tlTrimesh *tlLoadTrimesh( const char*filename, unsigned int vertex_format );
/** Delete an previously loaded tlTrimesh object
* \param trimesh Previously loaded tlTrimesh object
*/
TRIMESH_LOADER_API void tlDeleteTrimesh( tlTrimesh *trimesh );
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /*TRIMESHLOADER_H_*/

909
libs/trimeshloader/src/tl3ds.c Normal file
View File

@ -0,0 +1,909 @@
/*
* Copyright (c) 2007 Gero Mueller <gero.mueller@cloo.de>
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source
* distribution.
*/
#include "tl3ds.h"
#include <string.h>
#include <stdlib.h>
/*----------------------------------------------------------------------------*/
typedef enum tl3dsParsingState
{
TDS_STATE_READ_CHUNK_ID,
TDS_STATE_READ_CHUNK_LENGTH,
TDS_STATE_READ_OBJECT_NAME,
TDS_STATE_SKIP_CHUNK,
TDS_STATE_READ_POINT_COUNT,
TDS_STATE_READ_POINTS,
TDS_STATE_READ_TEXCOORD_COUNT,
TDS_STATE_READ_TEXCOORDS,
TDS_STATE_READ_FACE_COUNT,
TDS_STATE_READ_FACES,
TDS_STATE_DONE
} tl3dsParsingState;
/*----------------------------------------------------------------------------*/
typedef struct tl3dsObject
{
char *name;
unsigned int index, count;
} tl3dsObject;
/*----------------------------------------------------------------------------*/
struct tl3dsState
{
unsigned short chunk_id;
unsigned int chunk_length;
char *buffer;
unsigned int buffer_size;
unsigned int buffer_length;
unsigned int counter;
unsigned int item_count;
tl3dsParsingState parsing_state;
float *point_buffer;
unsigned int point_buffer_size;
unsigned int point_count;
float *texcoord_buffer;
unsigned int texcoord_buffer_size;
unsigned int texcoord_count;
unsigned short *face_buffer;
unsigned int face_buffer_size;
unsigned int face_count;
tl3dsObject **object_buffer;
unsigned int object_count;
};
/*----------------------------------------------------------------------------*/
static unsigned int tds_le()
{
const char endian[8] = { 1, 0, 0, 0, 0, 0, 0, 0 };
unsigned int i = *((unsigned int *)endian);
/* LE uint64: i = 1 */
/* LE uint32: i = 1 */
/* LE uint16: i = 1 */
/* BE uint32: i > 1 */
/* BE uint32: i > 1 */
/* BE uint16: i > 1 */
if( i == 1 )
return 1;
else
return 0;
}
/*----------------------------------------------------------------------------*/
static float tds_read_le_float( const char *ptr )
{
float f = 0;
char *fptr = (char *)&f;
if( tds_le() )
{
fptr[0] = ptr[0];
fptr[1] = ptr[1];
fptr[2] = ptr[2];
fptr[3] = ptr[3];
}
else
{
fptr[0] = ptr[3];
fptr[1] = ptr[2];
fptr[2] = ptr[1];
fptr[3] = ptr[0];
}
return f;
}
/*----------------------------------------------------------------------------*/
static unsigned short tds_read_le_ushort( const char *ptr )
{
unsigned short s = 0;
char *sptr = (char *)&s;
if( tds_le() )
{
sptr[0] = ptr[0];
sptr[1] = ptr[1];
}
else
{
sptr[0] = ptr[1];
sptr[1] = ptr[0];
}
return s;
}
/*----------------------------------------------------------------------------*/
static unsigned int tds_read_le_uint( const char *ptr )
{
unsigned int i = 0;
char *iptr = (char *)&i;
if( tds_le() )
{
iptr[0] = ptr[0];
iptr[1] = ptr[1];
iptr[2] = ptr[2];
iptr[3] = ptr[3];
}
else
{
iptr[0] = ptr[3];
iptr[1] = ptr[2];
iptr[2] = ptr[1];
iptr[3] = ptr[0];
}
return i;
}
/*----------------------------------------------------------------------------*/
static int tds_buffer_reserve( tl3dsState *state, unsigned int size )
{
unsigned int new_size = 1;
char *new_buffer = 0;
if( state == NULL )
return 1;
if( state->buffer_size >= size )
return 0;
while( new_size < size )
new_size = new_size * 2;
new_buffer = (char *)realloc( state->buffer, new_size );
if( new_buffer )
{
state->buffer = new_buffer;
state->buffer_size = new_size;
}
return 0;
}
/*----------------------------------------------------------------------------*/
static void tds_buffer_add( tl3dsState *state, char c )
{
if( tds_buffer_reserve( state, state->buffer_length + 1 ) != 0 )
return;
state->buffer[ state->buffer_length ] = c;
state->buffer_length++;
}
/*----------------------------------------------------------------------------*/
static int tds_object_buffer_add(
tl3dsState *state,
const char *name,
unsigned int name_length )
{
tl3dsObject **new_object_buffer = 0;
unsigned int new_object_count = state->object_count + 1;
new_object_buffer = (tl3dsObject **)realloc(
state->object_buffer,
sizeof(tl3dsObject *) * new_object_count );
if( new_object_buffer )
{
/* create the new object */
tl3dsObject *new_object = (tl3dsObject *)malloc( sizeof(tl3dsObject) );
memset( new_object, 0, sizeof(tl3dsObject) );
/* copy the name */
new_object->name = (char *)malloc( name_length );
memcpy( new_object->name, name, name_length );
/* add the new object */
new_object_buffer[ new_object_count - 1 ] = new_object;
/* update state */
state->object_buffer = new_object_buffer;
state->object_count = new_object_count;
return 0;
}
return 1;
}
/*----------------------------------------------------------------------------*/
static void tds_point_buffer_grow( tl3dsState *state, unsigned int count )
{
unsigned int new_size = (state->point_count + count ) * 3 * sizeof(float);
float *new_buffer = realloc( state->point_buffer, new_size );
if( new_buffer )
{
state->point_buffer = new_buffer;
state->point_buffer_size = new_size;
}
}
/*----------------------------------------------------------------------------*/
static void tds_point_buffer_add( tl3dsState *state, float x, float y, float z )
{
unsigned int new_size = (state->point_count + 1 ) * 3 * sizeof(float);
if( state->point_buffer_size < new_size )
return;
state->point_buffer[state->point_count * 3] = x;
state->point_buffer[state->point_count * 3 + 1] = y;
state->point_buffer[state->point_count * 3 + 2] = z;
state->point_count++;
}
/*----------------------------------------------------------------------------*/
static void tds_texcoord_buffer_grow( tl3dsState *state, unsigned int count )
{
unsigned int new_size = (state->texcoord_count + count ) * 2 * sizeof(float);
float *new_buffer = realloc( state->texcoord_buffer, new_size );
if( new_buffer )
{
state->texcoord_buffer = new_buffer;
state->texcoord_buffer_size = new_size;
}
}
/*----------------------------------------------------------------------------*/
static void tds_texcoord_buffer_add( tl3dsState *state, float u, float v )
{
unsigned int new_size = (state->texcoord_count + 1 ) * 2 * sizeof(float);
if( state->texcoord_buffer_size < new_size )
return;
state->texcoord_buffer[state->texcoord_count * 2] = u;
state->texcoord_buffer[state->texcoord_count * 2 + 1] = v;
state->texcoord_count++;
}
/*----------------------------------------------------------------------------*/
static void tds_face_buffer_grow( tl3dsState *state, unsigned int count )
{
unsigned int new_size
= (state->face_count + count ) * 3 * sizeof(unsigned short);
unsigned short *new_buffer = realloc( state->face_buffer, new_size );
if( new_buffer )
{
state->face_buffer = new_buffer;
state->face_buffer_size = new_size;
}
}
/*----------------------------------------------------------------------------*/
static void tds_face_buffer_add(
tl3dsState *state,
unsigned short a,
unsigned short b,
unsigned short c )
{
unsigned int new_size
= (state->face_count + 1 ) * 3 * sizeof(unsigned short);
if( state->face_buffer_size < new_size )
return;
state->face_buffer[state->face_count * 3] = a;
state->face_buffer[state->face_count * 3 + 1] = b;
state->face_buffer[state->face_count * 3 + 2] = c;
state->face_count++;
}
/*----------------------------------------------------------------------------*/
tl3dsState *tl3dsCreateState()
{
tl3dsState *state = malloc( sizeof(tl3dsState) );
if( state )
{
memset( state, 0, sizeof(tl3dsState) );
state->parsing_state = TDS_STATE_READ_CHUNK_ID;
}
return state;
}
/*----------------------------------------------------------------------------*/
int tl3dsResetState( tl3dsState *state )
{
unsigned int i;
if( state->buffer )
free( state->buffer );
if( state->object_buffer )
{
for( i = 0; i < state->object_count; i++ )
{
tl3dsObject *obj = state->object_buffer[i];
if( obj == 0 )
continue;
if( obj->name )
free( obj->name );
free( obj );
}
free( state->object_buffer );
}
if( state->point_buffer )
free( state->point_buffer );
if( state->texcoord_buffer )
free( state->texcoord_buffer );
if( state->face_buffer )
free( state->face_buffer );
memset( state, 0, sizeof(tl3dsState) );
state->parsing_state = TDS_STATE_READ_CHUNK_ID;
return 0;
}
/*----------------------------------------------------------------------------*/
void tl3dsDestroyState( tl3dsState *state )
{
if( state )
{
tl3dsResetState( state );
free( state );
}
}
/*----------------------------------------------------------------------------*/
int tl3dsParse(
tl3dsState *state,
const char *buffer,
unsigned int length,
int last )
{
unsigned int i = 0;
if( state == NULL )
return 1;
while( i < length )
{
char c = buffer[i];
switch( state->parsing_state )
{
case TDS_STATE_READ_CHUNK_ID:
tds_buffer_add( state, c );
if( state->buffer_length == 2 )
{
state->chunk_id = tds_read_le_ushort( state->buffer );
state->buffer_length = 0;
state->parsing_state = TDS_STATE_READ_CHUNK_LENGTH;
}
++i;
break;
case TDS_STATE_READ_CHUNK_LENGTH:
tds_buffer_add( state, c );
if( state->buffer_length == 4 )
{
state->chunk_length = tds_read_le_uint( state->buffer );
state->buffer_length = 0;
switch( state->chunk_id )
{
case 0x4d4d: /* MAIN CHUNK */
case 0x4100: /* TRI_OBJECT */
case 0x3d3d: /* 3D EDITOR CHUNK */
state->parsing_state = TDS_STATE_READ_CHUNK_ID;
break;
case 0x4000: /* OBJECT */
state->parsing_state = TDS_STATE_READ_OBJECT_NAME;
break;
case 0x4110: /* POINT_ARRAY */
state->parsing_state = TDS_STATE_READ_POINT_COUNT;
break;
case 0x4120: /* FACE_ARRAY */
state->parsing_state = TDS_STATE_READ_FACE_COUNT;
break;
case 0x4140: /* TEX_ARRAY */
state->parsing_state = TDS_STATE_READ_TEXCOORD_COUNT;
break;
default:
state->parsing_state = TDS_STATE_SKIP_CHUNK;
state->counter = 6;
break;
}
}
++i;
break;
case TDS_STATE_READ_OBJECT_NAME:
tds_buffer_add( state, c );
if( c == 0 )
{
tds_object_buffer_add(
state,
state->buffer,
state->buffer_length );
/* continue with chunks */
state->parsing_state = TDS_STATE_READ_CHUNK_ID;
state->buffer_length = 0;
}
++i;
break;
case TDS_STATE_READ_POINT_COUNT:
tds_buffer_add( state, c );
if( state->buffer_length == 2 )
{
state->item_count = tds_read_le_ushort( state->buffer );
tds_point_buffer_grow( state, state->item_count );
state->parsing_state = TDS_STATE_READ_POINTS;
state->buffer_length = 0;
state->counter = 0;
}
++i;
break;
case TDS_STATE_READ_POINTS:
tds_buffer_add( state, c );
if( state->buffer_length == 12 )
{
tds_point_buffer_add(
state,
tds_read_le_float( state->buffer ),
tds_read_le_float( state->buffer + 4 ),
tds_read_le_float( state->buffer + 8 ) );
state->counter++;
state->buffer_length = 0;
if( state->counter >= state->item_count )
{
state->parsing_state = TDS_STATE_READ_CHUNK_ID;
state->buffer_length = 0;
}
}
++i;
break;
case TDS_STATE_READ_TEXCOORD_COUNT:
tds_buffer_add( state, c );
if( state->buffer_length == 2 )
{
state->item_count = tds_read_le_ushort( state->buffer );
tds_texcoord_buffer_grow( state, state->item_count );
state->parsing_state = TDS_STATE_READ_TEXCOORDS;
state->buffer_length = 0;
state->counter = 0;
}
++i;
break;
case TDS_STATE_READ_TEXCOORDS:
tds_buffer_add( state, c );
if( state->buffer_length == 8 )
{
tds_texcoord_buffer_add(
state,
tds_read_le_float( state->buffer ),
tds_read_le_float( state->buffer + 4 ) );
state->counter++;
state->buffer_length = 0;
if( state->counter >= state->item_count )
state->parsing_state = TDS_STATE_READ_CHUNK_ID;
}
++i;
break;
case TDS_STATE_READ_FACE_COUNT:
tds_buffer_add( state, c );
if( state->buffer_length == 2 )
{
state->item_count = tds_read_le_ushort( state->buffer );
tds_face_buffer_grow( state, state->item_count );
state->object_buffer[state->object_count-1]->count
= state->item_count;
if( state->object_count > 1 )
state->object_buffer[state->object_count - 1]->index
= state->object_buffer[state->object_count-2]->index
+ state->object_buffer[state->object_count-2]->count;
state->parsing_state = TDS_STATE_READ_FACES;
state->buffer_length = 0;
state->counter = 0;
}
++i;
break;
case TDS_STATE_READ_FACES:
tds_buffer_add( state, c );
if( state->buffer_length == 8 )
{
tds_face_buffer_add(
state,
tds_read_le_ushort( state->buffer ),
tds_read_le_ushort( state->buffer + 2),
tds_read_le_ushort( state->buffer + 4 ) );
state->counter++;
state->buffer_length = 0;
if( state->counter >= state->item_count )
state->parsing_state = TDS_STATE_READ_CHUNK_ID;
}
++i;
break;
case TDS_STATE_SKIP_CHUNK:
++i;
++state->counter;
if( state->counter >= state->chunk_length )
state->parsing_state = TDS_STATE_READ_CHUNK_ID;
break;
default:
++i;
break;
}
}
if( last )
state->parsing_state = TDS_STATE_DONE;
return 0;
}
/*----------------------------------------------------------------------------*/
unsigned int tl3dsObjectCount( tl3dsState *state )
{
if( state == NULL )
return 0;
if( state->parsing_state != TDS_STATE_DONE )
return 0;
return state->object_count;
}
/*----------------------------------------------------------------------------*/
const char *tl3dsObjectName( tl3dsState *state, unsigned int object )
{
if( state == NULL )
return NULL;
if( state->parsing_state != TDS_STATE_DONE )
return NULL;
if( object >= state->object_count )
return NULL;
return state->object_buffer[object]->name;
}
/*----------------------------------------------------------------------------*/
unsigned int tl3dsObjectFaceCount( tl3dsState *state, unsigned int object )
{
if( state == NULL )
return 0;
if( state->parsing_state != TDS_STATE_DONE )
return 0;
if( object >= state->object_count )
return 0;
return state->object_buffer[object]->count;
}
/*----------------------------------------------------------------------------*/
unsigned int tl3dsObjectFaceIndex( tl3dsState *state, unsigned int object )
{
if( state == NULL )
return 0;
if( state->parsing_state != TDS_STATE_DONE )
return 0;
if( object >= state->object_count )
return 0;
return state->object_buffer[object]->index;
}
/*----------------------------------------------------------------------------*/
unsigned int tl3dsVertexCount( tl3dsState *state )
{
if( state == NULL )
return 0;
if( state->parsing_state != TDS_STATE_DONE )
return 0;
return state->point_count;
}
/*----------------------------------------------------------------------------*/
int tl3dsGetVertexDouble(
tl3dsState *state,
unsigned int index,
double *x, double *y, double *z,
double *tu, double *tv,
double *nx, double *ny, double *nz )
{
if( state == NULL )
return 1;
if( index >= state->point_count )
return 1;
if( state->point_buffer && index < state->point_count )
{
if( x )
*x = (float)state->point_buffer[ index * 3 ];
if( y )
*y = (float)state->point_buffer[ index * 3 + 1];
if( z )
*z = (float)state->point_buffer[ index * 3 + 2];
}
if( state->texcoord_buffer && index < state->texcoord_count )
{
if( tu )
*tu = (float)state->texcoord_buffer[ index * 2 ];
if( tv )
*tv = (float)state->texcoord_buffer[ index * 2 + 1];
}
if( nx )
*nx = 0;
if( ny )
*ny = 0;
if( nz )
*nz = 0;
return 0;
}
/*----------------------------------------------------------------------------*/
int tl3dsGetVertex(
tl3dsState *state,
unsigned int index,
float *x, float *y, float *z,
float *tu, float *tv,
float *nx, float *ny, float *nz )
{
if( state == NULL )
return 1;
if( index >= state->point_count )
return 1;
if( state->point_buffer && index < state->point_count )
{
if( x )
*x = (float)state->point_buffer[ index * 3 ];
if( y )
*y = (float)state->point_buffer[ index * 3 + 1];
if( z )
*z = (float)state->point_buffer[ index * 3 + 2];
}
if( state->texcoord_buffer && index < state->texcoord_count )
{
if( tu )
*tu = (float)state->texcoord_buffer[ index * 2 ];
if( tv )
*tv = (float)state->texcoord_buffer[ index * 2 + 1];
}
if( nx )
*nx = 0;
if( ny )
*ny = 0;
if( nz )
*nz = 0;
return 0;
}
/*----------------------------------------------------------------------------*/
unsigned int tl3dsFaceCount( tl3dsState *state )
{
if( state == NULL )
return 0;
return state->face_count;
}
/*----------------------------------------------------------------------------*/
int tl3dsGetFaceInt(
tl3dsState *state,
unsigned int index,
unsigned int *a,
unsigned int *b,
unsigned int *c )
{
unsigned int face = 0;
if( state == NULL )
return 1;
if( state->face_buffer && face <= state->face_count )
{
if( a )
*a = state->face_buffer[ index * 3 ];
if( b )
*b = state->face_buffer[ index * 3 + 1 ];
if( c )
*c = state->face_buffer[ index * 3 + 2 ];
}
return 0;
}
/*----------------------------------------------------------------------------*/
int tl3dsGetFace(
tl3dsState *state,
unsigned int index,
unsigned short *a,
unsigned short *b,
unsigned short *c )
{
unsigned int face = 0;
if( state == NULL )
return 1;
if( state->face_buffer && face <= state->face_count )
{
if( a )
*a = state->face_buffer[ index * 3 ];
if( b )
*b = state->face_buffer[ index * 3 + 1 ];
if( c )
*c = state->face_buffer[ index * 3 + 2 ];
}
return 0;
}
/*----------------------------------------------------------------------------*/
int tl3dsCheckFileExtension( const char *filename )
{
const char *ext = 0, *tmp = filename;
if( filename == NULL )
return 1;
while( *tmp != 0 )
{
if( *tmp == '.' )
ext = tmp + 1;
tmp++;
}
/* no extension found */
if( ext == 0 )
return 1;
if( (ext[0] == '3')
&& (ext[1] == 'd' || ext[1] == 'D')
&& (ext[2] == 's' || ext[2] == 'S')
&& (ext[3] == 0) )
return 0;
return 1;
}

1125
libs/trimeshloader/src/tlobj.c Normal file
View File

File diff suppressed because it is too large Load Diff

280
libs/trimeshloader/src/trimeshloader.c Normal file
View File

@ -0,0 +1,280 @@
/*
* Copyright (c) 2007 Gero Mueller <gero.mueller@cloo.de>
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source
* distribution.
*/
#include "trimeshloader.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
/*----------------------------------------------------------------------------*/
tlTrimesh *tlCreateTrimeshFrom3dsState( tl3dsState *state, unsigned int vertex_format )
{
tlTrimesh *trimesh = NULL;
unsigned int i = 0, index = 0;
float *x = NULL, *y = NULL, *z = NULL;
float *u = NULL, *v = NULL;
float *nx = NULL, *ny = NULL, *nz = NULL;
if( state == NULL )
return NULL;
trimesh = malloc( sizeof(tlTrimesh) );
trimesh->object_count = tl3dsObjectCount( state );
trimesh->objects = malloc( sizeof(tlObject) * trimesh->object_count );
for( i = 0; i < trimesh->object_count; i++ )
{
unsigned int length = strlen( tl3dsObjectName( state, i ) ) + 1;
trimesh->objects[i].name = malloc( length );
memcpy( trimesh->objects[i].name, tl3dsObjectName( state, i ), length );
trimesh->objects[i].face_index = tl3dsObjectFaceIndex( state, i );
trimesh->objects[i].face_count = tl3dsObjectFaceCount( state, i );
}
trimesh->face_count = tl3dsFaceCount( state );
trimesh->faces = malloc( sizeof(unsigned short) * trimesh->face_count * 3 );
for( i = 0; i < trimesh->face_count; i++ )
{
unsigned int offset = i * 3;
tl3dsGetFace( state, i,
&trimesh->faces[offset],
&trimesh->faces[offset + 1],
&trimesh->faces[offset + 2] );
}
trimesh->vertex_count = tl3dsVertexCount( state );
trimesh->vertex_format = vertex_format;
trimesh->vertex_size = vertex_format & TL_FVF_XYZ ? 3 * sizeof(float) : 0;
trimesh->vertex_size += vertex_format & TL_FVF_UV ? 2 * sizeof(float) : 0;
trimesh->vertex_size += vertex_format & TL_FVF_NORMAL ? 3 * sizeof(float) : 0;
trimesh->vertices = malloc( trimesh->vertex_count * trimesh->vertex_size );
index = 0;
for( i = 0; i < trimesh->vertex_count; i++ )
{
if( vertex_format & TL_FVF_XYZ )
{
x = &trimesh->vertices[index++];
y = &trimesh->vertices[index++];
z = &trimesh->vertices[index++];
}
if( vertex_format & TL_FVF_UV )
{
u = &trimesh->vertices[index++];
v = &trimesh->vertices[index++];
}
if( vertex_format & TL_FVF_NORMAL )
{
nx = &trimesh->vertices[index++];
ny = &trimesh->vertices[index++];
nz = &trimesh->vertices[index++];
}
tl3dsGetVertex( state, i, x, y, z, u, v, nx, ny, nz );
}
return trimesh;
}
/*----------------------------------------------------------------------------*/
tlTrimesh *tlLoad3DS( const char *filename, unsigned int vertex_format )
{
FILE *f = 0;
tlTrimesh *trimesh = NULL;
if( filename == NULL )
return NULL;
f = fopen( filename, "r" );
if( f )
{
tl3dsState *state = NULL;
state = tl3dsCreateState();
if( state )
{
char buffer[1024];
unsigned int size = 0;
while( !feof( f ) )
{
size = (unsigned int) fread( buffer, 1, sizeof(buffer), f );
tl3dsParse( state, buffer, size, size < sizeof(buffer) ? 1 : 0 );
}
trimesh = tlCreateTrimeshFrom3dsState( state, vertex_format );
tl3dsDestroyState( state );
}
fclose( f );
}
return trimesh;
}
/*----------------------------------------------------------------------------*/
tlTrimesh *tlCreateTrimeshFromObjState( tlObjState *state, unsigned int vertex_format )
{
tlTrimesh *trimesh = NULL;
unsigned int i = 0, index = 0;
float *x = NULL, *y = NULL, *z = NULL;
float *u = NULL, *v = NULL;
float *nx = NULL, *ny = NULL, *nz = NULL;
if( state == NULL )
return NULL;
trimesh = malloc( sizeof(tlTrimesh) );
trimesh->object_count = tlObjObjectCount( state );
trimesh->objects = malloc( sizeof(tlObject) * trimesh->object_count );
for( i = 0; i < trimesh->object_count; i++ )
{
unsigned int length = strlen( tlObjObjectName( state, i ) ) + 1;
trimesh->objects[i].name = malloc( length );
memcpy( trimesh->objects[i].name, tlObjObjectName( state, i ), length );
trimesh->objects[i].face_index = tlObjObjectFaceIndex( state, i );
trimesh->objects[i].face_count = tlObjObjectFaceCount( state, i );
}
trimesh->face_count = tlObjFaceCount( state );
trimesh->faces = malloc( sizeof(unsigned short) * trimesh->face_count * 3 );
for( i = 0; i < trimesh->face_count; i++ )
{
unsigned int offset = i * 3;
tlObjGetFace( state, i,
&trimesh->faces[offset],
&trimesh->faces[offset + 1],
&trimesh->faces[offset + 2] );
}
trimesh->vertex_count = tlObjVertexCount( state );
trimesh->vertex_format = vertex_format;
trimesh->vertex_size = vertex_format & TL_FVF_XYZ ? 3 * sizeof(float) : 0;
trimesh->vertex_size += vertex_format & TL_FVF_UV ? 2 * sizeof(float) : 0;
trimesh->vertex_size += vertex_format & TL_FVF_NORMAL ? 3 * sizeof(float) : 0;
trimesh->vertices = malloc( trimesh->vertex_count * trimesh->vertex_size );
index = 0;
for( i = 0; i < trimesh->vertex_count; i++ )
{
if( vertex_format & TL_FVF_XYZ )
{
x = &trimesh->vertices[index++];
y = &trimesh->vertices[index++];
z = &trimesh->vertices[index++];
}
if( vertex_format & TL_FVF_UV )
{
u = &trimesh->vertices[index++];
v = &trimesh->vertices[index++];
}
if( vertex_format & TL_FVF_NORMAL )
{
nx = &trimesh->vertices[index++];
ny = &trimesh->vertices[index++];
nz = &trimesh->vertices[index++];
}
tlObjGetVertex( state, i, x, y, z, u, v, nx, ny, nz );
}
return trimesh;
}
/*----------------------------------------------------------------------------*/
tlTrimesh *tlLoadOBJ( const char *filename, unsigned int vertex_format )
{
FILE *f = 0;
tlTrimesh *trimesh = NULL;
if( filename == NULL )
return NULL;
f = fopen( filename, "r" );
if( f )
{
tlObjState *state = NULL;
state = tlObjCreateState();
if( state )
{
char buffer[1024];
unsigned int size = 0;
while( !feof( f ) )
{
size = (unsigned int) fread( buffer, 1, sizeof(buffer), f );
tlObjParse( state, buffer, size, size < sizeof(buffer) ? 1 : 0 );
}
trimesh = tlCreateTrimeshFromObjState( state, vertex_format );
tlObjDestroyState( state );
}
fclose( f );
}
return trimesh;
}
/*----------------------------------------------------------------------------*/
tlTrimesh *tlLoadTrimesh( const char* filename, unsigned int vertex_format )
{
tlTrimesh *trimesh = NULL;
if( tl3dsCheckFileExtension( filename ) == 0 )
trimesh = tlLoad3DS( filename, vertex_format );
else if( tlObjCheckFileExtension( filename ) == 0 )
trimesh = tlLoadOBJ( filename, vertex_format );
return trimesh;
}
/*----------------------------------------------------------------------------*/
void tlDeleteTrimesh( tlTrimesh *trimesh )
{
unsigned int i = 0;
if( trimesh == NULL )
return;
for( i = 0; i < trimesh->object_count; i++ )
free( trimesh->objects[i].name );
free( trimesh->objects );
free( trimesh->faces );
free( trimesh->vertices );
free( trimesh );
}