vmap/tools/common/matlib.c

418 lines
8.1 KiB
C
Raw Normal View History

/*
Copyright (C) 1999-2007 id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.
This file is part of GtkRadiant.
GtkRadiant is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
GtkRadiant is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
// matlib.c
#include "cmdlib.h"
#include "mathlib.h"
#include "inout.h"
#include "matlib.h"
#include "vfs.h"
/*
=============================================================================
PARSING STUFF
=============================================================================
*/
typedef struct
{
char filename[1024];
char *buffer,*script_p,*end_p;
int line;
} mat_t;
#define MAX_INCLUDES 8
mat_t matstack[MAX_INCLUDES];
mat_t *mat;
int matline;
char mattoken[MAXTOKEN];
qboolean endofmat;
qboolean mattokenready; // only qtrue if UnGetMatToken was just called
/*
==============
AddMatToStack
==============
*/
void AddMatToStack( const char *filename, int index ){
int size;
void* buffer;
mat++;
if ( mat == &matstack[MAX_INCLUDES] ) {
Error( "mat file exceeded MAX_INCLUDES" );
}
strcpy( mat->filename, ExpandPath( filename ) );
size = vfsLoadFile( mat->filename, &buffer, index );
if ( size == -1 ) {
Sys_Printf( "Script file %s was not found\n", mat->filename );
mat--;
}
else
{
if ( index > 0 ) {
Sys_Printf( "entering %s (%d)\n", mat->filename, index + 1 );
}
else{
Sys_Printf( "entering %s\n", mat->filename );
}
mat->buffer = buffer;
mat->line = 1;
mat->script_p = mat->buffer;
mat->end_p = mat->buffer + size;
}
}
/*
==============
LoadMatFile
==============
*/
void LoadMatFile( const char *filename, int index ){
mat = matstack;
AddMatToStack( filename, index );
endofmat = qfalse;
mattokenready = qfalse;
}
/*
==============
ParseMatMemory
==============
*/
void ParseMatMemory( char *buffer, int size ){
mat = matstack;
mat++;
if ( mat == &matstack[MAX_INCLUDES] ) {
Error( "mat file exceeded MAX_INCLUDES" );
}
strcpy( mat->filename, "memory buffer" );
mat->buffer = buffer;
mat->line = 1;
mat->script_p = mat->buffer;
mat->end_p = mat->buffer + size;
endofmat = qfalse;
mattokenready = qfalse;
}
/*
==============
UnGetMatToken
Signals that the current mattoken was not used, and should be reported
for the next GetMatToken. Note that
GetMatToken (qtrue);
UnGetMatToken ();
GetMatToken (qfalse);
could cross a line boundary.
==============
*/
void UnGetMatToken( void ){
mattokenready = qtrue;
}
qboolean EndOfMat( qboolean crossline ){
if ( !crossline ) {
Error( "Line %i is incomplete\n",matline );
}
if ( !strcmp( mat->filename, "memory buffer" ) ) {
endofmat = qtrue;
return qfalse;
}
if ( mat->buffer == NULL ) {
Sys_FPrintf( SYS_WRN, "WARNING: Attempt to free already freed mat buffer\n" );
}
else{
free( mat->buffer );
}
mat->buffer = NULL;
if ( mat == matstack + 1 ) {
endofmat = qtrue;
return qfalse;
}
mat--;
matline = mat->line;
Sys_Printf( "returning to %s\n", mat->filename );
return GetMatToken( crossline );
}
/*
==============
GetMatToken
==============
*/
qboolean GetMatToken( qboolean crossline ){
char *mattoken_p;
/* ydnar: dummy testing */
if ( mat == NULL || mat->buffer == NULL ) {
return qfalse;
}
if ( mattokenready ) { // is a mattoken already waiting?
mattokenready = qfalse;
return qtrue;
}
if ( ( mat->script_p >= mat->end_p ) || ( mat->script_p == NULL ) ) {
return EndOfMat( crossline );
}
//
// skip space
//
skipspace:
while ( *mat->script_p <= 32 )
{
if ( mat->script_p >= mat->end_p ) {
return EndOfMat( crossline );
}
if ( *mat->script_p++ == '\n' ) {
if ( !crossline ) {
Error( "Line %i is incomplete\n",matline );
}
mat->line++;
matline = mat->line;
}
}
if ( mat->script_p >= mat->end_p ) {
return EndOfMat( crossline );
}
// ; # // comments
if ( *mat->script_p == ';' || *mat->script_p == '#'
|| ( mat->script_p[0] == '/' && mat->script_p[1] == '/' ) ) {
if ( !crossline ) {
Error( "Line %i is incomplete\n",matline );
}
while ( *mat->script_p++ != '\n' )
if ( mat->script_p >= mat->end_p ) {
return EndOfMat( crossline );
}
mat->line++;
matline = mat->line;
goto skipspace;
}
// /* */ comments
if ( mat->script_p[0] == '/' && mat->script_p[1] == '*' ) {
if ( !crossline ) {
Error( "Line %i is incomplete\n",matline );
}
mat->script_p += 2;
while ( mat->script_p[0] != '*' && mat->script_p[1] != '/' )
{
if ( *mat->script_p == '\n' ) {
mat->line++;
matline = mat->line;
}
mat->script_p++;
if ( mat->script_p >= mat->end_p ) {
return EndOfMat( crossline );
}
}
mat->script_p += 2;
goto skipspace;
}
//
// copy mattoken
//
mattoken_p = mattoken;
if ( *mat->script_p == '"' ) {
// quoted mattoken
mat->script_p++;
while ( *mat->script_p != '"' )
{
*mattoken_p++ = *mat->script_p++;
if ( mat->script_p == mat->end_p ) {
break;
}
if ( mattoken_p == &mattoken[MAXTOKEN] ) {
Error( "Token too large on line %i\n",matline );
}
}
mat->script_p++;
}
else{ // regular mattoken
while ( *mat->script_p > 32 && *mat->script_p != ';' )
{
*mattoken_p++ = *mat->script_p++;
if ( mat->script_p == mat->end_p ) {
break;
}
if ( mattoken_p == &mattoken[MAXTOKEN] ) {
Error( "Token too large on line %i\n",matline );
}
}
}
*mattoken_p = 0;
if ( !strcmp( mattoken, "$include" ) ) {
GetMatToken( qfalse );
AddMatToStack( mattoken, 0 );
return GetMatToken( crossline );
}
return qtrue;
}
/*
==============
MatTokenAvailable
Returns qtrue if there is another mattoken on the line
==============
*/
qboolean MatTokenAvailable( void ) {
int oldLine;
qboolean r;
/* save */
oldLine = matline;
/* test */
r = GetMatToken( qtrue );
if ( !r ) {
return qfalse;
}
UnGetMatToken();
if ( oldLine == matline ) {
return qtrue;
}
/* restore */
//% matline = oldLine;
//% script->line = oldScriptLine;
return qfalse;
}
//=====================================================================
void MatchMatToken( char *match ) {
GetMatToken( qtrue );
if ( strcmp( mattoken, match ) ) {
Error( "MatchMatToken( \"%s\" ) failed at line %i in file %s", match, matline, mat->filename );
}
}
void Parse1DMatMatrix( int x, vec_t *m ) {
int i;
MatchMatToken( "(" );
for ( i = 0 ; i < x ; i++ ) {
GetMatToken( qfalse );
m[i] = atof( mattoken );
}
MatchMatToken( ")" );
}
void Parse2DMatMatrix( int y, int x, vec_t *m ) {
int i;
MatchMatToken( "(" );
for ( i = 0 ; i < y ; i++ ) {
Parse1DMatMatrix( x, m + i * x );
}
MatchMatToken( ")" );
}
void Parse3DMatMatrix( int z, int y, int x, vec_t *m ) {
int i;
MatchMatToken( "(" );
for ( i = 0 ; i < z ; i++ ) {
Parse2DMatMatrix( y, x, m + i * x * y );
}
MatchMatToken( ")" );
}
void Write1DMatMatrix( FILE *f, int x, vec_t *m ) {
int i;
fprintf( f, "( " );
for ( i = 0 ; i < x ; i++ ) {
if ( m[i] == (int)m[i] ) {
fprintf( f, "%i ", (int)m[i] );
}
else {
fprintf( f, "%f ", m[i] );
}
}
fprintf( f, ")" );
}
void Write2DMatMatrix( FILE *f, int y, int x, vec_t *m ) {
int i;
fprintf( f, "( " );
for ( i = 0 ; i < y ; i++ ) {
Write1DMatMatrix( f, x, m + i * x );
fprintf( f, " " );
}
fprintf( f, ")\n" );
}
void Write3DMatMatrix( FILE *f, int z, int y, int x, vec_t *m ) {
int i;
fprintf( f, "(\n" );
for ( i = 0 ; i < z ; i++ ) {
Write2DMatMatrix( f, y, x, m + i * ( x * y ) );
}
fprintf( f, ")\n" );
}