picomodel.c

Revision 275, 45.8 kB (checked in by mattn, 2 years ago)
* fixed warnings * removed www dir (dead links, almost none of the posted links are available - correct me when i'm wrong, then we can revert this remove)
Property svn:eol-style set to `native`

Line
1	/ -----------------------------------------------------------------------------*
2
3	PicoModel Library
4
5	Copyright (c) 2002, Randy Reddig & seaw0lf
6	All rights reserved.
7
8	Redistribution and use in source and binary forms, with or without modification,
9	are permitted provided that the following conditions are met:
10
11	Redistributions of source code must retain the above copyright notice, this list
12	of conditions and the following disclaimer.
13
14	Redistributions in binary form must reproduce the above copyright notice, this
15	list of conditions and the following disclaimer in the documentation and/or
16	other materials provided with the distribution.
17
18	Neither the names of the copyright holders nor the names of its contributors may
19	be used to endorse or promote products derived from this software without
20	specific prior written permission.
21
22	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
23	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
24	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25	DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
26	ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
27	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28	LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
29	ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31	SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32
33	----------------------------------------------------------------------------- /*
34
35
36
37	/ marker /
38	#define PICOMODEL_C
39
40
41
42	/ dependencies /
43	#include "picointernal.h"
44
45
46
47	/*
48	PicoInit()
49	initializes the picomodel library
50	*/
51
52	int PicoInit( void )
53	{
54	/ successfully initialized -sea /
55	return 1;
56	}
57
58
59
60	/*
61	PicoShutdown()
62	shuts the pico model library down
63	*/
64
65	void PicoShutdown( void )
66	{
67	/ do something interesting here in the future /
68	return;
69	}
70
71
72
73	/*
74	PicoError()
75	returns last picomodel error code (see PME_ defines)*
76	*/
77
78	int PicoError( void )
79	{
80	/ todo: do something here /
81	return 0;
82	}
83
84
85
86	/*
87	PicoSetMallocFunc()
88	sets the ptr to the malloc function
89	*/
90
91	void PicoSetMallocFunc( void (func)( size_t ) )
92	{
93	if( func != NULL )
94	_pico_ptr_malloc = func;
95	}
96
97
98
99	/*
100	PicoSetFreeFunc()
101	sets the ptr to the free function
102	*/
103
104	void PicoSetFreeFunc( void (func)( void** ) )
105	{
106	if( func != NULL )
107	_pico_ptr_free = func;
108	}
109
110
111
112	/*
113	PicoSetLoadFileFunc()
114	sets the ptr to the file load function
115	*/
116
117	void PicoSetLoadFileFunc( void (func)( char, unsigned char**, int*** ) )
118	{
119	if( func != NULL )
120	_pico_ptr_load_file = func;
121	}
122
123
124
125	/*
126	PicoSetFreeFileFunc()
127	sets the ptr to the free function
128	*/
129
130	void PicoSetFreeFileFunc( void (func)( void** ) )
131	{
132	if( func != NULL )
133	_pico_ptr_free_file = func;
134	}
135
136
137
138	/*
139	PicoSetPrintFunc()
140	sets the ptr to the print function
141	*/
142
143	void PicoSetPrintFunc( void (func)( int, const* char* ) )
144	{
145	if( func != NULL )
146	_pico_ptr_print = func;
147	}
148
149
150
151	/*
152	PicoLoadModel()
153	the meat and potatoes function
154	*/
155
156	picoModel_t *PicoLoadModel( char fileName, int* frameNum )
157	{
158	const picoModule_t *modules, pm;
159	picoModel_t *model;
160	picoByte_t *buffer;
161	int bufSize;
162	char modelFileName, remapFileName;
163
164
165	/ init /
166	model = NULL;
167
168	/ make sure we've got a file name /
169	if( fileName == NULL )
170	{
171	_pico_printf( PICO_ERROR, "PicoLoadModel: No filename given (fileName == NULL)" );
172	return NULL;
173	}
174
175	/ load file data (buffer is allocated by host app) /
176	_pico_load_file( fileName, &buffer, &bufSize );
177	if( bufSize < 0 )
178	{
179	_pico_printf( PICO_ERROR, "PicoLoadModel: Failed loading model %s", fileName );
180	return NULL;
181	}
182
183	/ get ptr to list of supported modules /
184	modules = PicoModuleList( NULL );
185
186	/ run it through the various loader functions and try /
187	/ to find a loader that fits the given file data /
188	for( ; *modules != NULL; modules++ )
189	{
190	/ get module /
191	pm = *modules;
192
193	/ sanity check /
194	if( pm == NULL)
195	break;
196
197	/ module must be able to load /
198	if( pm->canload == NULL \|\| pm->load == NULL )
199	continue;
200
201	/ see whether this module can load the model file or not /
202	if( pm->canload( fileName, buffer, bufSize ) == PICO_PMV_OK )
203	{
204	/ use loader provided by module to read the model data /
205	model = pm->load( fileName, frameNum, buffer, bufSize );
206	if( model == NULL )
207	{
208	_pico_free_file( buffer );
209	return NULL;
210	}
211
212	/ assign pointer to file format module /
213	model->module = pm;
214
215	/ get model file name /
216	modelFileName = PicoGetModelFileName( model );
217
218	/ apply model remappings from <model>.remap /
219	if( strlen( modelFileName ) )
220	{
221	/ alloc copy of model file name /
222	remapFileName = _pico_alloc( strlen( modelFileName ) + 20 );
223	if( remapFileName != NULL )
224	{
225	/ copy model file name and change extension /
226	strcpy( remapFileName, modelFileName );
227	_pico_setfext( remapFileName, "remap" );
228
229	/ try to remap model; we don't handle the result /
230	PicoRemapModel( model, remapFileName );
231
232	/ free the remap file name string /
233	_pico_free( remapFileName );
234	}
235	}
236
237	/ model was loaded, so break out of loop /
238	break;
239	}
240	}
241
242	/ free memory used by file buffer /
243	if( buffer)
244	_pico_free_file( buffer );
245
246	/ return /
247	return model;
248	}
249
250
251
252	/ ----------------------------------------------------------------------------*
253	models
254	---------------------------------------------------------------------------- /*
255
256	/*
257	PicoNewModel()
258	creates a new pico model
259	*/
260
261	picoModel_t *PicoNewModel( void )
262	{
263	picoModel_t *model;
264
265	/ allocate /
266	model = _pico_alloc( sizeof(picoModel_t) );
267	if( model == NULL )
268	return NULL;
269
270	/ clear /
271	memset( model,0,sizeof(picoModel_t) );
272
273	/ model set up /
274	_pico_zero_bounds( model->mins,model->maxs );
275
276	/ set initial frame count to 1 -sea /
277	model->numFrames = 1;
278
279	/ return ptr to new model /
280	return model;
281	}
282
283
284
285	/*
286	PicoFreeModel()
287	frees a model and all associated data
288	*/
289
290	void PicoFreeModel( picoModel_t *model )
291	{
292	int i;
293
294
295	/ sanity check /
296	if( model == NULL )
297	return;
298
299	/ free bits /
300	if( model->name )
301	_pico_free( model->name );
302
303	/ free shaders /
304	for( i = 0; i < model->numShaders; i++ )
305	PicoFreeShader( model->shader[ i ] );
306	free( model->shader );
307
308	/ free surfaces /
309	for( i = 0; i < model->numSurfaces; i++ )
310	PicoFreeSurface( model->surface[ i ] );
311	free( model->surface );
312
313	/ free the model /
314	_pico_free( model );
315	}
316
317
318
319	/*
320	PicoAdjustModel()
321	adjusts a models's memory allocations to handle the requested sizes.
322	will always grow, never shrink
323	*/
324
325	int PicoAdjustModel( picoModel_t model, int* numShaders, int numSurfaces )
326	{
327	/ dummy check /
328	if( model == NULL )
329	return 0;
330
331	/ bare minimums /
332	/ sea: null surface/shader fix (1s=>0s) /
333	if( numShaders < 0 )
334	numShaders = 0;
335	if( numSurfaces < 0 )
336	numSurfaces = 0;
337
338	/ additional shaders? /
339	while( numShaders > model->maxShaders )
340	{
341	model->maxShaders += PICO_GROW_SHADERS;
342	if( !_pico_realloc( (void ) &model->shader, model->numShaders sizeof( model->shader ), model->maxShaders sizeof( *model->shader ) ) )
343	return 0;
344	}
345
346	/ set shader count to higher /
347	if( numShaders > model->numShaders )
348	model->numShaders = numShaders;
349
350	/ additional surfaces? /
351	while( numSurfaces > model->maxSurfaces )
352	{
353	model->maxSurfaces += PICO_GROW_SURFACES;
354	if( !_pico_realloc( (void ) &model->surface, model->numSurfaces sizeof( model->surface ), model->maxSurfaces sizeof( *model->surface ) ) )
355	return 0;
356	}
357
358	/ set shader count to higher /
359	if( numSurfaces > model->numSurfaces )
360	model->numSurfaces = numSurfaces;
361
362	/ return ok /
363	return 1;
364	}
365
366
367
368	/ ----------------------------------------------------------------------------*
369	shaders
370	---------------------------------------------------------------------------- /*
371
372	/*
373	PicoNewShader()
374	creates a new pico shader and returns its index. -sea
375	*/
376
377	picoShader_t *PicoNewShader( picoModel_t *model )
378	{
379	picoShader_t *shader;
380
381
382	/ allocate and clear /
383	shader = _pico_alloc( sizeof(picoShader_t) );
384	if( shader == NULL )
385	return NULL;
386	memset( shader, 0, sizeof(picoShader_t) );
387
388	/ attach it to the model /
389	if( model != NULL )
390	{
391	/ adjust model /
392	if( !PicoAdjustModel( model, model->numShaders + 1, 0 ) )
393	{
394	_pico_free( shader );
395	return NULL;
396	}
397	/ attach /
398	model->shader[ model->numShaders - 1 ] = shader;
399	shader->model = model;
400	}
401	/ setup default shader colors /
402	_pico_set_color( shader->ambientColor,0,0,0,0 );
403	_pico_set_color( shader->diffuseColor,255,255,255,1 );
404	_pico_set_color( shader->specularColor,0,0,0,0 );
405
406	/ no need to do this, but i do it anyway /
407	shader->transparency = 0;
408	shader->shininess = 0;
409
410	/ return the newly created shader /
411	return shader;
412	}
413
414
415
416	/*
417	PicoFreeShader()
418	frees a shader and all associated data -sea
419	*/
420
421	void PicoFreeShader( picoShader_t *shader )
422	{
423	/ dummy check /
424	if( shader == NULL )
425	return;
426
427	/ free bits /
428	if( shader->name )
429	_pico_free( shader->name );
430	if( shader->mapName )
431	_pico_free( shader->mapName );
432
433	/ free the shader /
434	_pico_free( shader );
435	}
436
437
438
439	/*
440	PicoFindShader()
441	finds a named shader in a model
442	*/
443
444	picoShader_t *PicoFindShader( picoModel_t model, char* name, int* caseSensitive )
445	{
446	int i;
447
448
449	/ sanity checks /
450	if( model == NULL \|\| name == NULL ) / sea: null name fix /
451	return NULL;
452
453	/ walk list /
454	for( i = 0; i < model->numShaders; i++ )
455	{
456	/ skip null shaders or shaders with null names /
457	if( model->shader[ i ] == NULL \|\|
458	model->shader[ i ]->name == NULL )
459	continue;
460
461	/ compare the shader name with name we're looking for /
462	if( caseSensitive )
463	{
464	if( !strcmp( name, model->shader[ i ]->name ) )
465	return model->shader[ i ];
466	}
467	else if( !_pico_stricmp( name, model->shader[ i ]->name ) )
468	return model->shader[ i ];
469	}
470
471	/ named shader not found /
472	return NULL;
473	}
474
475
476
477	/ ----------------------------------------------------------------------------*
478	surfaces
479	---------------------------------------------------------------------------- /*
480
481	/*
482	PicoNewSurface()
483	creates a new pico surface
484	*/
485
486	picoSurface_t *PicoNewSurface( picoModel_t *model )
487	{
488	picoSurface_t *surface;
489	char surfaceName[64];
490
491	/ allocate and clear /
492	surface = _pico_alloc( sizeof( *surface ) );
493	if( surface == NULL )
494	return NULL;
495	memset( surface, 0, sizeof( *surface ) );
496
497	/ attach it to the model /
498	if( model != NULL )
499	{
500	/ adjust model /
501	if( !PicoAdjustModel( model, 0, model->numSurfaces + 1 ) )
502	{
503	_pico_free( surface );
504	return NULL;
505	}
506
507	/ attach /
508	model->surface[ model->numSurfaces - 1 ] = surface;
509	surface->model = model;
510
511	/ set default name /
512	sprintf( surfaceName, "Unnamed_%d", model->numSurfaces );
513	PicoSetSurfaceName( surface, surfaceName );
514	}
515
516	/ return /
517	return surface;
518	}
519
520
521
522	/*
523	PicoFreeSurface()
524	frees a surface and all associated data
525	*/
526	void PicoFreeSurface( picoSurface_t *surface )
527	{
528	int i;
529
530
531	/ dummy check /
532	if( surface == NULL )
533	return;
534
535	/ free bits /
536	_pico_free( surface->xyz );
537	_pico_free( surface->normal );
538	_pico_free( surface->index );
539	_pico_free( surface->faceNormal );
540
541	/ free arrays /
542	for( i = 0; i < surface->numSTArrays; i++ )
543	_pico_free( surface->st[ i ] );
544	free( surface->st );
545	for( i = 0; i < surface->numColorArrays; i++ )
546	_pico_free( surface->color[ i ] );
547	free( surface->color );
548
549	/ free the surface /
550	_pico_free( surface );
551	}
552
553
554
555	/*
556	PicoAdjustSurface()
557	adjusts a surface's memory allocations to handle the requested sizes.
558	will always grow, never shrink
559	*/
560
561	int PicoAdjustSurface( picoSurface_t surface, int* numVertexes, int numSTArrays, int numColorArrays, int numIndexes, int numFaceNormals )
562	{
563	int i;
564
565
566	/ dummy check /
567	if( surface == NULL )
568	return 0;
569
570	/ bare minimums /
571	if( numVertexes < 1 )
572	numVertexes = 1;
573	if( numSTArrays < 1 )
574	numSTArrays = 1;
575	if( numColorArrays < 1 )
576	numColorArrays = 1;
577	if( numIndexes < 1 )
578	numIndexes = 1;
579
580	/ additional vertexes? /
581	while( numVertexes > surface->maxVertexes ) / fix /
582	{
583	surface->maxVertexes += PICO_GROW_VERTEXES;
584	if( !_pico_realloc( (void ) &surface->xyz, surface->numVertexes sizeof( surface->xyz ), surface->maxVertexes sizeof( *surface->xyz ) ) )
585	return 0;
586	if( !_pico_realloc( (void ) &surface->normal, surface->numVertexes sizeof( surface->normal ), surface->maxVertexes sizeof( *surface->normal ) ) )
587	return 0;
588	for( i = 0; i < surface->numSTArrays; i++ )
589	if( !_pico_realloc( (void) &surface->st[ i ], surface->numVertexes sizeof( surface->st[ i ] ), surface->maxVertexes sizeof( *surface->st[ i ] ) ) )
590	return 0;
591	for( i = 0; i < surface->numColorArrays; i++ )
592	if( !_pico_realloc( (void) &surface->color[ i ], surface->numVertexes sizeof( surface->color[ i ] ), surface->maxVertexes sizeof( *surface->color[ i ] ) ) )
593	return 0;
594	}
595
596	/ set vertex count to higher /
597	if( numVertexes > surface->numVertexes )
598	surface->numVertexes = numVertexes;
599
600	/ additional st arrays? /
601	while( numSTArrays > surface->maxSTArrays ) / fix /
602	{
603	surface->maxSTArrays += PICO_GROW_ARRAYS;
604	if( !_pico_realloc( (void) &surface->st, surface->numSTArrays sizeof( surface->st ), surface->maxSTArrays sizeof( *surface->st ) ) )
605	return 0;
606	while( surface->numSTArrays < numSTArrays )
607	{
608	surface->st[ surface->numSTArrays ] = _pico_alloc( surface->maxVertexes * sizeof( *surface->st[ 0 ] ) );
609	memset( surface->st[ surface->numSTArrays ], 0, surface->maxVertexes * sizeof( *surface->st[ 0 ] ) );
610	surface->numSTArrays++;
611	}
612	}
613
614	/ additional color arrays? /
615	while( numColorArrays > surface->maxColorArrays ) / fix /
616	{
617	surface->maxColorArrays += PICO_GROW_ARRAYS;
618	if( !_pico_realloc( (void) &surface->color, surface->numColorArrays sizeof( surface->color ), surface->maxColorArrays sizeof( *surface->color ) ) )
619	return 0;
620	while( surface->numColorArrays < numColorArrays )
621	{
622	surface->color[ surface->numColorArrays ] = _pico_alloc( surface->maxVertexes * sizeof( *surface->color[ 0 ] ) );
623	memset( surface->color[ surface->numColorArrays ], 0, surface->maxVertexes * sizeof( *surface->color[ 0 ] ) );
624	surface->numColorArrays++;
625	}
626	}
627
628	/ additional indexes? /
629	while( numIndexes > surface->maxIndexes ) / fix /
630	{
631	surface->maxIndexes += PICO_GROW_INDEXES;
632	if( !_pico_realloc( (void) &surface->index, surface->numIndexes sizeof( surface->index ), surface->maxIndexes sizeof( *surface->index ) ) )
633	return 0;
634	}
635
636	/ set index count to higher /
637	if( numIndexes > surface->numIndexes )
638	surface->numIndexes = numIndexes;
639
640	/ additional face normals? /
641	while( numFaceNormals > surface->maxFaceNormals ) / fix /
642	{
643	surface->maxFaceNormals += PICO_GROW_FACES;
644	if( !_pico_realloc( (void ) &surface->faceNormal, surface->numFaceNormals sizeof( surface->faceNormal ), surface->maxFaceNormals sizeof( *surface->faceNormal ) ) )
645	return 0;
646	}
647
648	/ set face normal count to higher /
649	if( numFaceNormals > surface->numFaceNormals )
650	surface->numFaceNormals = numFaceNormals;
651
652	/ return ok /
653	return 1;
654	}
655
656
657	/ PicoFindSurface:*
658	* Finds first matching named surface in a model.
659	*/
660	picoSurface_t *PicoFindSurface(
661	picoModel_t model, char* name, int* caseSensitive )
662	{
663	int i;
664
665	/ sanity check /
666	if( model == NULL \|\| name == NULL )
667	return NULL;
668
669	/ walk list /
670	for( i = 0; i < model->numSurfaces; i++ )
671	{
672	/ skip null surfaces or surfaces with null names /
673	if( model->surface[ i ] == NULL \|\|
674	model->surface[ i ]->name == NULL )
675	continue;
676
677	/ compare the surface name with name we're looking for /
678	if (caseSensitive) {
679	if( !strcmp(name,model->surface[ i ]->name) )
680	return model->surface[ i ];
681	} else {
682	if( !_pico_stricmp(name,model->surface[ i ]->name) )
683	return model->surface[ i ];
684	}
685	}
686	/ named surface not found /
687	return NULL;
688	}
689
690
691
692	/----------------------------------------------------------------------------*
693	PicoSet() Setter Functions*
694	----------------------------------------------------------------------------/*
695
696	void PicoSetModelName( picoModel_t model, char* *name )
697	{
698	if( model == NULL \|\| name == NULL )
699	return;
700	if( model->name != NULL )
701	_pico_free( model->name );
702
703	model->name = _pico_clone_alloc( name,-1 );
704	}
705
706
707
708	void PicoSetModelFileName( picoModel_t model, char* *fileName )
709	{
710	if( model == NULL \|\| fileName == NULL )
711	return;
712	if( model->fileName != NULL )
713	_pico_free( model->fileName );
714
715	model->fileName = _pico_clone_alloc( fileName,-1 );
716	}
717
718
719
720	void PicoSetModelFrameNum( picoModel_t model, int* frameNum )
721	{
722	if( model == NULL )
723	return;
724	model->frameNum = frameNum;
725	}
726
727
728
729	void PicoSetModelNumFrames( picoModel_t model, int* numFrames )
730	{
731	if( model == NULL )
732	return;
733	model->numFrames = numFrames;
734	}
735
736
737
738	void PicoSetModelData( picoModel_t model, void* *data )
739	{
740	if( model == NULL )
741	return;
742	model->data = data;
743	}
744
745
746
747	void PicoSetShaderName( picoShader_t shader, char* *name )
748	{
749	if( shader == NULL \|\| name == NULL )
750	return;
751	if( shader->name != NULL )
752	_pico_free( shader->name );
753
754	shader->name = _pico_clone_alloc( name,-1 );
755	}
756
757
758
759	void PicoSetShaderMapName( picoShader_t shader, char* *mapName )
760	{
761	if( shader == NULL \|\| mapName == NULL )
762	return;
763	if( shader->mapName != NULL )
764	_pico_free( shader->mapName );
765
766	shader->mapName = _pico_clone_alloc( mapName,-1 );
767	}
768
769
770
771	void PicoSetShaderAmbientColor( picoShader_t *shader, picoColor_t color )
772	{
773	if( shader == NULL \|\| color == NULL )
774	return;
775	shader->ambientColor[ 0 ] = color[ 0 ];
776	shader->ambientColor[ 1 ] = color[ 1 ];
777	shader->ambientColor[ 2 ] = color[ 2 ];
778	shader->ambientColor[ 3 ] = color[ 3 ];
779	}
780
781
782
783	void PicoSetShaderDiffuseColor( picoShader_t *shader, picoColor_t color )
784	{
785	if( shader == NULL \|\| color == NULL )
786	return;
787	shader->diffuseColor[ 0 ] = color[ 0 ];
788	shader->diffuseColor[ 1 ] = color[ 1 ];
789	shader->diffuseColor[ 2 ] = color[ 2 ];
790	shader->diffuseColor[ 3 ] = color[ 3 ];
791	}
792
793
794
795	void PicoSetShaderSpecularColor( picoShader_t *shader, picoColor_t color )
796	{
797	if( shader == NULL \|\| color == NULL )
798	return;
799	shader->specularColor[ 0 ] = color[ 0 ];
800	shader->specularColor[ 1 ] = color[ 1 ];
801	shader->specularColor[ 2 ] = color[ 2 ];
802	shader->specularColor[ 3 ] = color[ 3 ];
803	}
804
805
806
807	void PicoSetShaderTransparency( picoShader_t shader, float* value )
808	{
809	if( shader == NULL )
810	return;
811	shader->transparency = value;
812
813	/ cap to 0..1 range /
814	if (shader->transparency < 0.0)
815	shader->transparency = 0.0;
816	if (shader->transparency > 1.0)
817	shader->transparency = 1.0;
818	}
819
820
821
822	void PicoSetShaderShininess( picoShader_t shader, float* value )
823	{
824	if( shader == NULL )
825	return;
826	shader->shininess = value;
827
828	/ cap to 0..127 range /
829	if (shader->shininess < 0.0)
830	shader->shininess = 0.0;
831	if (shader->shininess > 127.0)
832	shader->shininess = 127.0;
833	}
834
835
836
837	void PicoSetSurfaceData( picoSurface_t surface, void* *data )
838	{
839	if( surface == NULL )
840	return;
841	surface->data = data;
842	}
843
844
845
846	void PicoSetSurfaceType( picoSurface_t *surface, picoSurfaceType_t type )
847	{
848	if( surface == NULL )
849	return;
850	surface->type = type;
851	}
852
853
854
855	void PicoSetSurfaceName( picoSurface_t surface, char* *name )
856	{
857	if( surface == NULL \|\| name == NULL )
858	return;
859	if( surface->name != NULL )
860	_pico_free( surface->name );
861
862	surface->name = _pico_clone_alloc( name,-1 );
863	}
864
865
866
867	void PicoSetSurfaceShader( picoSurface_t surface, picoShader_t shader )
868	{
869	if( surface == NULL )
870	return;
871	surface->shader = shader;
872	}
873
874
875
876	void PicoSetSurfaceXYZ( picoSurface_t surface, int* num, picoVec3_t xyz )
877	{
878	if( surface == NULL \|\| num < 0 \|\| xyz == NULL )
879	return;
880	if( !PicoAdjustSurface( surface, num + 1, 0, 0, 0, 0 ) )
881	return;
882	_pico_copy_vec( xyz, surface->xyz[ num ] );
883	if( surface->model != NULL )
884	_pico_expand_bounds( xyz, surface->model->mins, surface->model->maxs );
885	}
886
887
888
889	void PicoSetSurfaceNormal( picoSurface_t surface, int* num, picoVec3_t normal )
890	{
891	if( surface == NULL \|\| num < 0 \|\| normal == NULL )
892	return;
893	if( !PicoAdjustSurface( surface, num + 1, 0, 0, 0, 0 ) )
894	return;
895	_pico_copy_vec( normal, surface->normal[ num ] );
896	}
897
898
899
900	void PicoSetSurfaceST( picoSurface_t surface, int* array, int num, picoVec2_t st )
901	{
902	if( surface == NULL \|\| num < 0 \|\| st == NULL )
903	return;
904	if( !PicoAdjustSurface( surface, num + 1, array + 1, 0, 0, 0 ) )
905	return;
906	surface->st[ array ][ num ][ 0 ] = st[ 0 ];
907	surface->st[ array ][ num ][ 1 ] = st[ 1 ];
908	}
909
910
911
912	void PicoSetSurfaceColor( picoSurface_t surface, int* array, int num, picoColor_t color )
913	{
914	if( surface == NULL \|\| num < 0 \|\| color == NULL )
915	return;
916	if( !PicoAdjustSurface( surface, num + 1, 0, array + 1, 0, 0 ) )
917	return;
918	surface->color[ array ][ num ][ 0 ] = color[ 0 ];
919	surface->color[ array ][ num ][ 1 ] = color[ 1 ];
920	surface->color[ array ][ num ][ 2 ] = color[ 2 ];
921	surface->color[ array ][ num ][ 3 ] = color[ 3 ];
922	}
923
924
925
926	void PicoSetSurfaceIndex( picoSurface_t surface, int* num, picoIndex_t index )
927	{
928	if( surface == NULL \|\| num < 0 )
929	return;
930	if( !PicoAdjustSurface( surface, 0, 0, 0, num + 1, 0 ) )
931	return;
932	surface->index[ num ] = index;
933	}
934
935
936
937	void PicoSetSurfaceIndexes( picoSurface_t surface, int* num, picoIndex_t index, int* count )
938	{
939	if( num < 0 \|\| index == NULL \|\| count < 1 )
940	return;
941	if( !PicoAdjustSurface( surface, 0, 0, 0, num + count, 0 ) )
942	return;
943	memcpy( &surface->index[ num ], index, count * sizeof( surface->index[ num ] ) );
944	}
945
946
947
948	void PicoSetFaceNormal( picoSurface_t surface, int* num, picoVec3_t normal )
949	{
950	if( surface == NULL \|\| num < 0 \|\| normal == NULL )
951	return;
952	if( !PicoAdjustSurface( surface, 0, 0, 0, 0, num + 1 ) )
953	return;
954	_pico_copy_vec( normal, surface->faceNormal[ num ] );
955	}
956
957
958	void PicoSetSurfaceSpecial( picoSurface_t surface, int* num, int special )
959	{
960	if( surface == NULL \|\| num < 0 \|\| num >= PICO_MAX_SPECIAL )
961	return;
962	surface->special[ num ] = special;
963	}
964
965
966
967	/----------------------------------------------------------------------------*
968	PicoGet() Getter Functions*
969	----------------------------------------------------------------------------/*
970
971	char *PicoGetModelName( picoModel_t *model )
972	{
973	if( model == NULL )
974	return NULL;
975	if( model->name == NULL)
976	return (char*) "";
977	return model->name;
978	}
979
980
981
982	char *PicoGetModelFileName( picoModel_t *model )
983	{
984	if( model == NULL )
985	return NULL;
986	if( model->fileName == NULL)
987	return (char*) "";
988	return model->fileName;
989	}
990
991
992
993	int PicoGetModelFrameNum( picoModel_t *model )
994	{
995	if( model == NULL )
996	return 0;
997	return model->frameNum;
998	}
999
1000
1001
1002	int PicoGetModelNumFrames( picoModel_t *model )
1003	{
1004	if( model == NULL )
1005	return 0;
1006	return model->numFrames;
1007	}
1008
1009
1010
1011	void *PicoGetModelData( picoModel_t *model )
1012	{
1013	if( model == NULL )
1014	return NULL;
1015	return model->data;
1016	}
1017
1018
1019
1020	int PicoGetModelNumShaders( picoModel_t *model )
1021	{
1022	if( model == NULL )
1023	return 0;
1024	return model->numShaders;
1025	}
1026
1027
1028
1029	picoShader_t *PicoGetModelShader( picoModel_t model, int* num )
1030	{
1031	/ a few sanity checks /
1032	if( model == NULL )
1033	return NULL;
1034	if( model->shader == NULL)
1035	return NULL;
1036	if( num < 0 \|\| num >= model->numShaders )
1037	return NULL;
1038
1039	/ return the shader /
1040	return model->shader[ num ];
1041	}
1042
1043
1044
1045	int PicoGetModelNumSurfaces( picoModel_t *model )
1046	{
1047	if( model == NULL )
1048	return 0;
1049	return model->numSurfaces;
1050	}
1051
1052
1053
1054	picoSurface_t *PicoGetModelSurface( picoModel_t model, int* num )
1055	{
1056	/ a few sanity checks /
1057	if( model == NULL )
1058	return NULL;
1059	if( model->surface == NULL)
1060	return NULL;
1061	if( num < 0 \|\| num >= model->numSurfaces )
1062	return NULL;
1063
1064	/ return the surface /
1065	return model->surface[ num ];
1066	}
1067
1068
1069
1070	int PicoGetModelTotalVertexes( picoModel_t *model )
1071	{
1072	int i, count;
1073
1074
1075	if( model == NULL )
1076	return 0;
1077	if( model->surface == NULL )
1078	return 0;
1079
1080	count = 0;
1081	for( i = 0; i < model->numSurfaces; i++ )
1082	count += PicoGetSurfaceNumVertexes( model->surface[ i ] );
1083
1084	return count;
1085	}
1086
1087
1088
1089	int PicoGetModelTotalIndexes( picoModel_t *model )
1090	{
1091	int i, count;
1092
1093
1094	if( model == NULL )
1095	return 0;
1096	if( model->surface == NULL )
1097	return 0;
1098
1099	count = 0;
1100	for( i = 0; i < model->numSurfaces; i++ )
1101	count += PicoGetSurfaceNumIndexes( model->surface[ i ] );
1102
1103	return count;
1104	}
1105
1106
1107
1108	char *PicoGetShaderName( picoShader_t *shader )
1109	{
1110	if( shader == NULL )
1111	return NULL;
1112	if( shader->name == NULL)
1113	return (char*) "";
1114	return shader->name;
1115	}
1116
1117
1118
1119	char *PicoGetShaderMapName( picoShader_t *shader )
1120	{
1121	if( shader == NULL )
1122	return NULL;
1123	if( shader->mapName == NULL)
1124	return (char*) "";
1125	return shader->mapName;
1126	}
1127
1128
1129
1130	picoByte_t *PicoGetShaderAmbientColor( picoShader_t *shader )
1131	{
1132	if( shader == NULL )
1133	return NULL;
1134	return shader->ambientColor;
1135	}
1136
1137
1138
1139	picoByte_t *PicoGetShaderDiffuseColor( picoShader_t *shader )
1140	{
1141	if( shader == NULL )
1142	return NULL;
1143	return shader->diffuseColor;
1144	}
1145
1146
1147
1148	picoByte_t *PicoGetShaderSpecularColor( picoShader_t *shader )
1149	{
1150	if( shader == NULL )
1151	return NULL;
1152	return shader->specularColor;
1153	}
1154
1155
1156
1157	float PicoGetShaderTransparency( picoShader_t *shader )
1158	{
1159	if( shader == NULL )
1160	return 0.0f;
1161	return shader->transparency;
1162	}
1163
1164
1165
1166	float PicoGetShaderShininess( picoShader_t *shader )
1167	{
1168	if( shader == NULL )
1169	return 0.0f;
1170	return shader->shininess;
1171	}
1172
1173
1174
1175	void *PicoGetSurfaceData( picoSurface_t *surface )
1176	{
1177	if( surface == NULL )
1178	return NULL;
1179	return surface->data;
1180	}
1181
1182
1183
1184	picoSurfaceType_t PicoGetSurfaceType( picoSurface_t *surface )
1185	{
1186	if( surface == NULL )
1187	return PICO_BAD;
1188	return surface->type;
1189	}
1190
1191
1192
1193	char *PicoGetSurfaceName( picoSurface_t *surface )
1194	{
1195	if( surface == NULL )
1196	return NULL;
1197	if( surface->name == NULL )
1198	return (char*) "";
1199	return surface->name;
1200	}
1201
1202
1203
1204	picoShader_t *PicoGetSurfaceShader( picoSurface_t *surface )
1205	{
1206	if( surface == NULL )
1207	return NULL;
1208	return surface->shader;
1209	}
1210
1211
1212
1213	int PicoGetSurfaceNumVertexes( picoSurface_t *surface )
1214	{
1215	if( surface == NULL )
1216	return 0;
1217	return surface->numVertexes;
1218	}
1219
1220
1221
1222	picoVec_t *PicoGetSurfaceXYZ( picoSurface_t surface, int* num )
1223	{
1224	if( surface == NULL \|\| num < 0 \|\| num > surface->numVertexes )
1225	return NULL;
1226	return surface->xyz[ num ];
1227	}
1228
1229
1230
1231	picoVec_t *PicoGetSurfaceNormal( picoSurface_t surface, int* num )
1232	{
1233	if( surface == NULL \|\| num < 0 \|\| num > surface->numVertexes )
1234	return NULL;
1235	return surface->normal[ num ];
1236	}
1237
1238
1239
1240	picoVec_t *PicoGetSurfaceST( picoSurface_t surface, int* array, int num )
1241	{
1242	if( surface == NULL \|\| array < 0 \|\| array > surface->numSTArrays \|\| num < 0 \|\| num > surface->numVertexes )
1243	return NULL;
1244	return surface->st[ array ][ num ];
1245	}
1246
1247
1248
1249	picoByte_t *PicoGetSurfaceColor( picoSurface_t surface, int* array, int num )
1250	{
1251	if( surface == NULL \|\| array < 0 \|\| array > surface->numColorArrays \|\| num < 0 \|\| num > surface->numVertexes )
1252	return NULL;
1253	return surface->color[ array ][ num ];
1254	}
1255
1256
1257
1258	int PicoGetSurfaceNumIndexes( picoSurface_t *surface )
1259	{
1260	if( surface == NULL )
1261	return 0;
1262	return surface->numIndexes;
1263	}
1264
1265
1266
1267	picoIndex_t PicoGetSurfaceIndex( picoSurface_t surface, int* num )
1268	{
1269	if( surface == NULL \|\| num < 0 \|\| num > surface->numIndexes )
1270	return 0;
1271	return surface->index[ num ];
1272	}
1273
1274
1275
1276	picoIndex_t *PicoGetSurfaceIndexes( picoSurface_t surface, int* num )
1277	{
1278	if( surface == NULL \|\| num < 0 \|\| num > surface->numIndexes )
1279	return NULL;
1280	return &surface->index[ num ];
1281	}
1282
1283
1284	picoVec_t *PicoGetFaceNormal( picoSurface_t surface, int* num )
1285	{
1286	if( surface == NULL \|\| num < 0 \|\| num > surface->numFaceNormals )
1287	return NULL;
1288	return surface->faceNormal[ num ];
1289	}
1290
1291
1292	int PicoGetSurfaceSpecial( picoSurface_t surface, int* num )
1293	{
1294	if( surface == NULL \|\| num < 0 \|\| num >= PICO_MAX_SPECIAL )
1295	return 0;
1296	return surface->special[ num ];
1297	}
1298
1299
1300
1301	/ ----------------------------------------------------------------------------*
1302	hashtable related functions
1303	---------------------------------------------------------------------------- /*
1304
1305	/ hashtable code for faster vertex lookups /
1306	//#define HASHTABLE_SIZE 32768 // 2048 / power of 2, use & /
1307	#define HASHTABLE_SIZE 7919 // 32749 // 2039 / prime, use % /
1308
1309	int PicoGetHashTableSize( void )
1310	{
1311	return HASHTABLE_SIZE;
1312	}
1313
1314	#define HASH_USE_EPSILON
1315
1316	#ifdef HASH_USE_EPSILON
1317	#define HASH_XYZ_EPSILON 0.01f
1318	#define HASH_XYZ_EPSILONSPACE_MULTIPLIER 1.f / HASH_XYZ_EPSILON
1319	#define HASH_ST_EPSILON 0.0001f
1320	#define HASH_NORMAL_EPSILON 0.02f
1321	#endif
1322
1323	unsigned int PicoVertexCoordGenerateHash( picoVec3_t xyz )
1324	{
1325	unsigned int hash = 0;
1326
1327	#ifndef HASH_USE_EPSILON
1328	hash += ~(((unsigned* int*) &xyz[ 0 ]) << 15);
1329	hash ^= (((unsigned* int*) &xyz[ 0 ]) >> 10);
1330	hash += (((unsigned* int*) &xyz[ 1 ]) << 3);
1331	hash ^= (((unsigned* int*) &xyz[ 1 ]) >> 6);
1332	hash += ~(((unsigned* int*) &xyz[ 2 ]) << 11);
1333	hash ^= (((unsigned* int*) &xyz[ 2 ]) >> 16);
1334	#else
1335	picoVec3_t xyz_epsilonspace;
1336
1337	_pico_scale_vec( xyz, HASH_XYZ_EPSILONSPACE_MULTIPLIER, xyz_epsilonspace );
1338	xyz_epsilonspace[ 0 ] = (float)floor(xyz_epsilonspace[ 0 ]);
1339	xyz_epsilonspace[ 1 ] = (float)floor(xyz_epsilonspace[ 1 ]);
1340	xyz_epsilonspace[ 2 ] = (float)floor(xyz_epsilonspace[ 2 ]);
1341
1342	hash += ~(((unsigned* int*) &xyz_epsilonspace[ 0 ]) << 15);
1343	hash ^= (((unsigned* int*) &xyz_epsilonspace[ 0 ]) >> 10);
1344	hash += (((unsigned* int*) &xyz_epsilonspace[ 1 ]) << 3);
1345	hash ^= (((unsigned* int*) &xyz_epsilonspace[ 1 ]) >> 6);
1346	hash += ~(((unsigned* int*) &xyz_epsilonspace[ 2 ]) << 11);
1347	hash ^= (((unsigned* int*) &xyz_epsilonspace[ 2 ]) >> 16);
1348	#endif
1349
1350	//hash = hash & (HASHTABLE_SIZE-1);
1351	hash = hash % (HASHTABLE_SIZE);
1352	return hash;
1353	}
1354
1355	picoVertexCombinationHash_t **PicoNewVertexCombinationHashTable( void )
1356	{
1357	picoVertexCombinationHash_t *hashTable = _pico_alloc( HASHTABLE_SIZE sizeof(picoVertexCombinationHash_t*) );
1358
1359	memset( hashTable, 0, HASHTABLE_SIZE * sizeof(picoVertexCombinationHash_t*) );
1360
1361	return hashTable;
1362	}
1363
1364	void PicoFreeVertexCombinationHashTable( picoVertexCombinationHash_t **hashTable )
1365	{
1366	int i;
1367	picoVertexCombinationHash_t *vertexCombinationHash;
1368	picoVertexCombinationHash_t *nextVertexCombinationHash;
1369
1370	/ dummy check /
1371	if (hashTable == NULL)
1372	return;
1373
1374	for( i = 0; i < HASHTABLE_SIZE; i++ )
1375	{
1376	if (hashTable[ i ])
1377	{
1378	nextVertexCombinationHash = NULL;
1379
1380	for( vertexCombinationHash = hashTable[ i ]; vertexCombinationHash; vertexCombinationHash = nextVertexCombinationHash )
1381	{
1382	nextVertexCombinationHash = vertexCombinationHash->next;
1383	if (vertexCombinationHash->data != NULL)
1384	{
1385	_pico_free( vertexCombinationHash->data );
1386	}
1387	_pico_free( vertexCombinationHash );
1388	}
1389	}
1390	}
1391
1392	_pico_free( hashTable );
1393	}
1394
1395	picoVertexCombinationHash_t *PicoFindVertexCombinationInHashTable( picoVertexCombinationHash_t **hashTable, picoVec3_t xyz, picoVec3_t normal, picoVec3_t st, picoColor_t color )
1396	{
1397	unsigned int hash;
1398	picoVertexCombinationHash_t *vertexCombinationHash;
1399
1400	/ dumy check /
1401	if (hashTable == NULL \|\| xyz == NULL \|\| normal == NULL \|\| st == NULL \|\| color == NULL )
1402	return NULL;
1403
1404	hash = PicoVertexCoordGenerateHash( xyz );
1405
1406	for( vertexCombinationHash = hashTable[ hash ]; vertexCombinationHash; vertexCombinationHash = vertexCombinationHash->next )
1407	{
1408	#ifndef HASH_USE_EPSILON
1409	/ check xyz /
1410	if( (vertexCombinationHash->vcd.xyz[ 0 ] != xyz[ 0 ] \|\| vertexCombinationHash->vcd.xyz[ 1 ] != xyz[ 1 ] \|\| vertexCombinationHash->vcd.xyz[ 2 ] != xyz[ 2 ]) )
1411	continue;
1412
1413	/ check normal /
1414	if( (vertexCombinationHash->vcd.normal[ 0 ] != normal[ 0 ] \|\| vertexCombinationHash->vcd.normal[ 1 ] != normal[ 1 ] \|\| vertexCombinationHash->vcd.normal[ 2 ] != normal[ 2 ]) )
1415	continue;
1416
1417	/ check st /
1418	if( vertexCombinationHash->vcd.st[ 0 ] != st[ 0 ] \|\| vertexCombinationHash->vcd.st[ 1 ] != st[ 1 ] )
1419	continue;
1420	#else
1421	/ check xyz /
1422	if( ( fabs(xyz[ 0 ] - vertexCombinationHash->vcd.xyz[ 0 ]) ) > HASH_XYZ_EPSILON \|\|
1423	( fabs(xyz[ 1 ] - vertexCombinationHash->vcd.xyz[ 1 ]) ) > HASH_XYZ_EPSILON \|\|
1424	( fabs(xyz[ 2 ] - vertexCombinationHash->vcd.xyz[ 2 ]) ) > HASH_XYZ_EPSILON )
1425	continue;
1426
1427	/ check normal /
1428	if( ( fabs(normal[ 0 ] - vertexCombinationHash->vcd.normal[ 0 ]) ) > HASH_NORMAL_EPSILON \|\|
1429	( fabs(normal[ 1 ] - vertexCombinationHash->vcd.normal[ 1 ]) ) > HASH_NORMAL_EPSILON \|\|
1430	( fabs(normal[ 2 ] - vertexCombinationHash->vcd.normal[ 2 ]) ) > HASH_NORMAL_EPSILON )
1431	continue;
1432
1433	/ check st /
1434	if( ( fabs(st[ 0 ] - vertexCombinationHash->vcd.st[ 0 ]) ) > HASH_ST_EPSILON \|\|
1435	( fabs(st[ 1 ] - vertexCombinationHash->vcd.st[ 1 ]) ) > HASH_ST_EPSILON )
1436	continue;
1437	#endif
1438
1439	/ check color /
1440	if( ((int*) vertexCombinationHash->vcd.color) != ((int*) color) )
1441	continue;
1442
1443	/ gotcha /
1444	return vertexCombinationHash;
1445	}
1446
1447	return NULL;
1448	}
1449
1450	picoVertexCombinationHash_t *PicoAddVertexCombinationToHashTable( picoVertexCombinationHash_t **hashTable, picoVec3_t xyz, picoVec3_t normal, picoVec3_t st, picoColor_t color, picoIndex_t index )
1451	{
1452	unsigned int hash;
1453	picoVertexCombinationHash_t *vertexCombinationHash;
1454
1455	/ dumy check /
1456	if (hashTable == NULL \|\| xyz == NULL \|\| normal == NULL \|\| st == NULL \|\| color == NULL )
1457	return NULL;
1458
1459	vertexCombinationHash = _pico_alloc( sizeof(picoVertexCombinationHash_t) );
1460
1461	if (!vertexCombinationHash)
1462	return NULL;
1463
1464	hash = PicoVertexCoordGenerateHash( xyz );
1465
1466	_pico_copy_vec( xyz, vertexCombinationHash->vcd.xyz );
1467	_pico_copy_vec( normal, vertexCombinationHash->vcd.normal );
1468	_pico_copy_vec2( st, vertexCombinationHash->vcd.st );
1469	_pico_copy_color( color, vertexCombinationHash->vcd.color );
1470	vertexCombinationHash->index = index;
1471	vertexCombinationHash->data = NULL;
1472	vertexCombinationHash->next = hashTable[ hash ];
1473	hashTable[ hash ] = vertexCombinationHash;
1474
1475	return vertexCombinationHash;
1476	}
1477
1478	/ ----------------------------------------------------------------------------*
1479	specialized routines
1480	---------------------------------------------------------------------------- /*
1481
1482	/*
1483	PicoFindSurfaceVertex()
1484	finds a vertex matching the set parameters
1485	fixme: needs non-naive algorithm
1486	*/
1487
1488	int PicoFindSurfaceVertexNum( picoSurface_t surface, picoVec3_t xyz, picoVec3_t normal, int* numSTs, picoVec2_t st, int* numColors, picoColor_t *color )
1489	{
1490	int i, j;
1491
1492
1493	/ dummy check /
1494	if( surface == NULL \|\| surface->numVertexes <= 0 )
1495	return -1;
1496
1497	/ walk vertex list /
1498	for( i = 0; i < surface->numVertexes; i++ )
1499	{
1500	/ check xyz /
1501	if( xyz != NULL && (surface->xyz[ i ][ 0 ] != xyz[ 0 ] \|\| surface->xyz[ i ][ 1 ] != xyz[ 1 ] \|\| surface->xyz[ i ][ 2 ] != xyz[ 2 ]) )
1502	continue;
1503
1504	/ check normal /
1505	if( normal != NULL && (surface->normal[ i ][ 0 ] != normal[ 0 ] \|\| surface->normal[ i ][ 1 ] != normal[ 1 ] \|\| surface->normal[ i ][ 2 ] != normal[ 2 ]) )
1506	continue;
1507
1508	/ check st /
1509	if( numSTs > 0 && st != NULL )
1510	{
1511	for( j = 0; j < numSTs; j++ )
1512	{
1513	if( surface->st[ j ][ i ][ 0 ] != st[ j ][ 0 ] \|\| surface->st[ j ][ i ][ 1 ] != st[ j ][ 1 ] )
1514	break;
1515	}
1516	if( j != numSTs )
1517	continue;
1518	}
1519
1520	/ check color /
1521	if( numColors > 0 && color != NULL )
1522	{
1523	for( j = 0; j < numSTs; j++ )
1524	{
1525	if( ((int*) surface->color[ j ]) != ((int*) color[ j ]) )
1526	break;
1527	}
1528	if( j != numColors )
1529	continue;
1530	}
1531
1532	/ vertex matches /
1533	return i;
1534	}
1535
1536	/ nada /
1537	return -1;
1538	}
1539
1540
1541
1542	/*
1543	PicoFixSurfaceNormals()
1544	fixes broken normals (certain formats bork normals)
1545	*/
1546
1547	#define MAX_NORMAL_VOTES 128
1548	#define EQUAL_NORMAL_EPSILON 0.01
1549	#define BAD_NORMAL_EPSILON 0.5
1550
1551	void PicoFixSurfaceNormals( picoSurface_t *surface )
1552	{
1553	int i, j, k, a, b, c, numVotes, faceIndex;
1554	picoVec3_t votes[ MAX_NORMAL_VOTES ];
1555	picoVec3_t *normals, diff;
1556	picoVec4_t plane;
1557
1558
1559	/ dummy check /
1560	if( surface == NULL \|\| surface->numVertexes == 0 )
1561	return;
1562
1563	/ fixme: handle other surface types /
1564	if( surface->type != PICO_TRIANGLES )
1565	return;
1566
1567	/ allocate normal storage /
1568	normals = _pico_alloc( surface->numVertexes * sizeof( *normals ) );
1569	if( normals == NULL )
1570	{
1571	_pico_printf( PICO_ERROR, "PicoFixSurfaceNormals: Unable to allocate memory for temporary normal storage" );
1572	return;
1573	}
1574
1575	/ zero it out /
1576	memset( normals, 0, surface->numVertexes * sizeof( *normals ) );
1577
1578	/ walk vertex list /
1579	for( i = 0; i < surface->numVertexes; i++ )
1580	{
1581	/ zero out votes /
1582	numVotes = 0;
1583
1584	/ find all the triangles that reference this vertex /
1585	for( j = 0, faceIndex = 0; j < surface->numIndexes; j += 3, faceIndex++ )
1586	{
1587	/ get triangle /
1588	a = surface->index[ j ];
1589	b = surface->index[ j + 1 ];
1590	c = surface->index[ j + 2 ];
1591
1592	/ ignore degenerate triangles /
1593	if( a == b \|\| b == c \|\| c == a )
1594	continue;
1595
1596	/ ignore indexes out of range /
1597	if( a < 0 \|\| a >= surface->numVertexes \|\|
1598	b < 0 \|\| b >= surface->numVertexes \|\|
1599	c < 0 \|\| c >= surface->numVertexes )
1600	continue;
1601
1602	/ test triangle /
1603	if( a == i \|\| b == i \|\| c == i )
1604	{
1605	/ if this surface has face normals /
1606	if( surface->numFaceNormals && faceIndex < surface->numFaceNormals )
1607	{
1608	_pico_copy_vec( surface->faceNormal[ faceIndex ], plane );
1609	if( plane[ 0 ] == 0.f && plane[ 1 ] == 0.f && plane[ 2 ] == 0.f )
1610	{
1611	/ if null normal, make plane from the 3 points /
1612	if( _pico_calc_plane( plane, surface->xyz[ a ], surface->xyz[ b ], surface->xyz[ c ] ) == 0 )
1613	{
1614	continue;
1615	}
1616	}
1617	}
1618	/ make a plane from the 3 points /
1619	else if( _pico_calc_plane( plane, surface->xyz[ a ], surface->xyz[ b ], surface->xyz[ c ] ) == 0 )
1620	{
1621	continue;
1622	}
1623
1624	/ see if this normal has already been voted /
1625	for( k = 0; k < numVotes; k++ )
1626	{
1627	_pico_subtract_vec( plane, votes[ k ], diff );
1628	if( fabs( diff[ 0 ] ) < EQUAL_NORMAL_EPSILON &&
1629	fabs( diff[ 1 ] ) < EQUAL_NORMAL_EPSILON &&
1630	fabs( diff[ 2 ] ) < EQUAL_NORMAL_EPSILON )
1631	break;
1632	}
1633
1634	/ add a new vote? /
1635	if( k == numVotes && numVotes < MAX_NORMAL_VOTES )
1636	{
1637	_pico_copy_vec( plane, votes[ numVotes ] );
1638	numVotes++;
1639	}
1640	}
1641	}
1642
1643	/ tally votes /
1644	if( numVotes > 0 )
1645	{
1646	/ create average normal /
1647	_pico_zero_vec( normals[ i ] );
1648	for( k = 0; k < numVotes; k++ )
1649	_pico_add_vec( normals[ i ], votes[ k ], normals[ i ] );
1650
1651	/ normalize it /
1652	if( _pico_normalize_vec( normals[ i ] ) )
1653	{
1654	/ test against actual normal /
1655	if( fabs( _pico_dot_vec( normals[ i ], surface->normal[ i ] ) - 1 ) > BAD_NORMAL_EPSILON )
1656	{
1657	//% printf( "Normal %8d: (%f %f %f) -> (%f %f %f)\n", i,
1658	//% surface->normal[ i ][ 0 ], surface->normal[ i ][ 1 ], surface->normal[ i ][ 2 ],
1659	//% normals[ i ][ 0 ], normals[ i ][ 1 ], normals[ i ][ 2 ] );
1660	_pico_copy_vec( normals[ i ], surface->normal[ i ] );
1661	}
1662	}
1663	}
1664	}
1665
1666	/ free normal storage /
1667	_pico_free( normals );
1668	}
1669
1670
1671
1672
1673	/*
1674	PicoRemapModel() - sea
1675	remaps model material/etc. information using the remappings
1676	contained in the given 'remapFile' (full path to the ascii file to open)
1677	returns 1 on success or 0 on error
1678	*/
1679
1680	#define _prm_error_return \
1681	{ \
1682	_pico_free_parser( p ); \
1683	_pico_free_file( remapBuffer ); \
1684	return 0; \
1685	}
1686
1687	int PicoRemapModel( picoModel_t model, char* *remapFile )
1688	{
1689	picoParser_t *p;
1690	picoByte_t *remapBuffer;
1691	int remapBufSize;
1692
1693
1694	/ sanity checks /
1695	if( model == NULL \|\| remapFile == NULL )
1696	return 0;
1697
1698	/ load remap file contents /
1699	_pico_load_file( remapFile,&remapBuffer,&remapBufSize );
1700
1701	/ check result /
1702	if( remapBufSize == 0 )
1703	return 1; / file is empty: no error /
1704	if( remapBufSize < 0 )
1705	return 0; / load failed: error /
1706
1707	/ create a new pico parser /
1708	p = _pico_new_parser( remapBuffer, remapBufSize );
1709	if (p == NULL)
1710	{
1711	/ ram is really cheap nowadays... /
1712	_prm_error_return;
1713	}
1714
1715	/ doo teh parse /
1716	while( 1 )
1717	{
1718	/ get next token in remap file /
1719	if (!_pico_parse( p,1 ))
1720	break;
1721
1722	/ skip over c++ style comment lines /
1723	if (!_pico_stricmp(p->token,"//"))
1724	{
1725	_pico_parse_skip_rest( p );
1726	continue;
1727	}
1728
1729	/ block for quick material shader name remapping /
1730	/ materials { "m" (=>\|->\|=) "s" } /
1731	if( !_pico_stricmp(p->token, "materials" ) )
1732	{
1733	int level = 1;
1734
1735	/ check bracket /
1736	if (!_pico_parse_check( p,1,"{" ))
1737	_prm_error_return;
1738
1739	/ process assignments /
1740	while( 1 )
1741	{
1742	picoShader_t *shader;
1743	char *materialName;
1744
1745
1746	/ get material name /
1747	if (_pico_parse( p,1 ) == NULL) break;
1748	if (!strlen(p->token)) continue;
1749	materialName = _pico_clone_alloc( p->token,-1 );
1750	if (materialName == NULL)
1751	_prm_error_return;
1752
1753	/ handle levels /
1754	if (p->token[0] == '{') level++;
1755	if (p->token[0] == '}') level--;
1756	if (!level) break;
1757
1758	/ get next token (assignment token or shader name) /
1759	if (!_pico_parse( p,0 ))
1760	{
1761	_pico_free( materialName );
1762	_prm_error_return;
1763	}
1764	/ skip assignment token (if present) /
1765	if (!strcmp(p->token,"=>") \|\|
1766	!strcmp(p->token,"->") \|\|
1767	!strcmp(p->token,"="))
1768	{
1769	/ simply grab the next token /
1770	if (!_pico_parse( p,0 ))
1771	{
1772	_pico_free( materialName );
1773	_prm_error_return;
1774	}
1775	}
1776	/ try to find material by name /
1777	shader = PicoFindShader( model,materialName,0 );
1778
1779	/ we've found a material matching the name /
1780	if (shader != NULL)
1781	{
1782	PicoSetShaderName( shader,p->token );
1783	}
1784	/ free memory used by material name /
1785	_pico_free( materialName );
1786
1787	/ skip rest /
1788	_pico_parse_skip_rest( p );
1789	}
1790	}
1791	/ block for detailed single material remappings /
1792	/ materials[ "m" ] { key data... } /
1793	else if (!_pico_stricmp(p->token,"materials["))
1794	{
1795	picoShader_t *shader;
1796	char *tempMaterialName;
1797	int level = 1;
1798
1799	/ get material name /
1800	if (!_pico_parse( p,0 ))
1801	_prm_error_return;
1802
1803	/ temporary copy of material name /
1804	tempMaterialName = _pico_clone_alloc( p->token,-1 );
1805	if (tempMaterialName == NULL)
1806	_prm_error_return;
1807
1808	/ check square closing bracket /
1809	if (!_pico_parse_check( p,0,"]" ))
1810	_prm_error_return;
1811
1812	/ try to find material by name /
1813	shader = PicoFindShader( model,tempMaterialName,0 );
1814
1815	/ free memory used by temporary material name /
1816	_pico_free( tempMaterialName );
1817
1818	/ we haven't found a material matching the name /
1819	/ so we simply skip the braced section now and /
1820	/ continue parsing with the next main token /
1821	if (shader == NULL)
1822	{
1823	_pico_parse_skip_braced( p );
1824	continue;
1825	}
1826	/ check opening bracket /
1827	if (!_pico_parse_check( p,1,"{" ))
1828	_prm_error_return;
1829
1830	/ process material info keys /
1831	while( 1 )
1832	{
1833	/ get key name /
1834	if (_pico_parse( p,1 ) == NULL) break;
1835	if (!strlen(p->token)) continue;
1836
1837	/ handle levels /
1838	if (p->token[0] == '{') level++;
1839	if (p->token[0] == '}') level--;
1840	if (!level) break;
1841
1842	/ remap shader name /
1843	if (!_pico_stricmp(p->token,"shader"))
1844	{
1845	if (!_pico_parse( p,0 )) _prm_error_return;
1846	PicoSetShaderName( shader,p->token );
1847	}
1848	/ remap shader map name /
1849	else if (!_pico_stricmp(p->token,"mapname"))
1850	{
1851	if (!_pico_parse( p,0 )) _prm_error_return;
1852	PicoSetShaderMapName( shader,p->token );
1853	}
1854	/ remap shader's ambient color /
1855	else if (!_pico_stricmp(p->token,"ambient"))
1856	{
1857	picoColor_t color;
1858	picoVec3_t v;
1859
1860	/ get vector from parser /
1861	if (!_pico_parse_vec( p,v )) _prm_error_return;
1862
1863	/ store as color /
1864	color[ 0 ] = (picoByte_t)v[ 0 ];
1865	color[ 1 ] = (picoByte_t)v[ 1 ];
1866	color[ 2 ] = (picoByte_t)v[ 2 ];
1867	color[ 3 ] = 1;
1868
1869	/ set new ambient color /
1870	PicoSetShaderAmbientColor( shader,color );
1871	}
1872	/ remap shader's diffuse color /
1873	else if (!_pico_stricmp(p->token,"diffuse"))
1874	{
1875	picoColor_t color;
1876	picoVec3_t v;
1877
1878	/ get vector from parser /
1879	if (!_pico_parse_vec( p,v )) _prm_error_return;
1880
1881	/ store as color /
1882	color[ 0 ] = (picoByte_t)v[ 0 ];
1883	color[ 1 ] = (picoByte_t)v[ 1 ];
1884	color[ 2 ] = (picoByte_t)v[ 2 ];
1885	color[ 3 ] = 1;
1886
1887	/ set new ambient color /
1888	PicoSetShaderDiffuseColor( shader,color );
1889	}
1890	/ remap shader's specular color /
1891	else if (!_pico_stricmp(p->token,"specular"))
1892	{
1893	picoColor_t color;
1894	picoVec3_t v;
1895
1896	/ get vector from parser /
1897	if (!_pico_parse_vec( p,v )) _prm_error_return;
1898
1899	/ store as color /
1900	color[ 0 ] = (picoByte_t)v[ 0 ];
1901	color[ 1 ] = (picoByte_t)v[ 1 ];
1902	color[ 2 ] = (picoByte_t)v[ 2 ];
1903	color[ 3 ] = 1;
1904
1905	/ set new ambient color /
1906	PicoSetShaderSpecularColor( shader,color );
1907	}
1908	/ skip rest /
1909	_pico_parse_skip_rest( p );
1910	}
1911	}
1912	/ end 'materials[' /
1913	}
1914
1915	/ free both parser and file buffer /
1916	_pico_free_parser( p );
1917	_pico_free_file( remapBuffer );
1918
1919	/ return with success /
1920	return 1;
1921	}
1922
1923
1924	/*
1925	PicoAddTriangleToModel() - jhefty
1926	A nice way to add individual triangles to the model.
1927	Chooses an appropriate surface based on the shader, or adds a new surface if necessary
1928	*/
1929
1930	void PicoAddTriangleToModel( picoModel_t model, picoVec3_t* xyz, picoVec3_t** normals,
1931	int numSTs, picoVec2_t st, int numColors, picoColor_t colors,
1932	picoShader_t* shader )
1933	{
1934	int i,j;
1935	int vertDataIndex;
1936	picoSurface_t* workSurface = NULL;
1937
1938	/ see if a surface already has the shader /
1939	for ( i = 0 ; i < model->numSurfaces ; i++ )
1940	{
1941	workSurface = model->surface[i];
1942	if ( workSurface->shader == shader )
1943	{
1944	break;
1945	}
1946	}
1947
1948	/ no surface uses this shader yet, so create a new surface /
1949	if ( !workSurface \|\| i >=model->numSurfaces )
1950	{
1951	/ create a new surface in the model for the unique shader /
1952	workSurface = PicoNewSurface(model);
1953	if ( !workSurface )
1954	{
1955	_pico_printf ( PICO_ERROR , "Could not allocate a new surface!\n" );
1956	return;
1957	}
1958
1959	/ do surface setup /
1960	PicoSetSurfaceType( workSurface, PICO_TRIANGLES );
1961	PicoSetSurfaceName( workSurface, shader->name );
1962	PicoSetSurfaceShader( workSurface, shader );
1963	}
1964
1965	/ add the triangle data to the surface /
1966	for ( i = 0 ; i < 3 ; i++ )
1967	{
1968	/ get the next free spot in the index array /
1969	int newVertIndex = PicoGetSurfaceNumIndexes ( workSurface );
1970
1971	/ get the index of the vertex that we're going to store at newVertIndex /
1972	vertDataIndex = PicoFindSurfaceVertexNum ( workSurface , xyz[i] , normals[i] , numSTs , st[i] , numColors , colors[i]);
1973
1974	/ the vertex wasn't found, so create a new vertex in the pool from the data we have /
1975	if ( vertDataIndex == -1 )
1976	{
1977	/ find the next spot for a new vertex /
1978	vertDataIndex = PicoGetSurfaceNumVertexes ( workSurface );
1979
1980	/ assign the data to it /
1981	PicoSetSurfaceXYZ ( workSurface ,vertDataIndex , *xyz[i] );
1982	PicoSetSurfaceNormal ( workSurface , vertDataIndex , *normals[i] );
1983
1984	/ make sure to copy over all available ST's and colors for the vertex /
1985	for ( j = 0 ; j < numColors ; j++ )
1986	{
1987	PicoSetSurfaceColor( workSurface , j , vertDataIndex , colors[i][j] );
1988	}
1989	for ( j = 0 ; j < numSTs ; j++ )
1990	{
1991	PicoSetSurfaceST ( workSurface , j , vertDataIndex , st[i][j] );
1992	}
1993	}
1994
1995	/ add this vertex to the triangle /
1996	PicoSetSurfaceIndex ( workSurface , newVertIndex , vertDataIndex );
1997	}
1998	}

Note: See TracBrowser for help on using the browser.

root/GtkRadiant/trunk/libs/picomodel/picomodel.c

Download in other formats: