#include "std.h"

#ifdef PRO

#include "bbblitz3d.h"
#include "bbgraphics.h"
#include "../blitz3d/blitz3d.h"
#include "../blitz3d/world.h"
#include "../blitz3d/texture.h"
#include "../blitz3d/brush.h"
#include "../blitz3d/camera.h"
#include "../blitz3d/sprite.h"
#include "../blitz3d/meshmodel.h"
#include "../blitz3d/loader_x.h"
#include "../blitz3d/loader_3ds.h"
#include "../blitz3d/loader_b3d.h"
#include "../blitz3d/md2model.h"
#include "../blitz3d/q3bspmodel.h"
#include "../blitz3d/meshutil.h"
#include "../blitz3d/pivot.h"
#include "../blitz3d/planemodel.h"
#include "../blitz3d/terrain.h"
#include "../blitz3d/listener.h"
#include "../blitz3d/cachedtexture.h"

gxScene *gx_scene;
extern gxFileSystem *gx_filesys;

static int tri_count;
static World *world;

static set<Brush*> brush_set;
static set<Texture*> texture_set;
static set<Entity*> entity_set;

static Listener *listener;

static bool stats_mode;

//converts 0...255 color to 0...1
static const float ctof=1.0f/255.0f;

//degrees to radians and back
static const float dtor=0.0174532925199432957692369076848861f;
static const float rtod=1/dtor;

static Vector projected,tformed;

static ObjCollision picked;

extern float stats3d[10];

static Loader_X loader_x;
static Loader_3DS loader_3ds;
static Loader_B3D loader_b3d;

static map<string,Transform> loader_mat_map;

static inline void debug3d(){
	if( debug && !gx_scene ) RTEX( "3D Graphics mode not set" );
}
static inline void debugTexture( Texture *t ){
	if( debug && !texture_set.count( t ) ) RTEX( "Texture does not exist" );
}
static inline void debugBrush( Brush *b ){
	if( debug && !brush_set.count( b ) ) RTEX( "Brush does not exist" );
}
static inline void debugEntity( Entity *e ){
	if( debug && !entity_set.count(e) ) RTEX( "Entity does not exist" );
}
static inline void debugParent( Entity *e ){
	if( debug ){
		debug3d();
		if( e && !entity_set.count(e) ) RTEX( "Parent entity does not exist" );
	}
}
static inline void debugMesh( MeshModel *m ){
	if( debug ){
		debugEntity(m);if( !m->getMeshModel() ) RTEX( "Entity is not a mesh" );
	}
}
static inline void debugObject( Object *o ){
	if( debug ){
		debugEntity(o);if( !o->getObject() ) RTEX( "Entity is not an object" );
	}
}
static inline void debugColl( Object *o,int index ){
	if( debug ){
		debugObject(o);
		if( index<1 || index>o->getCollisions().size() ) RTEX( "Collision index out of range" );
	}
}
static inline void debugCamera( Camera *c ){
	if( debug ){
		debugEntity(c);if( !c->getCamera() ) RTEX( "Entity is not a camera" );
	}
}
static inline void debugLight( Light *l ){
	if( debug ){
		debugEntity(l);if( !l->getLight() ) RTEX( "Entity is not a light" );
	}
}
static inline void debugModel( Model *m ){
	if( debug ){
		debugEntity(m);if( !m->getModel() ) RTEX( "Entity is not a model" );
	}
}
static inline void debugSprite( Sprite *s ){
	if( debug ){
		debugModel(s);if( !s->getSprite() ) RTEX( "Entity is not a sprite" );
	}
}
static inline void debugMD2( MD2Model *m ){
	if( debug ){
		debugModel(m);if( !m->getMD2Model() ) RTEX( "Entity is not an MD2 Model" );
	}
}
static inline void debugBSP( Q3BSPModel *m ){
	if( debug ){
		debugModel(m);if( !m->getBSPModel() ) RTEX( "Entity is not a BSP Model" );
	}
}
static inline void debugTerrain( Terrain *t ){
	if( debug ){
		debugModel(t);if( !t->getTerrain() ) RTEX( "Entity is not a terrain" );
	}
}
static inline void debugSegs( int n ){
	if( debug ){
		debug3d();
		if( n<3 || n>50 ) RTEX( "Illegal number of segments" );
	}
}
static inline void debugVertex( Surface *s,int n ){
	if( debug ){
		debug3d();
		if( n<0 || n>=s->numVertices() ) RTEX( "Vertex index out of range" );
	}
}
static inline void debugVertex( Surface *s,int n,int t ){
	if( debug ){
		debug3d();
		if( n<0 || n>=s->numVertices() ) RTEX( "Vertex index out of range" );
		if( t<0 || t>1 ) RTEX( "Texture coordinate set out of range" );
	}
}

static Entity *loadEntity( string t,int hint ){
	t=tolower(t);
	int n=t.rfind( "." );if( n==string::npos ) return 0;
	string ext=t.substr( n+1 );
	MeshLoader *l;

	if( ext=="x" ) l=&loader_x;
	else if( ext=="3ds" ) l=&loader_3ds;
	else if( ext=="b3d" ) l=&loader_b3d;
	else return 0;

	const Transform &conv=loader_mat_map[ext];

	CachedTexture::setPath( filenamepath( t ) );
	Entity *e=l->load( t,conv,hint );
	CachedTexture::setPath( "" );
	return e;
}

static void collapseMesh( MeshModel *mesh,Entity *e ){
	while( e->children() ){
		collapseMesh( mesh,e->children() );
	}
	if( Model *p=e->getModel() ){
		if( MeshModel *t=p->getMeshModel() ){
			t->transform( e->getWorldTform() );
			mesh->add( *t );
		}
	}
	delete e;
}

static void insert( Entity *e ){
	if( debug ) entity_set.insert( e );
	e->setVisible(true);
	e->setEnabled(true);
	e->getObject()->reset();
	for( Entity *p=e->children();p;p=p->successor() ){
		insert( p );
	}
}

static Entity *insertEntity( Entity *e,Entity *p ){
	e->setParent( p );
	insert( e );
	return e;
}

static void erase( Entity *e ){
	for( Entity *p=e->children();p;p=p->successor() ){
		erase( p );
	}
	if( e->getListener() ) listener=0;
	if( debug ) entity_set.erase( e );
}

static Entity *findChild( Entity *e,const string &t ){
	if( e->getName()==t ) return e;
	for( Entity *p=e->children();p;p=p->successor() ){
		if( Entity *q=findChild(p,t) ) return q;
	}
	return 0;
}

///////////////////////////
// GLOBAL WORLD COMMANDS //
///////////////////////////
void  bbLoaderMatrix( BBStr *ext,float xx,float xy,float xz,float yx,float yy,float yz,float zx,float zy,float zz ){
	loader_mat_map.erase( *ext );
	loader_mat_map[*ext]=Transform(Matrix(Vector(xx,xy,xz),Vector(yx,yy,yz),Vector(zx,zy,zz)));
	delete ext;
}

int   bbHWTexUnits(){
	debug3d();
	return gx_scene->hwTexUnits();
}

int	  bbGfxDriverCaps3D(){
	debug3d();
	return gx_scene->gfxDriverCaps3D();
}

void  bbHWMultiTex( int enable ){
	debug3d();
	gx_scene->setHWMultiTex( !!enable );
}

void  bbWBuffer( int enable ){
	debug3d();
	gx_scene->setWBuffer( !!enable );
}

void  bbDither( int enable ){
	debug3d();
	gx_scene->setDither( !!enable );
}

void  bbAntiAlias( int enable ){
	debug3d();
	gx_scene->setAntialias( !!enable );
}

void  bbWireFrame( int enable ){
	debug3d();
	gx_scene->setWireframe( !!enable );
}

void  bbAmbientLight( float r,float g,float b ){
	debug3d();
	Vector t( r*ctof,g*ctof,b*ctof );
	gx_scene->setAmbient( &(t.x) );
}

void  bbClearCollisions(){
	debug3d();
	world->clearCollisions();
}

void  bbCollisions( int src_type,int dest_type,int method,int response ){
	debug3d();
	world->addCollision( src_type,dest_type,method,response );
}

static int update_ms;

void  bbUpdateWorld( float elapsed ){
	debug3d();

#ifndef BETA
	world->update( elapsed );
	return;
#endif

	update_ms=gx_runtime->getMilliSecs();
	world->update( elapsed );
	update_ms=gx_runtime->getMilliSecs()-update_ms;
}

void  bbCaptureWorld(){
	debug3d();
	world->capture();
}

void  bbRenderWorld( float tween ){
	debug3d();

#ifndef BETA
	tri_count=gx_scene->getTrianglesDrawn();
	world->render( tween );
	tri_count=gx_scene->getTrianglesDrawn()-tri_count;
	return;
#endif

	int tris=gx_scene->getTrianglesDrawn();
	int render_ms=gx_runtime->getMilliSecs();
	world->render( tween );
	render_ms=gx_runtime->getMilliSecs()-render_ms;

	extern int bbKeyHit(int);
	extern void bbDelay(int);
	bbDelay(0);
	if( bbKeyHit( 0x57 ) ){
		stats_mode=!stats_mode;
	}
	if( bbKeyHit( 0x58 ) ){
		static int n;
		string t="screenshot"+itoa(++n)+".bmp";
		bbSaveBuffer( bbBackBuffer(),d_new BBStr(t) );
	}

	if( !stats_mode ) return;

	tris=gx_scene->getTrianglesDrawn()-tris;

	static int time;
	int frame_ms=gx_runtime->getMilliSecs()-time;
	time+=frame_ms;

	int fps=frame_ms ? 1000/frame_ms : 1000;
	int ups=update_ms ? 1000/update_ms : 1000;
	int rps=render_ms ? 1000/render_ms : 1000;

	string t_fps="000"+itoa(fps);t_fps=t_fps.substr( t_fps.size()-4 );
	string t_ups="000"+itoa(ups);t_ups=t_ups.substr( t_ups.size()-4 );
	string t_rps="000"+itoa(rps);t_rps=t_rps.substr( t_rps.size()-4 );
	string t_tris="00000"+itoa(tris);t_tris=t_tris.substr( t_tris.size()-6 );

	string t="FPS:"+t_fps+" UPS:"+t_ups+" RPS:"+t_rps+" TRIS:"+t_tris;

	bbText( 0,bbGraphicsHeight()-bbFontHeight(),d_new BBStr(t),0,0 );
}

int  bbTrisRendered(){
	return tri_count;
}

float  bbStats3D( int n ){
	return stats3d[n];
}

//////////////////////
// TEXTURE COMMANDS //
//////////////////////

//Note: modify canvas->backup() to NOT release backup image!
//
Texture *  bbLoadTexture( BBStr *file,int flags ){
	debug3d();
	Texture *t=d_new Texture( *file,flags );delete file;
	if( !t->getCanvas(0) ){ delete t;return 0; }
	texture_set.insert( t );
	return t;
}

Texture *  bbLoadAnimTexture( BBStr *file,int flags,int w,int h,int first,int cnt ){
	debug3d();
	Texture *t=d_new Texture( *file,flags,w,h,first,cnt );
	delete file;
	if( !t->getCanvas(0) ){
		delete t;
		return 0; 
	}
	texture_set.insert( t );
	return t;
}

Texture *  bbCreateTexture( int w,int h,int flags,int frames ){
	if( debug ){
		debug3d();
		if( frames<=0 ){
			RTEX( "Illegal number of texture frames" );
		}
	}
	Texture *t=d_new Texture( w,h,flags,frames );
	texture_set.insert( t );
	return t;
}

void  bbFreeTexture( Texture *t ){
	if( !t ) return;
	debugTexture(t);
	if( texture_set.erase( t ) ) delete t;
}

void  bbTextureBlend( Texture *t,int blend ){
	debugTexture(t);
	t->setBlend( blend );
}

void  bbTextureCoords( Texture *t,int flags ){
	debugTexture(t);
	t->setFlags( flags );
}

void  bbScaleTexture( Texture *t,float u_scale,float v_scale ){
	debugTexture(t);
	t->setScale( 1/u_scale,1/v_scale );
}

void  bbRotateTexture( Texture *t,float angle ){
	debugTexture(t);
	t->setRotation( -angle*dtor );
}

void  bbPositionTexture( Texture *t,float u_pos,float v_pos ){
	debugTexture(t);
	t->setPosition( -u_pos,-v_pos );
}

int  bbTextureWidth( Texture *t ){
	debugTexture(t);
	return t->getCanvas(0)->getWidth();
}

int  bbTextureHeight( Texture *t ){
	debugTexture(t);
	return t->getCanvas(0)->getHeight();
}

BBStr *bbTextureName( Texture *t ){
	debugTexture(t);
	CachedTexture *c=t->getCachedTexture();
	return c ? d_new BBStr( c->getName().c_str() ) : d_new BBStr("");
}

void bbSetCubeFace( Texture *t,int face ){
	debugTexture(t);
	if( gxCanvas *c=t->getCanvas( 0 ) ){
		c->setCubeFace(face);
	}
}

void bbSetCubeMode( Texture *t,int mode ){
	debugTexture(t);
	if( gxCanvas *c=t->getCanvas( 0 ) ){
		c->setCubeMode( mode );
	}
}

gxCanvas *bbTextureBuffer( Texture *t,int frame ){
	//v1.04
	debugTexture(t);
	if( gxCanvas *c=t->getCanvas( frame ) ){
		if( c->getDepth() ) return c;
	}
	return 0;
	/*
	//v1.03  crashes if t->getCanvas returns null!
	debugTexture(t);
	gxCanvas *c=t->getCanvas( frame );
	if( c->getDepth() ) return c;
	return 0;
	*/
}

void  bbClearTextureFilters(){
	debug3d();
	Texture::clearFilters();
}

void  bbTextureFilter( BBStr *t,int flags ){
	debug3d();
	Texture::addFilter( *t,flags );
	delete t;
}

////////////////////
// BRUSH COMMANDS //
////////////////////
Brush *  bbCreateBrush( float r,float g,float b ){
	debug3d();
	Brush *br=d_new Brush();
	br->setColor( Vector( r*ctof,g*ctof,b*ctof ) );
	brush_set.insert( br );
	return br;
}

Brush *  bbLoadBrush( BBStr *file,int flags,float u_scale,float v_scale ){
	debug3d();
	Texture t( *file,flags );
	delete file;if( !t.getCanvas(0) ) return 0;
	if( u_scale!=1 || v_scale!=1 ) t.setScale( 1/u_scale,1/v_scale );
	Brush *br=bbCreateBrush( 255,255,255 );
	br->setTexture( 0,t,0 );
	delete file;
	return br;
}

void  bbFreeBrush( Brush *b ){
	if( !b ) return;
	debugBrush(b);
	if( brush_set.erase( b ) ) delete b;
}

void  bbBrushColor( Brush *br,float r,float g,float b ){
	debugBrush(br);
	br->setColor( Vector( r*ctof,g*ctof,b*ctof ) );
}

void  bbBrushAlpha( Brush *b,float alpha ){
	debugBrush(b);
	b->setAlpha( alpha );
}

void  bbBrushShininess( Brush *b,float n ){
	debugBrush(b);
	b->setShininess( n );
}

void  bbBrushTexture( Brush *b,Texture *t,int frame,int index ){
	debugBrush(b);
	debugTexture(t);
	b->setTexture( index,*t,frame );
}

Texture *bbGetBrushTexture( Brush *b,int index ){
	debugBrush(b);
	Texture *tex=d_new Texture(b->getTexture(index));
	texture_set.insert( tex );
	return tex;
}

void  bbBrushBlend( Brush *b,int blend ){
	debugBrush(b);
	b->setBlend( blend );
}

void  bbBrushFX( Brush *b,int fx ){
	debugBrush(b);
	b->setFX( fx );
}

///////////////////
// MESH COMMANDS //
///////////////////
Entity *  bbCreateMesh( Entity *p ){
	debugParent(p);
	MeshModel *m=d_new MeshModel();
	return insertEntity( m,p );
}

Entity *  bbLoadMesh( BBStr *f,Entity *p ){
	debugParent(p);
	Entity *e=loadEntity( f->c_str(),MeshLoader::HINT_COLLAPSE );
	delete f;

	if( !e ) return 0;
	MeshModel *m=d_new MeshModel();
	collapseMesh( m,e );
	return insertEntity( m,p );
}

Entity *  bbLoadAnimMesh( BBStr *f,Entity *p ){
	debugParent(p);
	Entity *e=loadEntity( f->c_str(),0 );
	delete f;

	if( !e ) return 0;
	if( Animator *anim=e->getObject()->getAnimator() ){
		anim->animate( 1,0,0,0 );
	}
	return insertEntity( e,p );
}

Entity *  bbCreateCube( Entity *p ){
	debugParent(p);
	Entity *e=MeshUtil::createCube( Brush() );
	return insertEntity( e,p );
}

Entity *  bbCreateSphere( int segs,Entity *p ){
	if( debug ){ debugParent(p);if( segs<2 || segs>100 ) RTEX( "Illegal number of segments" ); }
	Entity *e=MeshUtil::createSphere( Brush(),segs );
	return insertEntity( e,p );
}

Entity *  bbCreateCylinder( int segs,int solid,Entity *p ){
	if( debug ){ debugParent(p);if( segs<3 || segs>100 ) RTEX( "Illegal number of segments" ); }
	Entity *e=MeshUtil::createCylinder( Brush(),segs,!!solid );
	return insertEntity( e,p );
}

Entity *  bbCreateCone( int segs,int solid,Entity *p ){
	if( debug ){ debugParent(p);if( segs<3 || segs>100 ) RTEX( "Illegal number of segments" ); }
	Entity *e=MeshUtil::createCone( Brush(),segs,!!solid );
	return insertEntity( e,p );
}

Entity *  bbCopyMesh( MeshModel *m,Entity *p ){
	debugMesh(m);
	debugParent(p);

	MeshModel *t=d_new MeshModel();
	t->add( *m );
	return insertEntity( t,p );
}

void  bbScaleMesh( MeshModel *m,float x,float y,float z ){
	debugMesh(m);
	m->transform( scaleMatrix(x,y,z) );
}

void  bbRotateMesh( MeshModel *m,float x,float y,float z ){
	debugMesh(m);
	m->transform( rotationMatrix(x*dtor,y*dtor,z*dtor) );
}

void  bbPositionMesh( MeshModel *m,float x,float y,float z ){
	debugMesh(m);
	m->transform( Vector(x,y,z) );
}

void  bbFitMesh( MeshModel *m,float x,float y,float z,float w,float h,float d,int uniform ){
	debugMesh(m);
	Box box( Vector(x,y,z) );
	box.update( Vector(x+w,y+h,z+d) );
	const Box &curr_box=m->getBox();
	float x_scale=box.width()/curr_box.width();
	float y_scale=box.height()/curr_box.height();
	float z_scale=box.depth()/curr_box.depth();
	Transform t;
	if( uniform ){
		if( x_scale<y_scale && x_scale<z_scale ){
			y_scale=z_scale=x_scale;
		}else if( y_scale<x_scale && y_scale<z_scale ){
			x_scale=z_scale=y_scale;
		}else{
			x_scale=y_scale=z_scale;
		}
	}
	t.m.i.x=x_scale;
	t.m.j.y=y_scale;
	t.m.k.z=z_scale;
	t.v=box.centre() - t.m * curr_box.centre();
	m->transform( t );
}

void  bbFlipMesh( MeshModel *m ){
	debugMesh(m);
	m->flipTriangles();
}

void  bbPaintMesh( MeshModel *m,Brush *b ){
	if( debug ){ debugMesh(m);debugBrush(b); }
	m->paint( *b );
}

void  bbAddMesh( MeshModel *src,MeshModel *dest ){
	if( debug ){
		debugMesh(src);debugMesh(dest); 
		if( src==dest ) RTEX( "A mesh cannot be added to itself" );
	}

	dest->add( *src );
}

void  bbUpdateNormals( MeshModel *m ){
	debugMesh(m);
	m->updateNormals();
}

void  bbLightMesh( MeshModel *m,float r,float g,float b,float range,float x,float y,float z ){
	debugMesh(m);
	MeshUtil::lightMesh( m,Vector(x,y,z),Vector(r*ctof,g*ctof,b*ctof),range );
}

float  bbMeshWidth( MeshModel *m ){
	debugMesh(m);
	return m->getBox().width();
}

float  bbMeshHeight( MeshModel *m ){
	debugMesh(m);
	return m->getBox().height();
}

float  bbMeshDepth( MeshModel *m ){
	debugMesh(m);
	return m->getBox().depth();
}

int  bbMeshesIntersect( MeshModel *a,MeshModel *b ){
	if( debug ){ debugMesh(a);debugMesh(b); }
	return a->intersects( *b );
}

int  bbCountSurfaces( MeshModel *m ){
	debugMesh(m);
	return m->getSurfaces().size();
}

Surface *  bbGetSurface( MeshModel *m,int index ){
	if( debug ){
		debugMesh(m);
		if( index<1 || index>m->getSurfaces().size() ){
			RTEX( "Surface Index out of range" );
		}
	}
	return m->getSurfaces()[index-1];
}

void bbMeshCullBox( MeshModel *m,float x,float y,float z,float width,float height,float depth ){
	if( debug ){
		debugMesh( m );
	}
	m->setCullBox( Box( Vector(x,y,z),Vector(x+width,y+height,z+depth) ) );
}


//////////////////////
// SURFACE COMMANDS //
//////////////////////
Surface *  bbFindSurface( MeshModel *m,Brush *b ){
	if( debug ){ debugMesh(m);debugBrush(b); }
	return m->findSurface(*b);
}

Surface *  bbCreateSurface( MeshModel *m,Brush *b ){
	if( debug ){ debugMesh(m);if( b ) debugBrush(b); }
	Surface *s=b ? m->createSurface( *b ) : m->createSurface( Brush() );
	return s;
}

Brush *bbGetSurfaceBrush( Surface *s ){
	Brush *br=d_new Brush( s->getBrush() );
	brush_set.insert( br );
	return br;
}

Brush *bbGetEntityBrush( Model *m ){
	debugModel(m);
	Brush *br=d_new Brush( m->getBrush() );
	brush_set.insert( br );
	return br;
}

void  bbClearSurface( Surface *s,int verts,int tris ){
	s->clear( !!verts,!!tris );
}

void  bbPaintSurface( Surface *s,Brush *b ){
	debugBrush(b);
	s->setBrush(*b);
}

int  bbAddVertex( Surface *s,float x,float y,float z,float tu,float tv,float tw ){
	Surface::Vertex v;
	v.coords=Vector(x,y,z);
	v.color=0xffffffff;
	v.tex_coords[0][0]=v.tex_coords[1][0]=tu;
	v.tex_coords[0][1]=v.tex_coords[1][1]=tv;
	s->addVertex( v );
	return s->numVertices()-1;
}

int  bbAddTriangle( Surface *s,int v0,int v1,int v2 ){
	Surface::Triangle t;
	t.verts[0]=v0;t.verts[1]=v1;t.verts[2]=v2;
	s->addTriangle( t );
	return s->numTriangles()-1;
}

void  bbVertexCoords( Surface *s,int n,float x,float y,float z ){
	s->setCoords( n,Vector(x,y,z) );
}

void  bbVertexNormal( Surface *s,int n,float x,float y,float z ){
	s->setNormal( n,Vector(x,y,z) );
}

void  bbVertexColor( Surface *s,int n,float r,float g,float b,float a ){
	if(r<0)r=0;else if(r>255)r=255;
	if(g<0)g=0;else if(g>255)g=255;
	if(b<0)b=0;else if(b>255)b=255;
	a*=255;if(a<0)a=0;else if(a>255)a=255;
	s->setColor( n,(int(a)<<24)|(int(r)<<16)|(int(g)<<8)|int(b) );
}

void  bbVertexTexCoords( Surface *s,int n,float u,float v,float w,int set ){
	s->setTexCoords( n,Vector(u,v,w),set );
}

int  bbCountVertices( Surface *s ){
	return s->numVertices();
}

int  bbCountTriangles( Surface *s ){
	return s->numTriangles();
}

float  bbVertexX( Surface *s,int n ){
	debugVertex(s,n);
	return s->getVertex(n).coords.x;
}
float  bbVertexY( Surface *s,int n ){
	debugVertex(s,n);
	return s->getVertex(n).coords.y;
}
float  bbVertexZ( Surface *s,int n ){
	debugVertex(s,n);
	return s->getVertex(n).coords.z;
}
float  bbVertexNX( Surface *s,int n ){
	debugVertex(s,n);
	return s->getVertex(n).normal.x;
}
float  bbVertexNY( Surface *s,int n ){
	debugVertex(s,n);
	return s->getVertex(n).normal.y;
}
float  bbVertexNZ( Surface *s,int n ){
	debugVertex(s,n);
	return s->getVertex(n).normal.z;
}
float  bbVertexRed( Surface *s,int n ){
	debugVertex(s,n);
	return (s->getVertex(n).color&0xff0000)>>16;
}
float  bbVertexGreen( Surface *s,int n ){
	debugVertex(s,n);
	return (s->getVertex(n).color&0xff00)>>8;
}
float  bbVertexBlue( Surface *s,int n ){
	debugVertex(s,n);
	return s->getVertex(n).color&0xff;
}
float  bbVertexAlpha( Surface *s,int n ){
	debugVertex(s,n);
	return ((s->getVertex(n).color&0xff000000)>>24)/255.0f;
}
float  bbVertexU( Surface *s,int n,int t ){
	debugVertex(s,n,t);
	return s->getVertex(n).tex_coords[t][0];
}
float  bbVertexV( Surface *s,int n,int t ){
	debugVertex(s,n,t);
	return s->getVertex(n).tex_coords[t][1];
}
float  bbVertexW( Surface *s,int n,int t ){
	debugVertex(s,n,t);
	return 1;
}
int  bbTriangleVertex( Surface *s,int n,int v ){
	return s->getTriangle(n).verts[v];
}

/////////////////////
// CAMERA COMMANDS //
/////////////////////
Entity *  bbCreateCamera( Entity *p ){
	debugParent(p);
	int x,y,w,h;
	gx_canvas->getViewport( &x,&y,&w,&h );
	Camera *c=d_new Camera();
	c->setViewport( x,y,w,h );
	return insertEntity( c,p );
}

void  bbCameraZoom( Camera *c,float zoom ){
	debugCamera(c);
	c->setZoom( zoom );
}

void  bbCameraRange( Camera *c,float nr,float fr ){
	debugCamera(c);
	c->setRange( nr,fr );
}

void  bbCameraClsColor( Camera *c,float r,float g,float b ){
	debugCamera(c);
	c->setClsColor( Vector( r*ctof,g*ctof,b*ctof ) );
}

void  bbCameraClsMode( Camera *c,int cls_color,int cls_zbuffer ){
	debugCamera(c);
	c->setClsMode( cls_color ? true : false,cls_zbuffer ? true : false );
}

void  bbCameraProjMode( Camera *c,int mode ){
	debugCamera(c);
	c->setProjMode( mode );
}

void  bbCameraViewport( Camera *c,int x,int y,int w,int h ){
	debugCamera(c);
	c->setViewport( x,y,w,h );
}

void  bbCameraFogRange( Camera *c,float nr,float fr ){
	debugCamera(c);
	c->setFogRange( nr,fr );
}

void  bbCameraFogColor( Camera *c,float r,float g,float b ){
	debugCamera(c);
	c->setFogColor( Vector( r*ctof,g*ctof,b*ctof ) );
}

void  bbCameraFogMode( Camera *c,int mode ){
	debugCamera(c);
	c->setFogMode( mode );
}

int  bbCameraProject( Camera *c,float x,float y,float z ){
	debugCamera(c);
	Vector v=-c->getWorldTform()*Vector(x,y,z);
	const Frustum &f=c->getFrustum();
	if( c->getProjMode()==Camera::PROJ_ORTHO ){
		int vp_x,vp_y,vp_w,vp_h;
		c->getViewport( &vp_x,&vp_y,&vp_w,&vp_h );
		float nr=c->getFrustumNear();
		float fr=c->getFrustumFar();
		float nr_w=c->getFrustumWidth();
		float nr_h=c->getFrustumHeight();
		projected=Vector( (v.x/nr_w+.5f)*vp_w,(.5f-v.y/nr_h)*vp_h,nr );
		return 1;
	}
	if( v.z>0 ){
		float fr=+f.getPlane( Frustum::PLANE_FAR ).d;
		if( v.z<=fr ){
			int vp_x,vp_y,vp_w,vp_h;
			c->getViewport( &vp_x,&vp_y,&vp_w,&vp_h );
			float nr=c->getFrustumNear();
			float fr=c->getFrustumFar();
			float nr_w=c->getFrustumWidth();
			float nr_h=c->getFrustumHeight();
			projected=Vector( 
				(v.x*nr/v.z/nr_w+.5f)*vp_w,
				(.5f-v.y*nr/v.z/nr_h)*vp_h,nr );
			return 1;
		}
	}
	projected=Vector();
	return 0;
}

float  bbProjectedX(){
	return projected.x;
}

float  bbProjectedY(){
	return projected.y;
}

float  bbProjectedZ(){
	return projected.z;
}

static Object *doPick( const Line &l,float radius ){
	picked.collision.time=1;
	return world->traceRay( l,radius,&picked );
}

Entity *  bbCameraPick( Camera *c,float x,float y ){
	debugCamera(c);

	int vp_x,vp_y,vp_w,vp_h;
	c->getViewport( &vp_x,&vp_y,&vp_w,&vp_h );
	float nr=c->getFrustumNear();
	float fr=c->getFrustumFar();
	float nr_w=c->getFrustumWidth();
	float nr_h=c->getFrustumHeight();

	x=((x/vp_w)-.5f)*nr_w;
	y=(.5f-(y/vp_h))*nr_h;

	Line l;
	if( c->getProjMode()==Camera::PROJ_ORTHO ){
		l=c->getWorldTform() * Line( Vector(x,y,0),Vector(0,0,fr) );	//x,y,fr) );
	}else{
		x/=nr;y/=nr;
		l=c->getWorldTform() * Line( Vector(),Vector( x*fr,y*fr,fr ) );
	}

	return doPick( l,0 );
}

Entity *  bbLinePick( float x,float y,float z,float dx,float dy,float dz,float radius ){
	debug3d();

	Line l( Vector( x,y,z ),Vector( dx,dy,dz ) );

	return doPick( l,radius );
}

Entity *  bbEntityPick( Object *src,float range ){
	debugEntity(src);

	Line l( src->getWorldPosition(),src->getWorldTform().m.k * range );

	return doPick( l,0 );
}

int  bbEntityVisible( Object *src,Object *dest ){
	if( debug ){ debugObject(src);debugObject(dest); }

	return world->checkLOS( src,dest ) ? 1 : 0;
}

int  bbEntityInView( Entity *e,Camera *c ){
	if( debug ){ debugEntity(e);debugCamera(c); }
	if( Model *p=e->getModel() ){
		if( MeshModel *m=p->getMeshModel() ){
			const Box &b=m->getBox();
			Transform t=-c->getWorldTform() * e->getWorldTform();
			Vector p[]={ 
				t*b.corner(0),t*b.corner(1),t*b.corner(2),t*b.corner(3),
				t*b.corner(4),t*b.corner(5),t*b.corner(6),t*b.corner(7)
			};
			return c->getFrustum().cull( p,8 );
		}
	}
	Vector p[]={ -c->getWorldTform() * e->getWorldPosition() };
	return c->getFrustum().cull( p,1 );
}

float  bbPickedX(){
	return picked.coords.x;
}

float  bbPickedY(){
	return picked.coords.y;
}

float  bbPickedZ(){
	return picked.coords.z;
}

float  bbPickedNX(){
	return picked.collision.normal.x;
}

float  bbPickedNY(){
	return picked.collision.normal.y;
}

float  bbPickedNZ(){
	return picked.collision.normal.z;
}

float  bbPickedTime(){
	return picked.collision.time;
}

Object * bbPickedEntity(){
	return picked.with;
}

void * bbPickedSurface(){
	return picked.collision.surface;
}

int  bbPickedTriangle(){
	return picked.collision.index;
}

////////////////////
// LIGHT COMMANDS //
////////////////////
Entity *  bbCreateLight( int type,Entity *p ){
	debugParent(p);
	Light *t=d_new Light( type );
	return insertEntity( t,p );
}

void  bbLightColor( Light *light,float r,float g,float b ){
	debugLight(light);
	light->setColor( Vector(r*ctof,g*ctof,b*ctof) );
}

void  bbLightRange( Light *light,float range ){
	debugLight(light);
	light->setRange( range );
}

void  bbLightConeAngles( Light *light,float inner,float outer ){
	debugLight(light);
	inner*=dtor;
	outer*=dtor;
	if( inner<0 ) inner=0;
	else if( inner>PI ) inner=PI;
	if( outer<inner ) outer=inner;
	else if( outer>PI ) outer=PI;
	light->setConeAngles( inner,outer );
}

////////////////////
// PIVOT COMMANDS //
////////////////////
Entity *  bbCreatePivot( Entity *p ){
	debugParent(p);
	Pivot *t=d_new Pivot();
	return insertEntity( t,p );
}

/////////////////////
// SPRITE COMMANDS //
/////////////////////
Entity *  bbCreateSprite( Entity *p ){
	debugParent(p);
	Sprite *s=d_new Sprite();
	s->setFX( gxScene::FX_FULLBRIGHT );
	return insertEntity( s,p );
}

Entity *  bbLoadSprite( BBStr *file,int flags,Entity *p ){
	debugParent(p);
	Texture t( *file,flags );
	delete file;if( !t.getCanvas(0) ) return 0;
	Sprite *s=d_new Sprite();
	s->setTexture( 0,t,0 );
	s->setFX( gxScene::FX_FULLBRIGHT );

	if( flags & gxCanvas::CANVAS_TEX_MASK ) s->setBlend( gxScene::BLEND_REPLACE );
	else if( flags & gxCanvas::CANVAS_TEX_ALPHA ) s->setBlend( gxScene::BLEND_ALPHA );
	else s->setBlend( gxScene::BLEND_ADD );

	return insertEntity( s,p );
}

void  bbRotateSprite( Sprite *s,float angle ){
	debugSprite(s);
	s->setRotation( angle*dtor );
}

void  bbScaleSprite( Sprite *s,float x,float y ){
	debugSprite(s);
	s->setScale( x,y );
}

void  bbHandleSprite( Sprite *s,float x,float y ){
	debugSprite(s);
	s->setHandle( x,y );
}

void  bbSpriteViewMode( Sprite *s,int mode ){
	debugSprite(s);
	s->setViewmode( mode );
}

/////////////////////
// MIRROR COMMANDS //
/////////////////////
Entity *  bbCreateMirror( Entity *p ){
	debugParent(p);
	Mirror *t=d_new Mirror();
	return insertEntity( t,p );
}

////////////////////
// PLANE COMMANDS //
////////////////////
Entity *  bbCreatePlane( int segs,Entity *p ){
	if( debug ){
		debugParent(p);
		if( segs<1 || segs>20 ) RTEX( "Illegal number of segments" );
	}
	PlaneModel *t=d_new PlaneModel( segs );
	return insertEntity( t,p );
}

//////////////////
// MD2 COMMANDS //
//////////////////
Entity *  bbLoadMD2( BBStr *file,Entity *p ){
	debugParent(p);
	MD2Model *t=d_new MD2Model( *file );delete file;
	if( !t->getValid() ){ delete t;return 0; }
	return insertEntity( t,p );
}

void  bbAnimateMD2( MD2Model *m,int mode,float speed,int first,int last,float trans ){
	debugMD2(m);
	m->startMD2Anim( first,last,mode,speed,trans );
}

float  bbMD2AnimTime( MD2Model *m ){
	debugMD2(m);
	return m->getMD2AnimTime();
}

int  bbMD2AnimLength( MD2Model *m ){
	debugMD2(m);
	return m->getMD2AnimLength();
}

int  bbMD2Animating( MD2Model *m ){
	debugMD2(m);
	return m->getMD2Animating();
}

//////////////////
// BSP Commands //
//////////////////
Entity *  bbLoadBSP( BBStr *file,float gam,Entity *p ){
	debugParent(p);
	CachedTexture::setPath( filenamepath( *file ) );
	Q3BSPModel *t=d_new Q3BSPModel( *file,gam );delete file;
	CachedTexture::setPath( "" );

	if( !t->isValid() ){ delete t;return 0; }

	return insertEntity( t,p );
}

void  bbBSPAmbientLight( Q3BSPModel *t,float r,float g,float b ){
	debugBSP(t);
	t->setAmbient( Vector( r*ctof,g*ctof,b*ctof ) );
}

void  bbBSPLighting( Q3BSPModel *t,int lmap ){
	debugBSP(t);
	t->setLighting( !!lmap );
}

//////////////////////
// TERRAIN COMMANDS //
//////////////////////
static float terrainHeight( Terrain *t,float x,float z ){
	int ix=floor(x);
	int iz=floor(z);
	float tx=x-ix,tz=z-iz;
	float h0=t->getHeight(ix,iz);
	float h1=t->getHeight(ix+1,iz);
	float h2=t->getHeight(ix,iz+1);
	float h3=t->getHeight(ix+1,iz+1);
	float ha=(h1-h0)*tx+h0,hb=(h3-h2)*tx+h2;
	float h=(hb-ha)*tz+ha;
	return h;
}

static Vector terrainVector( Terrain *t,float x,float y,float z ){
	Vector v=-t->getWorldTform() * Vector( x,y,z );
	return t->getWorldTform() * Vector( v.x,terrainHeight( t,v.x,v.z ),v.z );
}

Entity *  bbCreateTerrain( int n,Entity *p ){
	debugParent(p);
	int shift=0;
	while( (1<<shift)<n ) ++shift;
	if( (1<<shift)!=n ) RTEX( "Illegal terrain size" );
	Terrain *t=d_new Terrain( shift );
	return insertEntity( t,p );
}

Entity *  bbLoadTerrain( BBStr *file,Entity *p ){
	debugParent(p);
	gxCanvas *c=gx_graphics->loadCanvas( *file,gxCanvas::CANVAS_HIGHCOLOR );
	if( !c ) RTEX( "Unable to load heightmap image" );
	int w=c->getWidth(),h=c->getHeight();
	if( w!=h ) RTEX( "Terrain must be square" );
	int shift=0;
	while( (1<<shift)<w ) ++shift;
	if( (1<<shift)!=w ) RTEX( "Illegal terrain size" );
	Terrain *t=d_new Terrain( shift );
	c->lock();
	for( int y=0;y<h;++y ){
		for( int x=0;x<w;++x ){
			int rgb=c->getPixelFast( x,y );
			int r=(rgb>>16)&0xff,g=(rgb>>8)&0xff,b=rgb&0xff;
			float p=(r>g?(r>b?r:b):(g>b?g:b))/255.0f;
			t->setHeight( x,h-1-y,p,false );
		}
	}
	c->unlock();
	gx_graphics->freeCanvas( c );
	return insertEntity( t,p );
}

void  bbTerrainDetail( Terrain *t,int n,int m ){
	debugTerrain(t);
	t->setDetail( n,!!m );
}

void  bbTerrainShading( Terrain *t,int enable ){
	debugTerrain(t);
	t->setShading( !!enable );
}

float  bbTerrainX( Terrain *t,float x,float y,float z ){
	debugTerrain(t);
	return terrainVector( t,x,y,z ).x;
}

float  bbTerrainY( Terrain *t,float x,float y,float z ){
	debugTerrain(t);
	return terrainVector( t,x,y,z ).y;
}

float  bbTerrainZ( Terrain *t,float x,float y,float z ){
	debugTerrain(t);
	return terrainVector( t,x,y,z ).z;
}

int  bbTerrainSize( Terrain *t ){
	debugTerrain(t);
	return t->getSize();
}

float  bbTerrainHeight( Terrain *t,int x,int z ){
	debugTerrain(t);
	return t->getHeight( x,z );
}

void  bbModifyTerrain( Terrain *t,int x,int z,float h,int realtime ){
	debugTerrain(t);
	t->setHeight( x,z,h,!!realtime );
}

////////////////////
// AUDIO COMMANDS //
////////////////////
Entity *  bbCreateListener( Entity *p,float roll,float dopp,float dist ){
	if( debug ){
		debugParent(p);
		if( listener ) RTEX( "Listener already created" );
	}
	listener=d_new Listener( roll,dopp,dist );
	return insertEntity( listener,p );
}

gxChannel *  bbEmitSound( gxSound *sound,Object *o ){
	if( debug ){
		debugObject(o);
		if( !listener ) RTEX( "No Listener created" );
	}
	return o->emitSound( sound );
}

/////////////////////
// ENTITY COMMANDS //
/////////////////////
Entity *  bbCopyEntity( Entity *e,Entity *p ){
	if( debug ){
		debugEntity(e);
		debugParent(p); 
	}
	Entity *t=e->getObject()->copy();
	if( !t ) return 0;
	return insertEntity( t,p );
}

void  bbFreeEntity( Entity *e ){
	if( !e ) return;
	if( debug ){
		debugEntity(e);
		erase(e);
	}
	delete e;
}

void  bbHideEntity( Entity *e ){
	debugEntity(e);
	e->setEnabled(false);
	e->setVisible(false);
}

void  bbShowEntity( Entity *e ){
	debugEntity(e);
	e->setVisible(true);
	e->setEnabled(true);
	e->getObject()->reset();
}

void  bbEntityParent( Entity *e,Entity *p,int global ){
	if( debug ){
		debugEntity(e);
		debugParent(p);
		Entity *t=p;
		while( t ){
			if( t==e ){
				RTEX( "Entity cannot be parented to itself!" );
			}
			t=t->getParent();
		}
	}

	if( e->getParent()==p ) return;

	if( global ){
		Transform t=e->getWorldTform();
		e->setParent( p );
		e->setWorldTform( t );
	}else{
		e->setParent( p );
		e->getObject()->reset();
	}
}

int  bbCountChildren( Entity *e ){
	debugEntity(e);
	int n=0;
	for( Entity *p=e->children();p;p=p->successor() ) ++n;
	return n;
}

Entity *  bbGetChild( Entity *e,int index ){
	debugEntity(e);
	Entity *p=e->children();
	while( --index && p ) p=p->successor();
	return p;
}

Entity *  bbFindChild( Entity *e,BBStr *t ){
	debugEntity(e);
	e=findChild( e,*t );
	delete t;
	return e;
}

////////////////////////
// ANIMATION COMMANDS //
////////////////////////
int  bbLoadAnimSeq( Object *o,BBStr *f ){
	debugObject( o );
	if( Animator *anim=o->getAnimator() ){
		Entity *t=loadEntity( f->c_str(),MeshLoader::HINT_ANIMONLY );
		delete f;
		if( t ){
			if( Animator *p=t->getObject()->getAnimator() ){
				anim->addSeqs( p );
			}
			delete t;
		}
		return anim->numSeqs()-1;
	}else{
		delete f;
	}
	return -1;
}

void  bbSetAnimTime( Object *o,float time,int seq ){
	debugObject( o );
	if( Animator *anim=o->getAnimator() ){
		anim->setAnimTime( time,seq );
	}else{
		RTEX( "Entity has not animation" );
	}
}

void  bbAnimate( Object *o,int mode,float speed,int seq,float trans ){
	debugObject( o );
	if( Animator *anim=o->getAnimator() ){
		anim->animate( mode,speed,seq,trans );
	}else{
		RTEX( "Entity has no animation" );
	}
}

void  bbSetAnimKey( Object *o,int frame,int pos_key,int rot_key,int scl_key ){
	debugObject( o );
	Animation anim=o->getAnimation();
	if( pos_key ) anim.setPositionKey( frame,o->getLocalPosition() );
	if( rot_key ) anim.setRotationKey( frame,o->getLocalRotation() );
	if( scl_key ) anim.setScaleKey( frame,o->getLocalScale() );
	o->setAnimation( anim );
}

int  bbExtractAnimSeq( Object *o,int first,int last,int seq ){
	debugObject( o );
	if( Animator *anim=o->getAnimator() ){
		anim->extractSeq( first,last,seq );
		return anim->numSeqs()-1;
	}
	return -1;
}

int  bbAddAnimSeq( Object *o,int length ){
	debugObject( o );
	Animator *anim=o->getAnimator();
	if( anim ){
		anim->addSeq( length );
	}else{
		anim=d_new Animator( o,length );
		o->setAnimator( anim );
	}
	return anim->numSeqs()-1;
}

int  bbAnimSeq( Object *o ){
	debugObject(o);
	if( Animator *anim=o->getAnimator() ) return anim->animSeq();
	return -1;
}

float  bbAnimTime( Object *o ){
	debugObject(o);
	if( Animator *anim=o->getAnimator() ) return anim->animTime();
	return -1;
}

int  bbAnimLength( Object *o ){
	debugObject(o);
	if( Animator *anim=o->getAnimator() ) return anim->animLen();
	return -1;
}

int  bbAnimating( Object *o ){
	debugObject(o);
	if( Animator *anim=o->getAnimator() ) return anim->animating();
	return 0;
}

////////////////////////////////
// ENTITY SPECIAL FX COMMANDS //
////////////////////////////////
void  bbPaintEntity( Model *m,Brush *b ){
	if( debug ){
		debugModel(m);
		debugBrush(b);
	}
	m->setBrush( *b );
}

void  bbEntityColor( Model *m,float r,float g,float b ){
	debugModel(m);
	m->setColor( Vector( r*ctof,g*ctof,b*ctof ) );
}

void  bbEntityAlpha( Model *m,float alpha ){
	debugModel(m);
	m->setAlpha( alpha );
}

void  bbEntityShininess( Model *m,float shininess ){
	debugModel(m);
	m->setShininess( shininess );
}

void  bbEntityTexture( Model *m,Texture *t,int frame,int index ){
	debugModel(m);
	debugTexture(t);
	m->setTexture( index,*t,frame );
}

void  bbEntityBlend( Model *m,int blend ){
	debugModel(m);
	m->setBlend( blend );
}

void  bbEntityFX( Model *m,int fx ){
	debugModel(m);
	m->setFX( fx );
}

void  bbEntityAutoFade( Model *m,float nr,float fr ){
	debugModel(m);
	m->setAutoFade( nr,fr );
}

void  bbEntityOrder( Object *o,int n ){
	if( debug ){
		debugEntity(o);
		if( !o->getModel() && !o->getCamera() ){
			RTEX( "Entity is not a model or camera" );
		}
	}
	o->setOrder( n );
}

//////////////////////////////
// ENTITY PROPERTY COMMANDS //
//////////////////////////////
float  bbEntityX( Entity *e,int global ){
	debugEntity(e);
	return global ? e->getWorldPosition().x : e->getLocalPosition().x;
}

float  bbEntityY( Entity *e,int global ){
	debugEntity(e);
	return global ? e->getWorldPosition().y : e->getLocalPosition().y;
}

float  bbEntityZ( Entity *e,int global ){
	debugEntity(e);
	return global ? e->getWorldPosition().z : e->getLocalPosition().z;
}

float  bbEntityPitch( Entity *e,int global ){
	debugEntity(e);
	return quatPitch( global ? e->getWorldRotation() : e->getLocalRotation() ) * rtod;
}

float  bbEntityYaw( Entity *e,int global ){
	debugEntity(e);
	return quatYaw( global ? e->getWorldRotation() : e->getLocalRotation() ) * rtod;
}

float  bbEntityRoll( Entity *e,int global ){
	debugEntity(e);
	return quatRoll( global ? e->getWorldRotation() : e->getLocalRotation() ) * rtod;
}

float  bbGetMatElement( Entity *e,int row,int col ){
	debugEntity(e);
	return row<3 ? e->getWorldTform().m[row][col] : e->getWorldTform().v[col];
}

void  bbTFormPoint( float x,float y,float z,Entity *src,Entity *dest ){
	if( debug ){
		if( src ) debugEntity(src);
		if( dest ) debugEntity(dest);
	}
	tformed=Vector( x,y,z );
	if( src ) tformed=src->getWorldTform() * tformed;
	if( dest ) tformed=-dest->getWorldTform() * tformed;
}

void  bbTFormVector( float x,float y,float z,Entity *src,Entity *dest ){
	if( debug ){
		if( src ) debugEntity(src);
		if( dest ) debugEntity(dest);
	}
	tformed=Vector( x,y,z );
	if( src ) tformed=src->getWorldTform().m * tformed;
	if( dest ) tformed=-dest->getWorldTform().m * tformed;
}

void  bbTFormNormal( float x,float y,float z,Entity *src,Entity *dest ){
	if( debug ){
		if( src ) debugEntity(src);
		if( dest ) debugEntity(dest);
	}
	tformed=Vector( x,y,z );
	if( src ) tformed=(src->getWorldTform().m).cofactor() * tformed;
	if( dest ) tformed=(-dest->getWorldTform().m).cofactor() * tformed;
	tformed.normalize();
}

float  bbTFormedX(){
	return tformed.x;
}

float  bbTFormedY(){
	return tformed.y;
}

float  bbTFormedZ(){
	return tformed.z;
}

float  bbVectorYaw( float x,float y,float z ){
	return Vector(x,y,z).yaw() * rtod;
}

float  bbVectorPitch( float x,float y,float z ){
	return Vector(x,y,z).pitch() * rtod;
}

float  bbDeltaYaw( Entity *src,Entity *dest ){
	float x=src->getWorldTform().m.k.yaw();
	float y=(dest->getWorldTform().v-src->getWorldTform().v).yaw();
	float d=y-x;
	if( d<-PI ) d+=TWOPI;
	else if( d>=PI ) d-=TWOPI;
	return d*rtod;
}

float  bbDeltaPitch( Entity *src,Entity *dest ){
	float x=src->getWorldTform().m.k.pitch();
	float y=(dest->getWorldTform().v-src->getWorldTform().v).pitch();
	float d=y-x;
	if( d<-PI ) d+=TWOPI;
	else if( d>=PI ) d-=TWOPI;
	return d*rtod;
}

///////////////////////////////
// ENTITY COLLISION COMMANDS //
///////////////////////////////
void  bbResetEntity( Object *o ){
	debugObject(o);
	o->reset();
}

static void entityType( Entity *e,int type ){
	e->getObject()->setCollisionType(type);
	e->getObject()->reset();
	for( Entity *p=e->children();p;p=p->successor() ){
		entityType( p,type );
	}
}

void  bbEntityType( Object *o,int type,int recurs ){
	if( debug ){
		debugObject(o);
		if( type<0 || type>999 ) RTEX( "EntityType ID must be in the range 0...999" );
	}
	if( recurs ) entityType( o,type );
	else{
		o->setCollisionType(type);
		o->reset();
	}
}

void  bbEntityPickMode( Object *o,int mode,int obs ){
	debugObject(o);
	o->setPickGeometry( mode );
	o->setObscurer( !!obs );
}

Entity *  bbGetParent( Entity *e ){
	debugEntity(e);
	return e->getParent();
}

int  bbGetEntityType( Object *o ){
	debugObject(o);
	return o->getCollisionType();
}

void  bbEntityRadius( Object *o,float x_radius,float y_radius ){
	debugObject(o);
	Vector radii( x_radius,y_radius ? y_radius : x_radius,x_radius );
	o->setCollisionRadii( radii );
}

void  bbEntityBox( Object *o,float x,float y,float z,float w,float h,float d ){
	debugObject(o);
	Box b( Vector(x,y,z) );
	b.update( Vector( x+w,y+h,z+d ) );
	o->setCollisionBox( b );
}

Object *  bbEntityCollided( Object *o,int type ){
	debugObject(o);
	Object::Collisions::const_iterator it;
	const Object::Collisions &c=o->getCollisions();
	for( it=c.begin();it!=c.end();++it ){
		const ObjCollision *c=*it;
		if( c->with->getCollisionType()==type ) return c->with;
	}
	return 0;
}

int  bbCountCollisions( Object *o ){
	debugObject(o);
	return o->getCollisions().size();
}

float  bbCollisionX( Object *o,int index ){
	debugColl(o,index);
	return o->getCollisions()[index-1]->coords.x;
}

float  bbCollisionY( Object *o,int index ){
	debugColl(o,index);
	return o->getCollisions()[index-1]->coords.y;
}

float  bbCollisionZ( Object *o,int index ){
	debugColl(o,index);
	return o->getCollisions()[index-1]->coords.z;
}

float  bbCollisionNX( Object *o,int index ){
	debugColl(o,index);
	return o->getCollisions()[index-1]->collision.normal.x;
}

float  bbCollisionNY( Object *o,int index ){
	debugColl(o,index);
	return o->getCollisions()[index-1]->collision.normal.y;
}

float  bbCollisionNZ( Object *o,int index ){
	debugColl(o,index);
	return o->getCollisions()[index-1]->collision.normal.z;
}

float  bbCollisionTime( Object *o,int index ){
	debugColl(o,index);
	return o->getCollisions()[index-1]->collision.time;
}

Object *  bbCollisionEntity( Object *o,int index ){
	debugColl(o,index);
	return o->getCollisions()[index-1]->with;
}

void *  bbCollisionSurface( Object *o,int index ){
	debugColl(o,index);
	return o->getCollisions()[index-1]->collision.surface;
}

int  bbCollisionTriangle( Object *o,int index ){
	debugColl(o,index);
	return o->getCollisions()[index-1]->collision.index;
}

float  bbEntityDistance( Entity *src,Entity *dest ){
	debugEntity(src);
	debugEntity(dest);
	return src->getWorldPosition().distance( dest->getWorldPosition() );
}

////////////////////////////////////
// ENTITY TRANSFORMATION COMMANDS //
////////////////////////////////////
void  bbMoveEntity( Entity *e,float x,float y,float z ){
	debugEntity(e);
	e->setLocalPosition( e->getLocalPosition()+e->getLocalRotation()*Vector(x,y,z) );
}

void  bbTurnEntity( Entity *e,float p,float y,float r,int global ){
	debugEntity(e);
	global?
	e->setWorldRotation( rotationQuat( p*dtor,y*dtor,r*dtor )*e->getWorldRotation() ):
	e->setLocalRotation( e->getLocalRotation()*rotationQuat( p*dtor,y*dtor,r*dtor ) );
}

void  bbTranslateEntity( Entity *e,float x,float y,float z,int global ){
	debugEntity(e);
	global?
	e->setWorldPosition( e->getWorldPosition()+Vector( x,y,z ) ):
	e->setLocalPosition( e->getLocalPosition()+Vector( x,y,z ) );
}

void  bbPositionEntity( Entity *e,float x,float y,float z,int global ){
	debugEntity(e);
	global?
	e->setWorldPosition(Vector(x,y,z)):
	e->setLocalPosition(Vector(x,y,z));
}

void  bbScaleEntity( Entity *e,float x,float y,float z,int global ){
	debugEntity(e);
	global?
	e->setWorldScale(Vector(x,y,z)):
	e->setLocalScale(Vector(x,y,z));
}

void  bbRotateEntity( Entity *e,float p,float y,float r,int global ){
	debugEntity(e);
	global?
	e->setWorldRotation( rotationQuat( p*dtor,y*dtor,r*dtor ) ):
	e->setLocalRotation( rotationQuat( p*dtor,y*dtor,r*dtor ) );
}

void  bbPointEntity( Entity *e,Entity *t,float roll ){
	if( debug ){ debugEntity(e);debugEntity(t); }
	Vector v=t->getWorldTform().v-e->getWorldTform().v;
	e->setWorldRotation( rotationQuat( v.pitch(),v.yaw(),roll*dtor ) );
}

void  bbAlignToVector( Entity *e,float nx,float ny,float nz,int axis,float rate ){
	Vector ax( nx,ny,nz );
	float l=ax.length();
	if( l<=EPSILON ) return;
	ax/=l;

	Quat q=e->getWorldRotation();
	Vector tv=(axis==1) ? q.i() : (axis==2 ? q.j() : q.k());

	float dp=ax.dot( tv );

	if( dp>=1-EPSILON ) return;

	if( dp<=-1+EPSILON ){
		float an=PI*rate/2;
		Vector cp=(axis==1) ? q.j() : (axis==2 ? q.k() : q.i());
		e->setWorldRotation( Quat( cosf(an),cp*sinf(an) ) * q );
		return;
	}

	float an=acosf( dp )*rate/2;
	Vector cp=ax.cross( tv ).normalized();
	e->setWorldRotation( Quat( cosf(an),cp*sinf(an) ) * q );
}

//////////////////////////
// ENTITY MISC COMMANDS //
//////////////////////////
void  bbNameEntity( Entity *e,BBStr *t ){
	debugEntity(e);
	e->setName( *t );
	delete t;
}

BBStr *  bbEntityName( Entity *e ){
	debugEntity(e);
	return d_new BBStr( e->getName() );
}

BBStr *bbEntityClass( Entity *e ){
	debugEntity(e);
	const char *p="Pivot";
	if( e->getLight() ) p="Light";
	else if( e->getCamera() ) p="Camera";
	else if( e->getMirror() ) p="Mirror";
	else if( e->getListener() ) p="Listener";
	else if( Model *t=e->getModel() ){
		if( t->getSprite() ) p="Sprite";
		else if( t->getTerrain() ) p="Terrain";
		else if( t->getPlaneModel() ) p="Plane";
		else if( t->getMeshModel() ) p="Mesh";
		else if( t->getMD2Model() ) p="MD2";
		else if( t->getBSPModel() ) p="BSP";
	}
	return new BBStr(p);
}

void  bbClearWorld( int e,int b,int t ){
	if( e ){
		while( Entity::orphans() ) bbFreeEntity( Entity::orphans() );
	}
	if( b ){
		while( brush_set.size() ) bbFreeBrush( *brush_set.begin() );
	}
	if( t ){
		while( texture_set.size() ) bbFreeTexture( *texture_set.begin() );
	}
}

extern int active_texs;

int  bbActiveTextures(){
	return active_texs;
}

void blitz3d_open(){
	gx_scene=gx_graphics->createScene( 0 );
	if( !gx_scene ) RTEX( "Unable to create 3D Scene" );
	world=d_new World();
	projected=Vector();
	picked.collision=Collision();
	picked.with=0;picked.coords=Vector();
	Texture::clearFilters();
	Texture::addFilter( "",gxCanvas::CANVAS_TEX_RGB|gxCanvas::CANVAS_TEX_MIPMAP );
	loader_mat_map.clear();
	loader_mat_map["x"]=Transform();
	loader_mat_map["3ds"]=Transform(Matrix(Vector(1,0,0),Vector(0,0,1),Vector(0,1,0)));
	listener=0;
	stats_mode=false;
}

void blitz3d_close(){
	if( !gx_scene ) return;
	bbClearWorld( 1,1,1 );
	Texture::clearFilters();
	loader_mat_map.clear();
	delete world;
	gx_graphics->freeScene( gx_scene );
	gx_scene=0;
}

bool blitz3d_create(){
	tri_count=0;
	gx_scene=0;world=0;
	return true;
}

bool blitz3d_destroy(){
	blitz3d_close();
	return true;
}

void blitz3d_link( void (*rtSym)( const char *sym,void *pc ) ){
	rtSym( "LoaderMatrix$file_ext#xx#xy#xz#yx#yy#yz#zx#zy#zz",bbLoaderMatrix );
	rtSym( "HWMultiTex%enable",bbHWMultiTex );
	rtSym( "%HWTexUnits",bbHWTexUnits );
	rtSym( "%GfxDriverCaps3D",bbGfxDriverCaps3D );
	rtSym( "WBuffer%enable",bbWBuffer );
	rtSym( "Dither%enable",bbDither );
	rtSym( "AntiAlias%enable",bbAntiAlias );
	rtSym( "WireFrame%enable",bbWireFrame );
	rtSym( "AmbientLight#red#green#blue",bbAmbientLight );
	rtSym( "ClearCollisions",bbClearCollisions );
	rtSym( "Collisions%source_type%destination_type%method%response",bbCollisions );
	rtSym( "UpdateWorld#elapsed_time=1",bbUpdateWorld );
	rtSym( "CaptureWorld",bbCaptureWorld );
	rtSym( "RenderWorld#tween=1",bbRenderWorld );
	rtSym( "ClearWorld%entities=1%brushes=1%textures=1",bbClearWorld );
	rtSym( "%ActiveTextures",bbActiveTextures );
	rtSym( "%TrisRendered",bbTrisRendered );
	rtSym( "#Stats3D%type",bbStats3D );

	rtSym( "%CreateTexture%width%height%flags=0%frames=1",bbCreateTexture );
	rtSym( "%LoadTexture$file%flags=1",bbLoadTexture );
	rtSym( "%LoadAnimTexture$file%flags%width%height%first%count",bbLoadAnimTexture );
	rtSym( "FreeTexture%texture",bbFreeTexture );
	rtSym( "TextureBlend%texture%blend",bbTextureBlend );
	rtSym( "TextureCoords%texture%coords",bbTextureCoords );
	rtSym( "ScaleTexture%texture#u_scale#v_scale",bbScaleTexture );
	rtSym( "RotateTexture%texture#angle",bbRotateTexture );
	rtSym( "PositionTexture%texture#u_offset#v_offset",bbPositionTexture );
	rtSym( "%TextureWidth%texture",bbTextureWidth );
	rtSym( "%TextureHeight%texture",bbTextureHeight );
	rtSym( "$TextureName%texture",bbTextureName );
	rtSym( "SetCubeFace%texture%face",bbSetCubeFace );
	rtSym( "SetCubeMode%texture%mode",bbSetCubeMode );
	rtSym( "%TextureBuffer%texture%frame=0",bbTextureBuffer );
	rtSym( "ClearTextureFilters",bbClearTextureFilters );
	rtSym( "TextureFilter$match_text%texture_flags=0",bbTextureFilter );

	rtSym( "%CreateBrush#red=255#green=255#blue=255",bbCreateBrush );
	rtSym( "%LoadBrush$file%texture_flags=1#u_scale=1#v_scale=1",bbLoadBrush );
	rtSym( "FreeBrush%brush",bbFreeBrush );
	rtSym( "BrushColor%brush#red#green#blue",bbBrushColor );
	rtSym( "BrushAlpha%brush#alpha",bbBrushAlpha );
	rtSym( "BrushShininess%brush#shininess",bbBrushShininess );
	rtSym( "BrushTexture%brush%texture%frame=0%index=0",bbBrushTexture );
	rtSym( "%GetBrushTexture%brush%index=0",bbGetBrushTexture );
	rtSym( "BrushBlend%brush%blend",bbBrushBlend );
	rtSym( "BrushFX%brush%fx",bbBrushFX );

	rtSym( "%LoadMesh$file%parent=0",bbLoadMesh );
	rtSym( "%LoadAnimMesh$file%parent=0",bbLoadAnimMesh );
	rtSym( "%LoadAnimSeq%entity$file",bbLoadAnimSeq );

	rtSym( "%CreateMesh%parent=0",bbCreateMesh );
	rtSym( "%CreateCube%parent=0",bbCreateCube );
	rtSym( "%CreateSphere%segments=8%parent=0",bbCreateSphere );
	rtSym( "%CreateCylinder%segments=8%solid=1%parent=0",bbCreateCylinder );
	rtSym( "%CreateCone%segments=8%solid=1%parent=0",bbCreateCone );
	rtSym( "%CopyMesh%mesh%parent=0",bbCopyMesh );
	rtSym( "ScaleMesh%mesh#x_scale#y_scale#z_scale",bbScaleMesh );
	rtSym( "RotateMesh%mesh#pitch#yaw#roll",bbRotateMesh );
	rtSym( "PositionMesh%mesh#x#y#z",bbPositionMesh );
	rtSym( "FitMesh%mesh#x#y#z#width#height#depth%uniform=0",bbFitMesh );
	rtSym( "FlipMesh%mesh",bbFlipMesh );
	rtSym( "PaintMesh%mesh%brush",bbPaintMesh );
	rtSym( "AddMesh%source_mesh%dest_mesh",bbAddMesh );
	rtSym( "UpdateNormals%mesh",bbUpdateNormals );
	rtSym( "LightMesh%mesh#red#green#blue#range=0#x=0#y=0#z=0",bbLightMesh );
	rtSym( "#MeshWidth%mesh",bbMeshWidth );
	rtSym( "#MeshHeight%mesh",bbMeshHeight );
	rtSym( "#MeshDepth%mesh",bbMeshDepth );
	rtSym( "%MeshesIntersect%mesh_a%mesh_b",bbMeshesIntersect );
	rtSym( "%CountSurfaces%mesh",bbCountSurfaces );
	rtSym( "%GetSurface%mesh%surface_index",bbGetSurface );
	rtSym( "MeshCullBox%mesh#x#y#z#width#height#depth",bbMeshCullBox );
	
	rtSym( "%CreateSurface%mesh%brush=0",bbCreateSurface );
	rtSym( "%GetSurfaceBrush%surface",bbGetSurfaceBrush );
	rtSym( "%GetEntityBrush%entity",bbGetEntityBrush );
	rtSym( "%FindSurface%mesh%brush",bbFindSurface );
	rtSym( "ClearSurface%surface%clear_vertices=1%clear_triangles=1",bbClearSurface );
	rtSym( "PaintSurface%surface%brush",bbPaintSurface );
	rtSym( "%AddVertex%surface#x#y#z#u=0#v=0#w=1",bbAddVertex );
	rtSym( "%AddTriangle%surface%v0%v1%v2",bbAddTriangle );
	rtSym( "VertexCoords%surface%index#x#y#z",bbVertexCoords );
	rtSym( "VertexNormal%surface%index#nx#ny#nz",bbVertexNormal );
	rtSym( "VertexColor%surface%index#red#green#blue#alpha=1",bbVertexColor );
	rtSym( "VertexTexCoords%surface%index#u#v#w=1%coord_set=0",bbVertexTexCoords );
	rtSym( "%CountVertices%surface",bbCountVertices );
	rtSym( "%CountTriangles%surface",bbCountTriangles );
	rtSym( "#VertexX%surface%index",bbVertexX );
	rtSym( "#VertexY%surface%index",bbVertexY );
	rtSym( "#VertexZ%surface%index",bbVertexZ );
	rtSym( "#VertexNX%surface%index",bbVertexNX );
	rtSym( "#VertexNY%surface%index",bbVertexNY );
	rtSym( "#VertexNZ%surface%index",bbVertexNZ );
	rtSym( "#VertexRed%surface%index",bbVertexRed );
	rtSym( "#VertexGreen%surface%index",bbVertexGreen );
	rtSym( "#VertexBlue%surface%index",bbVertexBlue );
	rtSym( "#VertexAlpha%surface%index",bbVertexAlpha );
	rtSym( "#VertexU%surface%index%coord_set=0",bbVertexU );
	rtSym( "#VertexV%surface%index%coord_set=0",bbVertexV );
	rtSym( "#VertexW%surface%index%coord_set=0",bbVertexW );
	rtSym( "%TriangleVertex%surface%index%vertex",bbTriangleVertex );

	rtSym( "%CreateCamera%parent=0",bbCreateCamera );
	rtSym( "CameraZoom%camera#zoom",bbCameraZoom );
	rtSym( "CameraRange%camera#near#far",bbCameraRange );
	rtSym( "CameraClsColor%camera#red#green#blue",bbCameraClsColor );
	rtSym( "CameraClsMode%camera%cls_color%cls_zbuffer",bbCameraClsMode );
	rtSym( "CameraProjMode%camera%mode",bbCameraProjMode );
	rtSym( "CameraViewport%camera%x%y%width%height",bbCameraViewport );
	rtSym( "CameraFogColor%camera#red#green#blue",bbCameraFogColor );
	rtSym( "CameraFogRange%camera#near#far",bbCameraFogRange );
	rtSym( "CameraFogMode%camera%mode",bbCameraFogMode );
	rtSym( "CameraProject%camera#x#y#z",bbCameraProject );
	rtSym( "#ProjectedX",bbProjectedX );
	rtSym( "#ProjectedY",bbProjectedY );
	rtSym( "#ProjectedZ",bbProjectedZ );

	rtSym( "%EntityInView%entity%camera",bbEntityInView );
	rtSym( "%EntityVisible%src_entity%dest_entity",bbEntityVisible );

	rtSym( "%EntityPick%entity#range",bbEntityPick );
	rtSym( "%LinePick#x#y#z#dx#dy#dz#radius=0",bbLinePick );
	rtSym( "%CameraPick%camera#viewport_x#viewport_y",bbCameraPick );

	rtSym( "#PickedX",bbPickedX );
	rtSym( "#PickedY",bbPickedY );
	rtSym( "#PickedZ",bbPickedZ );
	rtSym( "#PickedNX",bbPickedNX );
	rtSym( "#PickedNY",bbPickedNY );
	rtSym( "#PickedNZ",bbPickedNZ );
	rtSym( "#PickedTime",bbPickedTime );
	rtSym( "%PickedEntity",bbPickedEntity );
	rtSym( "%PickedSurface",bbPickedSurface );
	rtSym( "%PickedTriangle",bbPickedTriangle );

	rtSym( "%CreateLight%type=1%parent=0",bbCreateLight );
	rtSym( "LightColor%light#red#green#blue",bbLightColor );
	rtSym( "LightRange%light#range",bbLightRange );
	rtSym( "LightConeAngles%light#inner_angle#outer_angle",bbLightConeAngles );

	rtSym( "%CreatePivot%parent=0",bbCreatePivot );

	rtSym( "%CreateSprite%parent=0",bbCreateSprite );
	rtSym( "%LoadSprite$file%texture_flags=1%parent=0",bbLoadSprite );
	rtSym( "RotateSprite%sprite#angle",bbRotateSprite );
	rtSym( "ScaleSprite%sprite#x_scale#y_scale",bbScaleSprite );
	rtSym( "HandleSprite%sprite#x_handle#y_handle",bbHandleSprite );
	rtSym( "SpriteViewMode%sprite%view_mode",bbSpriteViewMode );

	rtSym( "%LoadMD2$file%parent=0",bbLoadMD2 );
	rtSym( "AnimateMD2%md2%mode=1#speed=1%first_frame=0%last_frame=9999#transition=0",bbAnimateMD2 );
	rtSym( "#MD2AnimTime%md2",bbMD2AnimTime );
	rtSym( "%MD2AnimLength%md2",bbMD2AnimLength );
	rtSym( "%MD2Animating%md2",bbMD2Animating );

	rtSym( "%LoadBSP$file#gamma_adj=0%parent=0",bbLoadBSP );
	rtSym( "BSPLighting%bsp%use_lightmaps",bbBSPLighting );
	rtSym( "BSPAmbientLight%bsp#red#green#blue",bbBSPAmbientLight );

	rtSym( "%CreateMirror%parent=0",bbCreateMirror );

	rtSym( "%CreatePlane%segments=1%parent=0",bbCreatePlane );

	rtSym( "%CreateTerrain%grid_size%parent=0",bbCreateTerrain );
	rtSym( "%LoadTerrain$heightmap_file%parent=0",bbLoadTerrain );
	rtSym( "TerrainDetail%terrain%detail_level%morph=0",bbTerrainDetail );
	rtSym( "TerrainShading%terrain%enable",bbTerrainShading );
	rtSym( "#TerrainX%terrain#world_x#world_y#world_z",bbTerrainX );
	rtSym( "#TerrainY%terrain#world_x#world_y#world_z",bbTerrainY );
	rtSym( "#TerrainZ%terrain#world_x#world_y#world_z",bbTerrainZ );
	rtSym( "%TerrainSize%terrain",bbTerrainSize );
	rtSym( "#TerrainHeight%terrain%terrain_x%terrain_z",bbTerrainHeight );
	rtSym( "ModifyTerrain%terrain%terrain_x%terrain_z#height%realtime=0",bbModifyTerrain );

	rtSym( "%CreateListener%parent#rolloff_factor=1#doppler_scale=1#distance_scale=1",bbCreateListener );
	rtSym( "%EmitSound%sound%entity",bbEmitSound );

	rtSym( "%CopyEntity%entity%parent=0",bbCopyEntity );

	rtSym( "#EntityX%entity%global=0",bbEntityX );
	rtSym( "#EntityY%entity%global=0",bbEntityY );
	rtSym( "#EntityZ%entity%global=0",bbEntityZ );
	rtSym( "#EntityPitch%entity%global=0",bbEntityPitch );
	rtSym( "#EntityYaw%entity%global=0",bbEntityYaw );
	rtSym( "#EntityRoll%entity%global=0",bbEntityRoll );
	rtSym( "#GetMatElement%entity%row%column",bbGetMatElement );
	rtSym( "TFormPoint#x#y#z%source_entity%dest_entity",bbTFormPoint );
	rtSym( "TFormVector#x#y#z%source_entity%dest_entity",bbTFormVector );
	rtSym( "TFormNormal#x#y#z%source_entity%dest_entity",bbTFormNormal );
	rtSym( "#TFormedX",bbTFormedX );
	rtSym( "#TFormedY",bbTFormedY );
	rtSym( "#TFormedZ",bbTFormedZ );
	rtSym( "#VectorYaw#x#y#z",bbVectorYaw );
	rtSym( "#VectorPitch#x#y#z",bbVectorPitch );
	rtSym( "#DeltaPitch%src_entity%dest_entity",bbDeltaPitch );
	rtSym( "#DeltaYaw%src_entity%dest_entity",bbDeltaYaw );

	rtSym( "ResetEntity%entity",bbResetEntity );
	rtSym( "EntityType%entity%collision_type%recursive=0",bbEntityType );
	rtSym( "EntityPickMode%entity%pick_geometry%obscurer=1",bbEntityPickMode );
	rtSym( "%GetParent%entity",bbGetParent );
	rtSym( "%GetEntityType%entity",bbGetEntityType );
	rtSym( "EntityRadius%entity#x_radius#y_radius=0",bbEntityRadius );
	rtSym( "EntityBox%entity#x#y#z#width#height#depth",bbEntityBox );
	rtSym( "#EntityDistance%source_entity%destination_entity",bbEntityDistance );
	rtSym( "%EntityCollided%entity%type",bbEntityCollided );

	rtSym( "%CountCollisions%entity",bbCountCollisions );
	rtSym( "#CollisionX%entity%collision_index",bbCollisionX );
	rtSym( "#CollisionY%entity%collision_index",bbCollisionY );
	rtSym( "#CollisionZ%entity%collision_index",bbCollisionZ );
	rtSym( "#CollisionNX%entity%collision_index",bbCollisionNX );
	rtSym( "#CollisionNY%entity%collision_index",bbCollisionNY );
	rtSym( "#CollisionNZ%entity%collision_index",bbCollisionNZ );
	rtSym( "#CollisionTime%entity%collision_index",bbCollisionTime );
	rtSym( "%CollisionEntity%entity%collision_index",bbCollisionEntity );
	rtSym( "%CollisionSurface%entity%collision_index",bbCollisionSurface );
	rtSym( "%CollisionTriangle%entity%collision_index",bbCollisionTriangle );

	rtSym( "MoveEntity%entity#x#y#z",bbMoveEntity );
	rtSym( "TurnEntity%entity#pitch#yaw#roll%global=0",bbTurnEntity );
	rtSym( "TranslateEntity%entity#x#y#z%global=0",bbTranslateEntity );
	rtSym( "PositionEntity%entity#x#y#z%global=0",bbPositionEntity );
	rtSym( "ScaleEntity%entity#x_scale#y_scale#z_scale%global=0",bbScaleEntity );
	rtSym( "RotateEntity%entity#pitch#yaw#roll%global=0",bbRotateEntity );
	rtSym( "PointEntity%entity%target#roll=0",bbPointEntity );
	rtSym( "AlignToVector%entity#vector_x#vector_y#vector_z%axis#rate=1",bbAlignToVector );
	rtSym( "SetAnimTime%entity#time%anim_seq=0",bbSetAnimTime );
	rtSym( "Animate%entity%mode=1#speed=1%sequence=0#transition=0",bbAnimate );
	rtSym( "SetAnimKey%entity%frame%pos_key=1%rot_key=1%scale_key=1",bbSetAnimKey );
	rtSym( "%AddAnimSeq%entity%length",bbAddAnimSeq );
	rtSym( "%ExtractAnimSeq%entity%first_frame%last_frame%anim_seq=0",bbExtractAnimSeq );
	rtSym( "%AnimSeq%entity",bbAnimSeq );
	rtSym( "#AnimTime%entity",bbAnimTime );
	rtSym( "%AnimLength%entity",bbAnimLength );
	rtSym( "%Animating%entity",bbAnimating );

	rtSym( "EntityParent%entity%parent%global=1",bbEntityParent );
	rtSym( "%CountChildren%entity",bbCountChildren );
	rtSym( "%GetChild%entity%index",bbGetChild );
	rtSym( "%FindChild%entity$name",bbFindChild );

	rtSym( "PaintEntity%entity%brush",bbPaintEntity );
	rtSym( "EntityColor%entity#red#green#blue",bbEntityColor );
	rtSym( "EntityAlpha%entity#alpha",bbEntityAlpha );
	rtSym( "EntityShininess%entity#shininess",bbEntityShininess );
	rtSym( "EntityTexture%entity%texture%frame=0%index=0",bbEntityTexture );
	rtSym( "EntityBlend%entity%blend",bbEntityBlend );
	rtSym( "EntityFX%entity%fx",bbEntityFX );
	rtSym( "EntityAutoFade%entity#near#far",bbEntityAutoFade );
	rtSym( "EntityOrder%entity%order",bbEntityOrder );
	rtSym( "HideEntity%entity",bbHideEntity );
	rtSym( "ShowEntity%entity",bbShowEntity );
	rtSym( "FreeEntity%entity",bbFreeEntity );

	rtSym( "NameEntity%entity$name",bbNameEntity );
	rtSym( "$EntityName%entity",bbEntityName );
	rtSym( "$EntityClass%entity",bbEntityClass );
}

#endif