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

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 = new gxLight(this, flags);
	_allLights.insert(l);
	return l;
}

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

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