#include "std.h"
#include "gxscene.h"
#include "gxgraphics.h"
#include "gxruntime.h"

static bool can_wb;
static int  hw_tex_stages,tex_stages;
static float BLACK[]={0,0,0};
static float WHITE[]={1,1,1};
static float GRAY[]={.5f,.5f,.5f};
static D3DMATRIX sphere_mat,nullmatrix;

void gxScene::setRS( int n,int t ){
	if( d3d_rs[n]==t ) return;
	dir3dDev->SetRenderState( (D3DRENDERSTATETYPE)n,t );
	d3d_rs[n]=t;
}

void gxScene::setTSS( int n,int s,int t ){
	if( d3d_tss[n][s]==t ) return;
	dir3dDev->SetTextureStageState( n,(D3DTEXTURESTAGESTATETYPE)s,t );
	d3d_tss[n][s]=t;
}

gxScene::gxScene( gxGraphics *g,gxCanvas *t ):
graphics(g),target(t),dir3dDev( g->dir3dDev ),
n_texs(0),tris_drawn(0){

	memset( d3d_rs,0x55,sizeof(d3d_rs) );
	memset( d3d_tss,0x55,sizeof(d3d_tss) );

	//nomalize normals
	setRS( D3DRENDERSTATE_NORMALIZENORMALS,TRUE );

	//vertex coloring
	setRS( D3DRENDERSTATE_COLORVERTEX,FALSE );
	setRS( D3DRENDERSTATE_DIFFUSEMATERIALSOURCE,D3DMCS_COLOR1 );
	setRS( D3DRENDERSTATE_AMBIENTMATERIALSOURCE,D3DMCS_COLOR1 );
	setRS( D3DRENDERSTATE_EMISSIVEMATERIALSOURCE,D3DMCS_MATERIAL );
	setRS( D3DRENDERSTATE_SPECULARMATERIALSOURCE,D3DMCS_MATERIAL );

	//Alpha test
	setRS( D3DRENDERSTATE_ALPHATESTENABLE,false );
	setRS( D3DRENDERSTATE_ALPHAFUNC,D3DCMP_GREATER );
	setRS( D3DRENDERSTATE_ALPHAREF,128 );

	//source/dest blending modes
	setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA );
	setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_INVSRCALPHA );

	//suss out caps
	can_wb=false;
	hw_tex_stages=1;
	D3DDEVICEDESC7 devDesc={0};
	if( dir3dDev->GetCaps( &devDesc )>=0 ){
		DWORD caps=devDesc.dpcTriCaps.dwRasterCaps;
		//texture stages
		hw_tex_stages=devDesc.wMaxSimultaneousTextures;
		//depth buffer mode
		if( (caps & D3DPRASTERCAPS_WBUFFER) && graphics->zbuffFmt.dwRGBBitCount==16 ) can_wb=true;
		//fog mode
		if( (caps&D3DPRASTERCAPS_FOGTABLE)&&(caps&D3DPRASTERCAPS_WFOG) ){
			setRS( D3DRENDERSTATE_FOGVERTEXMODE,D3DFOG_NONE );
			setRS( D3DRENDERSTATE_FOGTABLEMODE,D3DFOG_LINEAR );
		}else{
			setRS( D3DRENDERSTATE_FOGTABLEMODE,D3DFOG_NONE );
			setRS( D3DRENDERSTATE_FOGVERTEXMODE,D3DFOG_LINEAR );
		}
	}
	tex_stages=hw_tex_stages;

	caps_level=100;
	if( devDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_CUBEMAP ){
		caps_level=110;
	}

	//default texture states
	for( int n=0;n<hw_tex_stages;++n ){
		setTSS( n,D3DTSS_COLORARG1,D3DTA_TEXTURE );
		setTSS( n,D3DTSS_COLORARG2,D3DTA_CURRENT );
		setTSS( n,D3DTSS_ALPHAARG1,D3DTA_TEXTURE );
		setTSS( n,D3DTSS_ALPHAARG2,D3DTA_CURRENT );
		setTSS( n,D3DTSS_MINFILTER,D3DTFN_LINEAR );
		setTSS( n,D3DTSS_MAGFILTER,D3DTFG_LINEAR );
		setTSS( n,D3DTSS_MIPFILTER,D3DTFP_LINEAR );
	}
	setHWMultiTex( true );

	//ATI lighting hack
	dir3dDev->LightEnable( 0,true );
	dir3dDev->LightEnable( 0,false );

	//globals
	sphere_mat._11=.5f;sphere_mat._22=-.5f;sphere_mat._33=.5f;
	sphere_mat._41=.5f;sphere_mat._42=.5f;sphere_mat._43=.5f;
	nullmatrix._11=nullmatrix._22=nullmatrix._33=nullmatrix._44=1;

	//set null renderstate
	memset(&material,0,sizeof(material));
	shininess=0;blend=BLEND_REPLACE;fx=0;
	for( int k=0;k<MAX_TEXTURES;++k ) memset( &texstate[k],0,sizeof(texstate[k]) );

	wbuffer=can_wb;
	dither=false;setDither( true );
	antialias=true;setAntialias( false );
	wireframe=true;setWireframe( false );
	flipped=true;setFlippedTris( false );
	ambient=~0;setAmbient( GRAY );
	ambient2=~0;setAmbient2( BLACK );
	fogcolor=~0;setFogColor( BLACK );
	fogrange_nr=fogrange_fr=0;setFogRange( 1,1000 );
	fogmode=FOG_LINEAR;setFogMode( FOG_NONE );
	zmode=-1;setZMode( ZMODE_NORMAL );
	memset(&projmatrix,0,sizeof(projmatrix));
	ortho_proj=true;frustum_nr=frustum_fr=frustum_w=frustum_h=0;setPerspProj( 1,1000,1,1 );
	memset(&viewport,0,sizeof(viewport));viewport.dvMaxZ=1;setViewport( 0,0,target->getWidth(),target->getHeight() );
	viewmatrix=nullmatrix;setViewMatrix( 0 );
	worldmatrix=nullmatrix;setWorldMatrix( 0 );

	//set default renderstate
	blend=fx=~0;shininess=1;
	RenderState state;memset(&state,0,sizeof(state));
	state.color[0]=state.color[1]=state.color[2]=state.alpha=1;
	state.blend=BLEND_REPLACE;
	setRenderState( state );
}

gxScene::~gxScene(){
	while( _allLights.size() ) freeLight( *_allLights.begin() );
}

void gxScene::setTexState( int n,const TexState &state,bool tex_blend ){

	int flags=state.canvas->getFlags();
	int tc_index=state.flags & TEX_COORDS2 ? 1 : 0;

	//set canvas
	dir3dDev->SetTexture( n,state.canvas->getTexSurface() );

	//set addressing modes
	setTSS( n,D3DTSS_ADDRESSU,(flags & gxCanvas::CANVAS_TEX_CLAMPU) ? D3DTADDRESS_CLAMP : D3DTADDRESS_WRAP );
	setTSS( n,D3DTSS_ADDRESSV,(flags & gxCanvas::CANVAS_TEX_CLAMPV) ? D3DTADDRESS_CLAMP : D3DTADDRESS_WRAP );

	//texgen
	switch( flags&(
		gxCanvas::CANVAS_TEX_SPHERE|
		gxCanvas::CANVAS_TEX_CUBE) ){

	case gxCanvas::CANVAS_TEX_SPHERE:
		setTSS( n,D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACENORMAL );//|tc_index );
		setTSS( n,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT2 );
		dir3dDev->SetTransform( (D3DTRANSFORMSTATETYPE)(D3DTRANSFORMSTATE_TEXTURE0+n),&sphere_mat );
		break;
	case gxCanvas::CANVAS_TEX_CUBE:
		switch( state.canvas->cubeMode() & 3 ){
		case gxCanvas::CUBEMODE_NORMAL:
			setTSS( n,D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACENORMAL );//|tc_index );
			break;
		case gxCanvas::CUBEMODE_POSITION:
			setTSS( n,D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEPOSITION );//|tc_index );
			break;
		default:
			setTSS( n,D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR );//|tc_index );
			break;
		}
		if( state.canvas->cubeMode() & 4 ){
			setTSS( n,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE );
		}else{
			setTSS( n,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT3 );//COUNT4|D3DTTFF_PROJECTED );
			dir3dDev->SetTransform( (D3DTRANSFORMSTATETYPE)(D3DTRANSFORMSTATE_TEXTURE0+n),&inv_viewmatrix );
		}
		break;
	default:
		setTSS( n,D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_PASSTHRU|tc_index );
		if( state.mat_valid){
			setTSS( n,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT2 );
			dir3dDev->SetTransform( (D3DTRANSFORMSTATETYPE)(D3DTRANSFORMSTATE_TEXTURE0+n),(D3DMATRIX*)&state.matrix );
		}else{
			setTSS( n,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE );
		}
	}

	if( !tex_blend ) return;

	//blending
	switch( state.blend ){
	case BLEND_ALPHA:
		setTSS( n,D3DTSS_COLOROP,D3DTOP_BLENDTEXTUREALPHA );
		break;
	case BLEND_MULTIPLY:
		setTSS( n,D3DTSS_COLOROP,D3DTOP_MODULATE);
		break;
	case BLEND_ADD:
		setTSS( n,D3DTSS_COLOROP,D3DTOP_ADD );
		break;
	case BLEND_DOT3:
		setTSS( n,D3DTSS_COLOROP,D3DTOP_DOTPRODUCT3 );
		break;
	case BLEND_MULTIPLY2:
		setTSS( n,D3DTSS_COLOROP,D3DTOP_MODULATE2X );
		break;
	}
	setTSS( n,D3DTSS_ALPHAOP,(flags & gxCanvas::CANVAS_TEX_ALPHA) ? D3DTOP_MODULATE : D3DTOP_SELECTARG2 );
}

int  gxScene::hwTexUnits(){
	return tex_stages;
}

int  gxScene::gfxDriverCaps3D(){
	return caps_level;
}

void gxScene::setZMode(){
	switch( zmode ){
	case ZMODE_NORMAL:
		setRS( D3DRENDERSTATE_ZENABLE,wbuffer ? D3DZB_USEW : D3DZB_TRUE );
		setRS( D3DRENDERSTATE_ZWRITEENABLE,true );
		break;
	case ZMODE_DISABLE:
		setRS( D3DRENDERSTATE_ZENABLE,D3DZB_FALSE );
		setRS( D3DRENDERSTATE_ZWRITEENABLE,false );
		break;
	case ZMODE_CMPONLY:
		setRS( D3DRENDERSTATE_ZENABLE,wbuffer ? D3DZB_USEW : D3DZB_TRUE );
		setRS( D3DRENDERSTATE_ZWRITEENABLE,false );
		break;
	}
}

void gxScene::setLights(){
	if( fx & FX_FULLBRIGHT ){
		//no lights on
		for( int n=0;n<_curLights.size();++n ) dir3dDev->LightEnable( n,false );
	}else if( fx & FX_CONDLIGHT ){
		//some lights on
		for( int n=0;n<_curLights.size();++n ){
			gxLight *light=_curLights[n];
			bool enable=light->d3d_light.dltType!=D3DLIGHT_DIRECTIONAL;
			dir3dDev->LightEnable( n,enable );
		}
	}else{
		//all lights on
		for( int n=0;n<_curLights.size();++n ) dir3dDev->LightEnable( n,true );
	}
}

void gxScene::setAmbient(){
	int n=(fx & FX_FULLBRIGHT) ? 0xffffff : ((fx & FX_CONDLIGHT) ? ambient2 : ambient);
	setRS( D3DRENDERSTATE_AMBIENT,n );
}

void gxScene::setFogMode(){
	bool fog= fogmode==FOG_LINEAR && !(fx&FX_NOFOG);
	setRS( D3DRENDERSTATE_FOGENABLE,fog );
}

void gxScene::setTriCull(){
	if( fx & FX_DOUBLESIDED ){
		setRS( D3DRENDERSTATE_CULLMODE,D3DCULL_NONE );
	}else if( flipped ){
		setRS( D3DRENDERSTATE_CULLMODE,D3DCULL_CW );
	}else{
		setRS( D3DRENDERSTATE_CULLMODE,D3DCULL_CCW );
	}
}

void gxScene::setHWMultiTex( bool e ){
	for( int n=0;n<8;++n ){
		setTSS( n,D3DTSS_COLOROP,D3DTOP_DISABLE );
		setTSS( n,D3DTSS_ALPHAOP,D3DTOP_DISABLE );
		dir3dDev->SetTexture( n,0 );
	}
	for( int k=0;k<MAX_TEXTURES;++k ){
		memset( &texstate[k],0,sizeof(texstate[k]) );
	}
	tex_stages=e ? hw_tex_stages : 1;
	n_texs=0;
}

void gxScene::setWBuffer( bool n ){
	if( n==wbuffer || !can_wb ) return;
	wbuffer=n;setZMode();
}

void gxScene::setDither( bool n ){
	if( n==dither ) return;
	dither=n;setRS( D3DRENDERSTATE_DITHERENABLE,dither ? true : false );
}

void gxScene::setAntialias( bool n ){
	if( n==antialias ) return;
	antialias=n;setRS( D3DRENDERSTATE_ANTIALIAS,antialias ? D3DANTIALIAS_SORTINDEPENDENT : D3DANTIALIAS_NONE );
}

void gxScene::setWireframe( bool n ){
	if( n==wireframe ) return;
	wireframe=n;setRS( D3DRENDERSTATE_FILLMODE,wireframe ? D3DFILL_WIREFRAME : D3DFILL_SOLID );
}

void gxScene::setFlippedTris( bool n ){
	if( n==flipped ) return;
	flipped=n;setTriCull();
}

void gxScene::setAmbient( const float rgb[] ){
	int n=(int(rgb[0]*255.0f)<<16)|(int(rgb[1]*255.0f)<<8)|int(rgb[2]*255.0f);
	ambient=n;setAmbient();
}

void gxScene::setAmbient2( const float rgb[] ){
	int n=(int(rgb[0]*255.0f)<<16)|(int(rgb[1]*255.0f)<<8)|int(rgb[2]*255.0f);
	ambient2=n;setAmbient();
}

void gxScene::setViewport( int x,int y,int w,int h ){
	if( x==viewport.dwX && y==viewport.dwY && w==viewport.dwWidth && h==viewport.dwHeight ) return;
	viewport.dwX=x;viewport.dwY=y;viewport.dwWidth=w;viewport.dwHeight=h;
	dir3dDev->SetViewport( &viewport );
}

void gxScene::setOrthoProj( float nr,float fr,float w,float h ){
	if( ortho_proj && nr==frustum_nr && fr==frustum_fr && w==frustum_w && h==frustum_h ) return;
	frustum_nr=nr;frustum_fr=fr;frustum_w=w;frustum_h=h;ortho_proj=true;
	float W=2/w;
	float H=2/h;
	float Q=1/(fr-nr);
	projmatrix._11=W;
	projmatrix._22=H;
	projmatrix._33=Q;
	projmatrix._34=0;
	projmatrix._43=-Q*nr;
	projmatrix._44=1;
	dir3dDev->SetTransform( D3DTRANSFORMSTATE_PROJECTION,&projmatrix );
}

void gxScene::setPerspProj( float nr,float fr,float w,float h ){
	if( !ortho_proj && nr==frustum_nr && fr==frustum_fr && w==frustum_w && h==frustum_h ) return;
	frustum_nr=nr;frustum_fr=fr;frustum_w=w;frustum_h=h;ortho_proj=false;
	float W=2*nr/w;
	float H=2*nr/h;
	float Q=fr/(fr-nr);
	projmatrix._11=W;
	projmatrix._22=H;
	projmatrix._33=Q;
	projmatrix._34=1;
	projmatrix._43=-Q*nr;
	projmatrix._44=0;
	dir3dDev->SetTransform( D3DTRANSFORMSTATE_PROJECTION,&projmatrix );
}

void gxScene::setFogColor( const float rgb[3] ){
	int n=(int(rgb[0]*255.0f)<<16)|(int(rgb[1]*255.0f)<<8)|int(rgb[2]*255.0f);
	if( n==fogcolor ) return;
	fogcolor=n;setRS( D3DRENDERSTATE_FOGCOLOR,fogcolor );
}

void gxScene::setFogRange( float nr,float fr ){
	if( nr==fogrange_nr && fr==fogrange_fr ) return;
	fogrange_nr=nr;fogrange_fr=fr;
	setRS( D3DRENDERSTATE_FOGSTART,*(DWORD*)&fogrange_nr );
	setRS( D3DRENDERSTATE_FOGEND,*(DWORD*)&fogrange_fr );
}

void gxScene::setFogMode( int n ){
	if( n==fogmode ) return;
	fogmode=n;setFogMode();
}

void gxScene::setZMode( int n ){
	if( n==zmode ) return;
	zmode=n;setZMode();
}

void gxScene::setViewMatrix( const Matrix *m ){
	if( m ){
		memcpy( &viewmatrix._11,m->elements[0],12 );
		memcpy( &viewmatrix._21,m->elements[1],12 );
		memcpy( &viewmatrix._31,m->elements[2],12 );
		memcpy( &viewmatrix._41,m->elements[3],12 );
		inv_viewmatrix._11=viewmatrix._11;inv_viewmatrix._21=viewmatrix._12;inv_viewmatrix._31=viewmatrix._13;
		inv_viewmatrix._12=viewmatrix._21;inv_viewmatrix._22=viewmatrix._22;inv_viewmatrix._32=viewmatrix._23;
		inv_viewmatrix._13=viewmatrix._31;inv_viewmatrix._23=viewmatrix._32;inv_viewmatrix._33=viewmatrix._33;
		inv_viewmatrix._44=viewmatrix._44;
	}else{
		viewmatrix=inv_viewmatrix=nullmatrix;
	}

	dir3dDev->SetTransform( D3DTRANSFORMSTATE_VIEW,&viewmatrix );
}

void gxScene::setWorldMatrix( const Matrix *m ){
	if( m ){
		memcpy( &worldmatrix._11,m->elements[0],12 );
		memcpy( &worldmatrix._21,m->elements[1],12 );
		memcpy( &worldmatrix._31,m->elements[2],12 );
		memcpy( &worldmatrix._41,m->elements[3],12 );
	}else worldmatrix=nullmatrix;
	dir3dDev->SetTransform( D3DTRANSFORMSTATE_WORLD,&worldmatrix );
}

void gxScene::setRenderState( const RenderState &rs ){
	bool setmat=false;
	if( memcmp( rs.color,&material.diffuse.r,12 ) ){
		memcpy( &material.diffuse.r,rs.color,12 );
		memcpy( &material.ambient.r,rs.color,12 );
		setmat=true;
	}
	if( rs.alpha!=material.diffuse.a ){
		material.diffuse.a=rs.alpha;
		if( rs.fx&FX_ALPHATEST ){
			int alpharef=(rs.fx&FX_VERTEXALPHA)?0:128*rs.alpha;
			setRS( D3DRENDERSTATE_ALPHAREF,alpharef );
		}
		setmat=true;
	}
	if( rs.shininess!=shininess ){
		shininess=rs.shininess;
		float t=shininess>0 ? (shininess<1 ? shininess : 1) : 0;
		material.specular.r=material.specular.g=material.specular.b=t;
		material.power=shininess*128;
		setRS( D3DRENDERSTATE_SPECULARENABLE,shininess>0 ? true : false );
		setmat=true;
	}
	if( rs.blend!=blend ){
		blend=rs.blend;
		switch( blend ){
		case BLEND_REPLACE:
			setRS( D3DRENDERSTATE_ALPHABLENDENABLE,false );
			break;
		case BLEND_ALPHA:
			setRS( D3DRENDERSTATE_ALPHABLENDENABLE,true );
			setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA );
			setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_INVSRCALPHA );
			break;
		case BLEND_MULTIPLY:
			setRS( D3DRENDERSTATE_ALPHABLENDENABLE,true );
			setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_DESTCOLOR );
			setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_ZERO );
			break;
		case BLEND_ADD:
			setRS( D3DRENDERSTATE_ALPHABLENDENABLE,true );
			setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA );
			setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_ONE );
			break;
		}
	}
	if( rs.fx!=fx ){
		int t=rs.fx^fx;fx=rs.fx;
		if( t & (FX_FULLBRIGHT|FX_CONDLIGHT) ){
			setLights();
			setAmbient();
		}
		if( t&FX_VERTEXCOLOR ){
			setRS( D3DRENDERSTATE_COLORVERTEX,fx & FX_VERTEXCOLOR ? true : false );
		}
		if( t&FX_FLATSHADED ){
			setRS( D3DRENDERSTATE_SHADEMODE,fx & FX_FLATSHADED ? D3DSHADE_FLAT : D3DSHADE_GOURAUD );
		}
		if( t&FX_NOFOG ){
			setFogMode();
		}
		if( t&FX_DOUBLESIDED ){
			setTriCull();
		}
		if( t&FX_EMISSIVE ){
			//Q3 Hack!
			int n=fx & FX_EMISSIVE;
			setRS( D3DRENDERSTATE_DIFFUSEMATERIALSOURCE,n ? D3DMCS_MATERIAL : D3DMCS_COLOR1 );
			setRS( D3DRENDERSTATE_AMBIENTMATERIALSOURCE,n ? D3DMCS_MATERIAL : D3DMCS_COLOR1 );
			setRS( D3DRENDERSTATE_EMISSIVEMATERIALSOURCE,n ? D3DMCS_COLOR1 : D3DMCS_MATERIAL );
			setRS( D3DRENDERSTATE_COLORVERTEX,n ? true : false );
		}
		if( t&FX_ALPHATEST ){
			if( fx&FX_ALPHATEST ){
				int alpharef=(rs.fx&FX_VERTEXALPHA)?0:128*rs.alpha;
				setRS( D3DRENDERSTATE_ALPHAREF,alpharef );
			}
			setRS( D3DRENDERSTATE_ALPHATESTENABLE,fx & FX_ALPHATEST ? true : false );
		}
	}
	if( setmat ){
		dir3dDev->SetMaterial( &material );
	}

	n_texs=0;
	TexState *hw=texstate;
	for( int k=0;k<MAX_TEXTURES;++k ){
		const RenderState::TexState &ts=rs.tex_states[k];
		if( !ts.canvas || !ts.blend ) continue;
		bool settex=false;
		ts.canvas->getTexSurface();	//force mipmap rebuild
		if( ts.canvas!=hw->canvas ){ hw->canvas=ts.canvas;settex=true; }
		if( ts.blend!=hw->blend ){ hw->blend=ts.blend;settex=true; }
		if( ts.flags!=hw->flags ){ hw->flags=ts.flags;settex=true; }
		if( ts.matrix || hw->mat_valid ){
			if( ts.matrix ){
				memcpy( &hw->matrix._11,ts.matrix->elements[0],12 );
				memcpy( &hw->matrix._21,ts.matrix->elements[1],12 );
				memcpy( &hw->matrix._31,ts.matrix->elements[2],12 );
				memcpy( &hw->matrix._41,ts.matrix->elements[3],12 );
				hw->mat_valid=true;
			}else{
				hw->mat_valid=false;
			}
			settex=true;
		}
		if( settex && n_texs<tex_stages ){
			setTexState( n_texs,*hw,true );
		}
		++hw;++n_texs;
	}
	if( n_texs<tex_stages && hw->canvas ){
		hw->canvas=0;
		setTSS( n_texs,D3DTSS_COLOROP,D3DTOP_DISABLE );
		setTSS( n_texs,D3DTSS_ALPHAOP,D3DTOP_DISABLE );
		dir3dDev->SetTexture( n_texs,0 );
	}
}

bool gxScene::begin( const vector<gxLight*> &lights ){

	if( dir3dDev->BeginScene()!=D3D_OK ) return false;

	//clear textures!
	int n;
	for( n=0;n<tex_stages;++n ){
		texstate[n].canvas=0;
		setTSS( n,D3DTSS_COLOROP,D3DTOP_DISABLE );
		setTSS( n,D3DTSS_ALPHAOP,D3DTOP_DISABLE );
		dir3dDev->SetTexture( n,0 );
	}

	//set light states
	_curLights.clear();
	for( n=0;n<8;++n ){
		if( n<lights.size() ){
			_curLights.push_back( lights[n] );
			dir3dDev->SetLight( n,&_curLights[n]->d3d_light );
		}else{
			dir3dDev->LightEnable( n,false );
		}
	}
	setLights();

	return true;
}

void gxScene::clear( const float rgb[3],float alpha,float z,bool clear_argb,bool clear_z ){
	if( !clear_argb && !clear_z ) return;
	int flags=(clear_argb ? D3DCLEAR_TARGET : 0) | (clear_z ? D3DCLEAR_ZBUFFER : 0);
	unsigned argb=(int(alpha*255.0f)<<24)|(int(rgb[0]*255.0f)<<16)|(int(rgb[1]*255.0f)<<8)|int(rgb[2]*255.0f);
	dir3dDev->Clear( 0,0,flags,argb,z,0 );
}

void gxScene::render( gxMesh *m,int first_vert,int vert_cnt,int first_tri,int tri_cnt ){

	m->render( first_vert,vert_cnt,first_tri,tri_cnt );
	tris_drawn+=tri_cnt;
	if( n_texs<=tex_stages ) return;

	setTSS( 0,D3DTSS_COLOROP,D3DTOP_SELECTARG1 );
	setTSS( 0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG1 );
	if( tex_stages>1 ){
		setTSS( 1,D3DTSS_COLOROP,D3DTOP_DISABLE );
		setTSS( 1,D3DTSS_ALPHAOP,D3DTOP_DISABLE );
	}

	setRS( D3DRENDERSTATE_LIGHTING,false );
	setRS( D3DRENDERSTATE_ALPHABLENDENABLE,true );

	for( int k=tex_stages;k<n_texs;++k ){
		const TexState &state=texstate[k];
		switch( state.blend ){
		case BLEND_ALPHA:
			setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA );
			setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_INVSRCALPHA );
			break;
		case BLEND_MULTIPLY:case BLEND_DOT3:
			setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_DESTCOLOR );
			setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_ZERO );
			break;
		case BLEND_ADD:
			setRS( D3DRENDERSTATE_SRCBLEND,D3DBLEND_ONE );
			setRS( D3DRENDERSTATE_DESTBLEND,D3DBLEND_ONE );
			break;
		}
		setTexState( 0,state,false );
		m->render( first_vert,vert_cnt,first_tri,tri_cnt );
		tris_drawn+=tri_cnt;
	}

	setRS( D3DRENDERSTATE_ALPHABLENDENABLE,false );
	setRS( D3DRENDERSTATE_LIGHTING,true );
	if( tex_stages>1 ) setTexState( 1,texstate[1],true );
	setTexState( 0,texstate[0],true );
}

void gxScene::end(){
	dir3dDev->EndScene();
	RECT r={ viewport.dwX,viewport.dwY,viewport.dwX+viewport.dwWidth,viewport.dwY+viewport.dwHeight };
	target->damage( r );
}

gxLight *gxScene::createLight( int flags ){
	gxLight *l=d_new gxLight( this,flags );
	_allLights.insert(l);
	return l;
}

void gxScene::freeLight( gxLight *l ){
	_allLights.erase(l);
}

int gxScene::getTrianglesDrawn()const{
	return tris_drawn;
}