bgfx/examples/14-shadowvolumes/shadowvolumes.cpp

/*
 * Copyright 2013-2014 Dario Manesku. All rights reserved.
 * License: http://www.opensource.org/licenses/BSD-2-Clause
 */

#include <stdio.h>
#include <string.h>

#include <string>
#include <vector>
#include <unordered_map>
#include <map>

namespace std { namespace tr1 {} }
using namespace std::tr1;

#include "common.h"

#include <bgfx.h>
#include <bx/timer.h>
#include <bx/readerwriter.h>
#include <bx/allocator.h>
#include <bx/hash.h>
#include <bx/float4_t.h>
#include "entry/entry.h"
#include "camera.h"
#include "fpumath.h"
#include "imgui/imgui.h"

#define SV_USE_SIMD 1
#define MAX_INSTANCE_COUNT 25
#define MAX_LIGHTS_COUNT 5

#define VIEWID_RANGE1_PASS0     1
#define VIEWID_RANGE1_RT_PASS1  2
#define VIEWID_RANGE15_PASS2    3
#define VIEWID_RANGE1_PASS3    20

uint32_t packUint32(uint8_t _x, uint8_t _y, uint8_t _z, uint8_t _w)
{
	union
	{
		uint32_t ui32;
		uint8_t arr[4];
	} un;

	un.arr[0] = _x;
	un.arr[1] = _y;
	un.arr[2] = _z;
	un.arr[3] = _w;

	return un.ui32;
}

uint32_t packF4u(float _x, float _y = 0.0f, float _z = 0.0f, float _w = 0.0f)
{
	const uint8_t xx = uint8_t(_x*127.0f + 128.0f);
	const uint8_t yy = uint8_t(_y*127.0f + 128.0f);
	const uint8_t zz = uint8_t(_z*127.0f + 128.0f);
	const uint8_t ww = uint8_t(_w*127.0f + 128.0f);
	return packUint32(xx, yy, zz, ww);
}

struct PosNormalTexcoordVertex
{
	float    m_x;
	float    m_y;
	float    m_z;
	uint32_t m_normal;
	float    m_u;
	float    m_v;
};

static const float s_texcoord = 50.0f;
static const uint32_t s_numHPlaneVertices = 4;
static PosNormalTexcoordVertex s_hplaneVertices[s_numHPlaneVertices] =
{
	{ -1.0f, 0.0f,  1.0f, packF4u(0.0f, 1.0f, 0.0f), s_texcoord, s_texcoord },
	{  1.0f, 0.0f,  1.0f, packF4u(0.0f, 1.0f, 0.0f), s_texcoord, 0.0f       },
	{ -1.0f, 0.0f, -1.0f, packF4u(0.0f, 1.0f, 0.0f), 0.0f,       s_texcoord },
	{  1.0f, 0.0f, -1.0f, packF4u(0.0f, 1.0f, 0.0f), 0.0f,       0.0f       },
};

static const uint32_t s_numVPlaneVertices = 4;
static PosNormalTexcoordVertex s_vplaneVertices[s_numVPlaneVertices] =
{
	{ -1.0f,  1.0f, 0.0f, packF4u(0.0f, 0.0f, -1.0f), 1.0f, 1.0f },
	{  1.0f,  1.0f, 0.0f, packF4u(0.0f, 0.0f, -1.0f), 1.0f, 0.0f },
	{ -1.0f, -1.0f, 0.0f, packF4u(0.0f, 0.0f, -1.0f), 0.0f, 1.0f },
	{  1.0f, -1.0f, 0.0f, packF4u(0.0f, 0.0f, -1.0f), 0.0f, 0.0f },
};

static const uint32_t s_numPlaneIndices = 6;
static const uint16_t s_planeIndices[s_numPlaneIndices] =
{
	0, 1, 2,
	1, 3, 2,
};

static const char* s_shaderPath = NULL;
static bool s_flipV = false;
static float s_texelHalf = 0.0f;

static uint32_t s_viewMask = 0;

static bgfx::UniformHandle u_texColor;
static bgfx::UniformHandle u_texStencil;
static bgfx::FrameBufferHandle s_stencilFb;

inline uint32_t uint32_max(uint32_t _a, uint32_t _b)
{
	return _a > _b ? _a : _b;
}

static void shaderFilePath(char* _out, const char* _name)
{
	strcpy(_out, s_shaderPath);
	strcat(_out, _name);
	strcat(_out, ".bin");
}

long int fsize(FILE* _file)
{
	long int pos = ftell(_file);
	fseek(_file, 0L, SEEK_END);
	long int size = ftell(_file);
	fseek(_file, pos, SEEK_SET);
	return size;
}

static const bgfx::Memory* load(const char* _filePath)
{
	FILE* file = fopen(_filePath, "rb");
	if (NULL != file)
	{
		uint32_t size = (uint32_t)fsize(file);
		const bgfx::Memory* mem = bgfx::alloc(size+1);
		size_t ignore = fread(mem->data, 1, size, file);
		BX_UNUSED(ignore);
		fclose(file);
		mem->data[mem->size-1] = '\0';
		return mem;
	}

	return NULL;
}

static const bgfx::Memory* loadShader(const char* _name)
{
	char filePath[512];
	shaderFilePath(filePath, _name);
	return load(filePath);
}

static const bgfx::Memory* loadTexture(const char* _name)
{
	char filePath[512];
	strcpy(filePath, "textures/");
	strcat(filePath, _name);
	return load(filePath);
}

static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
{
	const bgfx::Memory* mem;

	// Load vertex shader.
	mem = loadShader(_vsName);
	bgfx::ShaderHandle vsh = bgfx::createShader(mem);

	// Load fragment shader.
	mem = loadShader(_fsName);
	bgfx::ShaderHandle fsh = bgfx::createShader(mem);

	// Create program from shaders.
	return bgfx::createProgram(vsh, fsh, true /* destroy shaders when program is destroyed */);
}

void mtxBillboard(float* __restrict _result
				  , const float* __restrict _view
				  , const float* __restrict _pos
				  , const float* __restrict _scale
				  )
{
	_result[ 0] = _view[0]  * _scale[0];
	_result[ 1] = _view[4]  * _scale[0];
	_result[ 2] = _view[8]  * _scale[0];
	_result[ 3] = 0.0f;
	_result[ 4] = _view[1]  * _scale[1];
	_result[ 5] = _view[5]  * _scale[1];
	_result[ 6] = _view[9]  * _scale[1];
	_result[ 7] = 0.0f;
	_result[ 8] = _view[2]  * _scale[2];
	_result[ 9] = _view[6]  * _scale[2];
	_result[10] = _view[10] * _scale[2];
	_result[11] = 0.0f;
	_result[12] = _pos[0];
	_result[13] = _pos[1];
	_result[14] = _pos[2];
	_result[15] = 1.0f;
}

void planeNormal(float* __restrict _result
				 , const float* __restrict _v0
				 , const float* __restrict _v1
				 , const float* __restrict _v2
				 )
{
	float vec0[3], vec1[3];
	float cross[3];

	vec0[0] = _v1[0] - _v0[0];
	vec0[1] = _v1[1] - _v0[1];
	vec0[2] = _v1[2] - _v0[2];

	vec1[0] = _v2[0] - _v1[0];
	vec1[1] = _v2[1] - _v1[1];
	vec1[2] = _v2[2] - _v1[2];

	vec3Cross(cross, vec0, vec1);
	vec3Norm(_result, cross);

	_result[3] = -vec3Dot(_result, _v0);
}

struct Uniforms
{
	void init()
	{
		m_params.m_ambientPass   = 1.0f;
		m_params.m_lightningPass = 1.0f;
		m_params.m_texelHalf     = 0.0f;

		m_ambient[0] = 0.05f;
		m_ambient[1] = 0.05f;
		m_ambient[2] = 0.05f;
		m_ambient[3] = 0.0f; //unused

		m_diffuse[0] = 0.8f;
		m_diffuse[1] = 0.8f;
		m_diffuse[2] = 0.8f;
		m_diffuse[3] = 0.0f; //unused

		m_specular_shininess[0] = 1.0f;
		m_specular_shininess[1] = 1.0f;
		m_specular_shininess[2] = 1.0f;
		m_specular_shininess[3] = 25.0f; //shininess

		m_fog[0] = 0.0f; //color
		m_fog[1] = 0.0f;
		m_fog[2] = 0.0f;
		m_fog[3] = 0.0055f; //density

		m_color[0] = 1.0f;
		m_color[1] = 1.0f;
		m_color[2] = 1.0f;
		m_color[3] = 1.0f;

		m_time = 0.0f;

		m_flipV = float(s_flipV) * 2.0f - 1.0f;

		m_lightPosRadius[0] = 0.0f;
		m_lightPosRadius[1] = 0.0f;
		m_lightPosRadius[2] = 0.0f;
		m_lightPosRadius[3] = 1.0f;

		m_lightRgbInnerR[0] = 0.0f;
		m_lightRgbInnerR[1] = 0.0f;
		m_lightRgbInnerR[2] = 0.0f;
		m_lightRgbInnerR[3] = 1.0f;

		m_virtualLightPos_extrusionDist[0] = 0.0f;
		m_virtualLightPos_extrusionDist[1] = 0.0f;
		m_virtualLightPos_extrusionDist[2] = 0.0f;
		m_virtualLightPos_extrusionDist[3] = 100.0f;

		u_params                        = bgfx::createUniform("u_params",                        bgfx::UniformType::Uniform4fv);
		u_svparams                      = bgfx::createUniform("u_svparams",                      bgfx::UniformType::Uniform4fv);
		u_ambient                       = bgfx::createUniform("u_ambient",                       bgfx::UniformType::Uniform4fv);
		u_diffuse                       = bgfx::createUniform("u_diffuse",                       bgfx::UniformType::Uniform4fv);
		u_specular_shininess            = bgfx::createUniform("u_specular_shininess",            bgfx::UniformType::Uniform4fv);
		u_fog                           = bgfx::createUniform("u_fog",                           bgfx::UniformType::Uniform4fv);
		u_color                         = bgfx::createUniform("u_color",                         bgfx::UniformType::Uniform4fv);
		u_time                          = bgfx::createUniform("u_time",                          bgfx::UniformType::Uniform1f );
		u_flipV                         = bgfx::createUniform("u_flipV",                         bgfx::UniformType::Uniform1f );
		u_lightPosRadius                = bgfx::createUniform("u_lightPosRadius",                bgfx::UniformType::Uniform4fv);
		u_lightRgbInnerR                = bgfx::createUniform("u_lightRgbInnerR",                bgfx::UniformType::Uniform4fv);
		u_virtualLightPos_extrusionDist = bgfx::createUniform("u_virtualLightPos_extrusionDist", bgfx::UniformType::Uniform4fv);
	}

	//call this once at initialization
	void submitConstUniforms()
	{
		bgfx::setUniform(u_ambient,            &m_ambient);
		bgfx::setUniform(u_diffuse,            &m_diffuse);
		bgfx::setUniform(u_specular_shininess, &m_specular_shininess);
		bgfx::setUniform(u_fog,                &m_fog);
		bgfx::setUniform(u_flipV,              &m_flipV);
	}

	//call this once per frame
	void submitPerFrameUniforms()
	{
		bgfx::setUniform(u_time, &m_time);
	}

	//call this before each draw call
	void submitPerDrawUniforms()
	{
		bgfx::setUniform(u_params,                        &m_params);
		bgfx::setUniform(u_svparams,                      &m_svparams);
		bgfx::setUniform(u_color,                         &m_color);
		bgfx::setUniform(u_lightPosRadius,                &m_lightPosRadius);
		bgfx::setUniform(u_lightRgbInnerR,                &m_lightRgbInnerR);
		bgfx::setUniform(u_virtualLightPos_extrusionDist, &m_virtualLightPos_extrusionDist);
	}

	void destroy()
	{
		bgfx::destroyUniform(u_params);
		bgfx::destroyUniform(u_svparams);
		bgfx::destroyUniform(u_ambient);
		bgfx::destroyUniform(u_diffuse);
		bgfx::destroyUniform(u_specular_shininess);
		bgfx::destroyUniform(u_fog);
		bgfx::destroyUniform(u_color);
		bgfx::destroyUniform(u_time);
		bgfx::destroyUniform(u_flipV);
		bgfx::destroyUniform(u_lightPosRadius);
		bgfx::destroyUniform(u_lightRgbInnerR);
		bgfx::destroyUniform(u_virtualLightPos_extrusionDist);
	}

	struct Params
	{
		float m_ambientPass;
		float m_lightningPass;
		float m_texelHalf;
		float m_unused00;
	};

	struct SvParams
	{
		float m_useStencilTex;
		float m_dfail;
		float m_unused10;
		float m_unused11;
	};

	Params m_params;
	SvParams m_svparams;
	float m_ambient[4];
	float m_diffuse[4];
	float m_specular_shininess[4];
	float m_fog[4];
	float m_color[4];
	float m_time;
	float m_flipV;
	float m_lightPosRadius[4];
	float m_lightRgbInnerR[4];
	float m_virtualLightPos_extrusionDist[4];

	/**
	 * u_params.x - u_ambientPass
	 * u_params.y - u_lightningPass
	 * u_params.z - u_texelHalf
	 * u_params.w - unused

	 * u_svparams.x - u_useStencilTex
	 * u_svparams.y - u_dfail
	 * u_svparams.z - unused
	 * u_svparams.w - unused
	 */

	bgfx::UniformHandle u_params;
	bgfx::UniformHandle u_svparams;
	bgfx::UniformHandle u_ambient;
	bgfx::UniformHandle u_diffuse;
	bgfx::UniformHandle u_specular_shininess;
	bgfx::UniformHandle u_fog;
	bgfx::UniformHandle u_color;
	bgfx::UniformHandle u_time;
	bgfx::UniformHandle u_flipV;
	bgfx::UniformHandle u_lightPosRadius;
	bgfx::UniformHandle u_lightRgbInnerR;
	bgfx::UniformHandle u_virtualLightPos_extrusionDist;
};

static Uniforms s_uniforms;

struct RenderState
{
	enum Enum
	{
		ShadowVolume_UsingStencilTexture_DrawAmbient = 0,
		ShadowVolume_UsingStencilTexture_BuildDepth,
		ShadowVolume_UsingStencilTexture_CraftStencil_DepthPass,
		ShadowVolume_UsingStencilTexture_CraftStencil_DepthFail,
		ShadowVolume_UsingStencilTexture_DrawDiffuse,

		ShadowVolume_UsingStencilBuffer_DrawAmbient,
		ShadowVolume_UsingStencilBuffer_CraftStencil_DepthPass,
		ShadowVolume_UsingStencilBuffer_CraftStencil_DepthFail,
		ShadowVolume_UsingStencilBuffer_DrawDiffuse,

		Custom_Default,
		Custom_BlendLightTexture,
		Custom_DrawPlaneBottom,
		Custom_DrawShadowVolume_Lines,

		Count
	};

	uint64_t m_state;
	uint32_t m_blendFactorRgba;
	uint32_t m_fstencil;
	uint32_t m_bstencil;
};

static void setRenderState(const RenderState& _renderState)
{
	bgfx::setStencil(_renderState.m_fstencil, _renderState.m_bstencil);
	bgfx::setState(_renderState.m_state, _renderState.m_blendFactorRgba);
}

static RenderState s_renderStates[RenderState::Count]  =
{
	{ // ShadowVolume_UsingStencilTexture_DrawAmbient
		BGFX_STATE_RGB_WRITE
		| BGFX_STATE_ALPHA_WRITE
		| BGFX_STATE_DEPTH_WRITE
		| BGFX_STATE_DEPTH_TEST_LESS
		| BGFX_STATE_CULL_CCW
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_NONE
		, BGFX_STENCIL_NONE
	},
	{ // ShadowVolume_UsingStencilTexture_BuildDepth
		BGFX_STATE_DEPTH_WRITE
		| BGFX_STATE_DEPTH_TEST_LESS
		| BGFX_STATE_CULL_CCW
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_NONE
		, BGFX_STENCIL_NONE
	},
	{ // ShadowVolume_UsingStencilTexture_CraftStencil_DepthPass
		BGFX_STATE_RGB_WRITE
		| BGFX_STATE_ALPHA_WRITE
		| BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE)
		| BGFX_STATE_DEPTH_TEST_LEQUAL
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_NONE
		, BGFX_STENCIL_NONE
	},
	{ // ShadowVolume_UsingStencilTexture_CraftStencil_DepthFail
		BGFX_STATE_RGB_WRITE
		| BGFX_STATE_ALPHA_WRITE
		| BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE)
		| BGFX_STATE_DEPTH_TEST_GEQUAL
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_NONE
		, BGFX_STENCIL_NONE
		},
	{ // ShadowVolume_UsingStencilTexture_DrawDiffuse
		BGFX_STATE_RGB_WRITE
		| BGFX_STATE_ALPHA_WRITE
		| BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE)
		| BGFX_STATE_DEPTH_WRITE
		| BGFX_STATE_DEPTH_TEST_EQUAL
		| BGFX_STATE_CULL_CCW
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_NONE
		, BGFX_STENCIL_NONE
	},
	{ // ShadowVolume_UsingStencilBuffer_DrawAmbient
		BGFX_STATE_RGB_WRITE
		| BGFX_STATE_ALPHA_WRITE
		| BGFX_STATE_DEPTH_WRITE
		| BGFX_STATE_DEPTH_TEST_LESS
		| BGFX_STATE_CULL_CCW
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_NONE
		, BGFX_STENCIL_NONE
	},
	{ // ShadowVolume_UsingStencilBuffer_CraftStencil_DepthPass
		BGFX_STATE_DEPTH_TEST_LEQUAL
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_TEST_ALWAYS
		| BGFX_STENCIL_FUNC_REF(1)
		| BGFX_STENCIL_FUNC_RMASK(0xff)
		| BGFX_STENCIL_OP_FAIL_S_KEEP
		| BGFX_STENCIL_OP_FAIL_Z_KEEP
		| BGFX_STENCIL_OP_PASS_Z_DECR
		, BGFX_STENCIL_TEST_ALWAYS
		| BGFX_STENCIL_FUNC_REF(1)
		| BGFX_STENCIL_FUNC_RMASK(0xff)
		| BGFX_STENCIL_OP_FAIL_S_KEEP
		| BGFX_STENCIL_OP_FAIL_Z_KEEP
		| BGFX_STENCIL_OP_PASS_Z_INCR
	},
	{ // ShadowVolume_UsingStencilBuffer_CraftStencil_DepthFail
		BGFX_STATE_DEPTH_TEST_LEQUAL
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_TEST_ALWAYS
		| BGFX_STENCIL_FUNC_REF(1)
		| BGFX_STENCIL_FUNC_RMASK(0xff)
		| BGFX_STENCIL_OP_FAIL_S_KEEP
		| BGFX_STENCIL_OP_FAIL_Z_INCR
		| BGFX_STENCIL_OP_PASS_Z_KEEP
		, BGFX_STENCIL_TEST_ALWAYS
		| BGFX_STENCIL_FUNC_REF(1)
		| BGFX_STENCIL_FUNC_RMASK(0xff)
		| BGFX_STENCIL_OP_FAIL_S_KEEP
		| BGFX_STENCIL_OP_FAIL_Z_DECR
		| BGFX_STENCIL_OP_PASS_Z_KEEP
	},
	{ // ShadowVolume_UsingStencilBuffer_DrawDiffuse
		BGFX_STATE_RGB_WRITE
		| BGFX_STATE_ALPHA_WRITE
		| BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE)
		| BGFX_STATE_DEPTH_TEST_EQUAL
		| BGFX_STATE_CULL_CCW
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_TEST_EQUAL
		| BGFX_STENCIL_FUNC_REF(0)
		| BGFX_STENCIL_FUNC_RMASK(0xff)
		| BGFX_STENCIL_OP_FAIL_S_KEEP
		| BGFX_STENCIL_OP_FAIL_Z_KEEP
		| BGFX_STENCIL_OP_PASS_Z_KEEP
		, BGFX_STENCIL_NONE
	},
	{ // Custom_Default
		BGFX_STATE_RGB_WRITE
		| BGFX_STATE_ALPHA_WRITE
		| BGFX_STATE_DEPTH_WRITE
		| BGFX_STATE_DEPTH_TEST_LESS
		| BGFX_STATE_CULL_CCW
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_NONE
		, BGFX_STENCIL_NONE
	},
	{ // Custom_BlendLightTexture
		BGFX_STATE_RGB_WRITE
		| BGFX_STATE_ALPHA_WRITE
		| BGFX_STATE_DEPTH_WRITE
		| BGFX_STATE_DEPTH_TEST_LESS
		| BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_SRC_COLOR, BGFX_STATE_BLEND_INV_SRC_COLOR)
		| BGFX_STATE_CULL_CCW
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_NONE
		, BGFX_STENCIL_NONE
	},
	{ // Custom_DrawPlaneBottom
		BGFX_STATE_RGB_WRITE
		| BGFX_STATE_ALPHA_WRITE
		| BGFX_STATE_DEPTH_WRITE
		| BGFX_STATE_CULL_CW
		| BGFX_STATE_MSAA
		, UINT32_MAX
		, BGFX_STENCIL_NONE
		, BGFX_STENCIL_NONE
	},
	{ // Custom_DrawShadowVolume_Lines
		BGFX_STATE_RGB_WRITE
		| BGFX_STATE_DEPTH_TEST_LESS
		| BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_FACTOR, BGFX_STATE_BLEND_SRC_ALPHA)
		| BGFX_STATE_PT_LINES
		| BGFX_STATE_MSAA
		, 0x0f0f0fff
		, BGFX_STENCIL_NONE
		, BGFX_STENCIL_NONE
	}
};

struct ViewState
{
	ViewState(uint32_t _width = 1280, uint32_t _height = 720)
		: m_width(_width)
		, m_height(_height)
	{
	}

	uint32_t m_width;
	uint32_t m_height;

	float m_view[16];
	float m_proj[16];
};

struct ClearValues
{
	uint32_t m_clearRgba;
	float    m_clearDepth;
	uint8_t  m_clearStencil;
};

void submit(uint8_t _id, int32_t _depth = 0)
{
	bgfx::submit(_id, _depth);

	// Keep track of submited view ids.
	s_viewMask |= 1 << _id;
}

void submitMask(uint32_t _viewMask, int32_t _depth = 0)
{
	bgfx::submitMask(_viewMask, _depth);

	// Keep track of submited view ids.
	s_viewMask |= _viewMask;
}

struct Aabb
{
	float m_min[3];
	float m_max[3];
};

struct Obb
{
	float m_mtx[16];
};

struct Sphere
{
	float m_center[3];
	float m_radius;
};

struct Primitive
{
	uint32_t m_startIndex;
	uint32_t m_numIndices;
	uint32_t m_startVertex;
	uint32_t m_numVertices;

	Sphere m_sphere;
	Aabb m_aabb;
	Obb m_obb;
};

typedef std::vector<Primitive> PrimitiveArray;

struct Face
{
	uint16_t m_i[3];
	float m_plane[4];
};
typedef std::vector<Face> FaceArray;

struct Edge
{
	bool m_faceReverseOrder[2];
	uint8_t m_faceIndex;
	uint16_t m_i0, m_i1;
};

struct Plane
{
	float m_plane[4];
};

struct HalfEdge
{
#define INVALID_EDGE_INDEX UINT16_MAX
	uint16_t m_secondIndex;
	bool m_marked;
};

struct HalfEdges
{
	HalfEdges()
		: m_data()
		, m_offsets()
		, m_endPtr()
	{
	}

	void init(uint16_t* _indices, uint32_t _numIndices)
	{
		m_data = (HalfEdge*)malloc(2 * _numIndices * sizeof(HalfEdge) );

		std::unordered_map<uint16_t, std::vector<uint16_t> > edges;
		for (uint32_t ii = 0; ii < _numIndices; ii+=3)
		{
			uint16_t idx0 = _indices[ii];
			uint16_t idx1 = _indices[ii+1];
			uint16_t idx2 = _indices[ii+2];

			edges[idx0].push_back(idx1);
			edges[idx1].push_back(idx2);
			edges[idx2].push_back(idx0);
		}

		uint32_t numRows = (uint32_t)edges.size();
		m_offsets = (uint32_t*)malloc(numRows * sizeof(uint32_t) );

		HalfEdge* he = m_data;
		for (uint32_t ii = 0; ii < numRows; ++ii)
		{
			m_offsets[ii] = uint32_t(he - m_data);

			std::vector<uint16_t>& row = edges[ii];
			for (uint32_t jj = 0, end = (uint32_t)row.size(); jj < end; ++jj)
			{
				he->m_secondIndex = row[jj];
				he->m_marked = false;
				++he;
			}
			he->m_secondIndex = INVALID_EDGE_INDEX;
			++he;
		}
		he->m_secondIndex = 0;
		m_endPtr = he;
	}

	void destroy()
	{
		free(m_data);
		m_data = NULL;
		free(m_offsets);
		m_offsets = NULL;
	}

	void mark(uint16_t _firstIndex, uint16_t _secondIndex)
	{
		HalfEdge* ptr = &m_data[m_offsets[_firstIndex]];
		while (INVALID_EDGE_INDEX != ptr->m_secondIndex)
		{
			if (ptr->m_secondIndex == _secondIndex)
			{
				ptr->m_marked = true;
				break;
			}
			++ptr;
		}
	}

	bool unmark(uint16_t _firstIndex, uint16_t _secondIndex)
	{
		bool ret = false;
		HalfEdge* ptr = &m_data[m_offsets[_firstIndex]];
		while (INVALID_EDGE_INDEX != ptr->m_secondIndex)
		{
			if (ptr->m_secondIndex == _secondIndex && ptr->m_marked)
			{
				ptr->m_marked = false;
				ret = true;
				break;
			}
			++ptr;
		}
		return ret;
	}

	inline HalfEdge* begin() const
	{
		return m_data;
	}

	inline HalfEdge* end() const
	{
		return m_endPtr;
	}

	HalfEdge* m_data;
	uint32_t* m_offsets;
	HalfEdge* m_endPtr;
};

struct WeldedVertex
{
	uint16_t m_v;
	bool m_welded;
};

inline float sqLength(const float _a[3], const float _b[3])
{
	const float xx = _a[0] - _b[0];
	const float yy = _a[1] - _b[1];
	const float zz = _a[2] - _b[2];
	return xx*xx + yy*yy + zz*zz;
}

uint16_t weldVertices(WeldedVertex* _output, const bgfx::VertexDecl& _decl, const void* _data, uint16_t _num, float _epsilon)
{
	const uint32_t hashSize = bx::uint32_nextpow2(_num);
	const uint32_t hashMask = hashSize-1;
	const float epsilonSq = _epsilon*_epsilon;

	uint32_t numVertices = 0;

	const uint32_t size = sizeof(uint16_t)*(hashSize + _num);
	uint16_t* hashTable = (uint16_t*)alloca(size);
	memset(hashTable, 0xff, size);

	uint16_t* next = hashTable + hashSize;

	for (uint32_t ii = 0; ii < _num; ++ii)
	{
		float pos[4];
		vertexUnpack(pos, bgfx::Attrib::Position, _decl, _data, ii);
		uint32_t hashValue = bx::hashMurmur2A(pos, 3*sizeof(float) ) & hashMask;

		uint16_t offset = hashTable[hashValue];
		for (; UINT16_MAX != offset; offset = next[offset])
		{
			float test[4];
			vertexUnpack(test, bgfx::Attrib::Position, _decl, _data, _output[offset].m_v);

			if (sqLength(test, pos) < epsilonSq)
			{
				_output[ii].m_v = _output[offset].m_v;
				_output[ii].m_welded = true;
				break;
			}
		}

		if (UINT16_MAX == offset)
		{
			_output[ii].m_v = ii;
			_output[ii].m_welded = false;
			next[ii] = hashTable[hashValue];
			hashTable[hashValue] = ii;
			numVertices++;
		}
	}

	return numVertices;
}

struct Group
{
	Group()
	{
		reset();
	}

	void reset()
	{
		m_vbh.idx = bgfx::invalidHandle;
		m_ibh.idx = bgfx::invalidHandle;
		m_numVertices = 0;
		m_vertices = NULL;
		m_numIndices = 0;
		m_indices = NULL;
		m_numEdges = 0;
		m_edges = NULL;
		m_edgePlanesUnalignedPtr = NULL;
		m_prims.clear();
	}

	typedef struct { float f[6]; } f6_t;

	struct EdgeAndPlane
	{
		EdgeAndPlane(uint16_t _i0, uint16_t _i1)
			: m_faceIndex(0)
			, m_i0(_i0)
			, m_i1(_i1)
		{
		}

		bool m_faceReverseOrder[2];
		uint8_t m_faceIndex;
		uint16_t m_i0, m_i1;
		Plane m_plane[2];
	};

	void fillStructures(const bgfx::VertexDecl& _decl)
	{
		uint16_t stride = _decl.getStride();
		m_faces.clear();
		m_halfEdges.destroy();

		//Init halfedges.
		m_halfEdges.init(m_indices, m_numIndices);

		//Init faces and edges.
		m_faces.reserve(m_numIndices/3); //1 face = 3 indices
		m_edges = (Edge*)malloc(m_numIndices * sizeof(Edge)); //1 triangle = 3 indices = 3 edges.
		m_edgePlanesUnalignedPtr = (Plane*)malloc(m_numIndices * sizeof(Plane) + 15);
		m_edgePlanes = (Plane*)bx::alignPtr(m_edgePlanesUnalignedPtr, 0, 16);

		typedef std::map<std::pair<uint16_t, uint16_t>, EdgeAndPlane> EdgeMap;
		EdgeMap edgeMap;

		//Get unique indices.
		WeldedVertex* uniqueVertices = (WeldedVertex*)malloc(m_numVertices*sizeof(WeldedVertex) );
		::weldVertices(uniqueVertices, _decl, m_vertices, m_numVertices, 0.0001f);
		uint16_t* uniqueIndices = (uint16_t*)malloc(m_numIndices*sizeof(uint16_t) );
		for (uint32_t ii = 0; ii < m_numIndices; ++ii)
		{
			uint16_t index = m_indices[ii];
			if (uniqueVertices[index].m_welded)
			{
				uniqueIndices[ii] = uniqueVertices[index].m_v;
			}
			else
			{
				uniqueIndices[ii] = index;
			}
		}
		free(uniqueVertices);

		for (uint32_t ii = 0, size = m_numIndices/3; ii < size; ++ii)
		{
			const uint16_t* indices = &m_indices[ii*3];
			const uint16_t i0 = indices[0];
			const uint16_t i1 = indices[1];
			const uint16_t i2 = indices[2];
			const float* v0 = (float*)&m_vertices[i0*stride];
			const float* v1 = (float*)&m_vertices[i1*stride];
			const float* v2 = (float*)&m_vertices[i2*stride];

			float plane[4];
			planeNormal(plane, v0, v2, v1);

			Face face;
			face.m_i[0] = i0;
			face.m_i[1] = i1;
			face.m_i[2] = i2;
			memcpy(face.m_plane, plane, 4*sizeof(float) );
			m_faces.push_back(face);

			//Use unique indices for EdgeMap.
			const uint16_t* uindices = &uniqueIndices[ii*3];
			const uint16_t ui0 = uindices[0];
			const uint16_t ui1 = uindices[1];
			const uint16_t ui2 = uindices[2];

			const uint16_t triangleEdge[3][2] =
			{
				{ui0, ui1},
				{ui1, ui2},
				{ui2, ui0},
			};

			for (uint8_t jj = 0; jj < 3; ++jj)
			{
				const uint16_t ui0 = triangleEdge[jj][0];
				const uint16_t ui1 = triangleEdge[jj][1];

				std::pair<uint16_t, uint16_t> key    = std::make_pair(ui0, ui1);
				std::pair<uint16_t, uint16_t> keyInv = std::make_pair(ui1, ui0);

				EdgeMap::iterator iter = edgeMap.find(keyInv);
				if (iter != edgeMap.end())
				{
					EdgeAndPlane& ep = iter->second;
					memcpy(ep.m_plane[ep.m_faceIndex].m_plane, plane, 4*sizeof(float) );
					ep.m_faceReverseOrder[ep.m_faceIndex] = true;
				}
				else
				{
					std::pair<EdgeMap::iterator, bool> result = edgeMap.insert(std::make_pair(key, EdgeAndPlane(ui0, ui1) ) );
					EdgeAndPlane& ep = result.first->second;
					memcpy(ep.m_plane[ep.m_faceIndex].m_plane, plane, 4*sizeof(float) );
					ep.m_faceReverseOrder[ep.m_faceIndex] = false;
					ep.m_faceIndex++;
				}
			}
		}

		free(uniqueIndices);

		uint32_t index = 0;
		for (EdgeMap::const_iterator iter = edgeMap.begin(), end = edgeMap.end(); iter != end; ++iter)
		{
			Edge* edge = &m_edges[m_numEdges];
			Plane* plane = &m_edgePlanes[index];

			memcpy(edge, iter->second.m_faceReverseOrder, sizeof(Edge));
			memcpy(plane, iter->second.m_plane, 2 * sizeof(Plane));

			m_numEdges++;
			index += 2;
		}
	}

	void unload()
	{
		bgfx::destroyVertexBuffer(m_vbh);
		if (bgfx::invalidHandle != m_ibh.idx)
		{
			bgfx::destroyIndexBuffer(m_ibh);
		}
		free(m_vertices);
		m_vertices = NULL;
		free(m_indices);
		m_indices = NULL;
		free(m_edges);
		m_edges = NULL;
		free(m_edgePlanesUnalignedPtr);
		m_edgePlanesUnalignedPtr = NULL;
		m_halfEdges.destroy();
	}

	bgfx::VertexBufferHandle m_vbh;
	bgfx::IndexBufferHandle m_ibh;
	uint16_t m_numVertices;
	uint8_t* m_vertices;
	uint32_t m_numIndices;
	uint16_t* m_indices;
	Sphere m_sphere;
	Aabb m_aabb;
	Obb m_obb;
	PrimitiveArray m_prims;
	uint32_t m_numEdges;
	Edge* m_edges;
	Plane* m_edgePlanesUnalignedPtr;
	Plane* m_edgePlanes;
	FaceArray m_faces;
	HalfEdges m_halfEdges;
};

typedef std::vector<Group> GroupArray;

struct Mesh
{
	void load(const void* _vertices, uint32_t _numVertices, const bgfx::VertexDecl _decl, const uint16_t* _indices, uint32_t _numIndices)
	{
		Group group;
		const bgfx::Memory* mem;
		uint32_t size;

		//vertices
		group.m_numVertices = _numVertices;
		size = _numVertices*_decl.getStride();

		group.m_vertices = (uint8_t*)malloc(size);
		memcpy(group.m_vertices, _vertices, size);

		mem = bgfx::makeRef(group.m_vertices, size);
		group.m_vbh = bgfx::createVertexBuffer(mem, _decl);

		//indices
		group.m_numIndices = _numIndices;
		size = _numIndices*2;

		group.m_indices = (uint16_t*)malloc(size);
		memcpy(group.m_indices, _indices, size);

		mem = bgfx::makeRef(group.m_indices, size);
		group.m_ibh = bgfx::createIndexBuffer(mem);

		m_groups.push_back(group);
	}

	void load(const char* _filePath)
	{
#define BGFX_CHUNK_MAGIC_VB BX_MAKEFOURCC('V', 'B', ' ', 0x0)
#define BGFX_CHUNK_MAGIC_IB BX_MAKEFOURCC('I', 'B', ' ', 0x0)
#define BGFX_CHUNK_MAGIC_PRI BX_MAKEFOURCC('P', 'R', 'I', 0x0)

		bx::CrtFileReader reader;
		reader.open(_filePath);

		Group group;

		uint32_t chunk;
		while (4 == bx::read(&reader, chunk) )
		{
			switch (chunk)
			{
			case BGFX_CHUNK_MAGIC_VB:
				{
					bx::read(&reader, group.m_sphere);
					bx::read(&reader, group.m_aabb);
					bx::read(&reader, group.m_obb);

					bx::read(&reader, m_decl);
					uint16_t stride = m_decl.getStride();

					bx::read(&reader, group.m_numVertices);
					const uint32_t size = group.m_numVertices*stride;
					group.m_vertices = (uint8_t*)malloc(size);
					bx::read(&reader, group.m_vertices, size);

					const bgfx::Memory* mem = bgfx::makeRef(group.m_vertices, size);
					group.m_vbh = bgfx::createVertexBuffer(mem, m_decl);
				}
				break;

			case BGFX_CHUNK_MAGIC_IB:
				{
					bx::read(&reader, group.m_numIndices);
					const uint32_t size = group.m_numIndices*2;
					group.m_indices = (uint16_t*)malloc(size);
					bx::read(&reader, group.m_indices, size);

					const bgfx::Memory* mem = bgfx::makeRef(group.m_indices, size);
					group.m_ibh = bgfx::createIndexBuffer(mem);
				}
				break;

			case BGFX_CHUNK_MAGIC_PRI:
				{
					uint16_t len;
					bx::read(&reader, len);

					std::string material;
					material.resize(len);
					bx::read(&reader, const_cast<char*>(material.c_str() ), len);

					uint16_t num;
					bx::read(&reader, num);

					for (uint32_t ii = 0; ii < num; ++ii)
					{
						bx::read(&reader, len);

						std::string name;
						name.resize(len);
						bx::read(&reader, const_cast<char*>(name.c_str() ), len);

						Primitive prim;
						bx::read(&reader, prim.m_startIndex);
						bx::read(&reader, prim.m_numIndices);
						bx::read(&reader, prim.m_startVertex);
						bx::read(&reader, prim.m_numVertices);
						bx::read(&reader, prim.m_sphere);
						bx::read(&reader, prim.m_aabb);
						bx::read(&reader, prim.m_obb);

						group.m_prims.push_back(prim);
					}

					m_groups.push_back(group);
					group.reset();
				}
				break;

			default:
				DBG("%08x at %d", chunk, reader.seek() );
				break;
			}
		}

		reader.close();

		for (GroupArray::iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it)
		{
			it->fillStructures(m_decl);
		}
	}

	void unload()
	{
		for (GroupArray::iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it)
		{
			it->unload();
		}
		m_groups.clear();
	}

	bgfx::VertexDecl m_decl;
	GroupArray m_groups;
};

struct Model
{
	Model()
	{
		m_program.idx = bgfx::invalidHandle;
		m_texture.idx = bgfx::invalidHandle;
	}

	void load(const void* _vertices, uint32_t _numVertices, const bgfx::VertexDecl _decl, const uint16_t* _indices, uint32_t _numIndices)
	{
		m_mesh.load(_vertices, _numVertices, _decl, _indices, _numIndices);
	}

	void load(const char* _meshFilePath)
	{
		m_mesh.load(_meshFilePath);
	}

	void unload()
	{
		m_mesh.unload();
	}

	void submit(uint8_t _viewId, float* _mtx, const RenderState& _renderState)
	{
		for (GroupArray::const_iterator it = m_mesh.m_groups.begin(), itEnd = m_mesh.m_groups.end(); it != itEnd; ++it)
		{
			const Group& group = *it;

			// Set uniforms
			s_uniforms.submitPerDrawUniforms();

			// Set program
			BX_CHECK(bgfx::invalidHandle != m_program, "Error, program is not set.");
			bgfx::setProgram(m_program);

			// Set transform
			bgfx::setTransform(_mtx);

			// Set buffers
			bgfx::setIndexBuffer(group.m_ibh);
			bgfx::setVertexBuffer(group.m_vbh);

			// Set textures
			if (bgfx::invalidHandle != m_texture.idx)
			{
				bgfx::setTexture(0, u_texColor, m_texture);
			}
			bgfx::setTexture(7, u_texStencil, s_stencilFb);

			// Apply render state
			::setRenderState(_renderState);

			// Submit
			::submit(_viewId);
		}
	}

	Mesh m_mesh;
	bgfx::ProgramHandle m_program;
	bgfx::TextureHandle m_texture;
};

struct Instance
{
	Instance()
		: m_svExtrusionDistance(150.0f)
	{
		m_color[0] = 1.0f;
		m_color[1] = 1.0f;
		m_color[2] = 1.0f;
	}

	void submit(uint8_t _viewId, const RenderState& _renderState)
	{
		memcpy(s_uniforms.m_color, m_color, 3*sizeof(float) );

		float mtx[16];
		mtxSRT(mtx
			, m_scale[0]
			, m_scale[1]
			, m_scale[2]
			, m_rotation[0]
			, m_rotation[1]
			, m_rotation[2]
			, m_pos[0]
			, m_pos[1]
			, m_pos[2]
			);

		BX_CHECK(NULL != m_model, "Instance model cannot be NULL!");
		m_model->submit(_viewId, mtx, _renderState);
	}

	float m_scale[3];
	float m_rotation[3];
	float m_pos[3];

	float m_color[3];
	float m_svExtrusionDistance;

	Model* m_model;
};

#define SV_INSTANCE_MEM_SIZE (1500 << 10)
#define SV_INSTANCE_COUNT ( (25 > MAX_INSTANCE_COUNT) ? 25 : MAX_INSTANCE_COUNT)
#define SV_PAGE_SIZE (SV_INSTANCE_MEM_SIZE * SV_INSTANCE_COUNT * MAX_LIGHTS_COUNT)

struct ShadowVolumeAllocator
{
	ShadowVolumeAllocator()
	{
		m_mem = (uint8_t*)malloc(SV_PAGE_SIZE*2);
		m_ptr = m_mem;
		m_firstPage = true;
	}

	~ShadowVolumeAllocator()
	{
		free(m_mem);
	}

	void* alloc(uint32_t _size)
	{
		void* ret = (void*)m_ptr;
		m_ptr += _size;
		BX_CHECK(m_ptr - m_mem < (m_firstPage ? SV_PAGE_SIZE : 2 * SV_PAGE_SIZE), "Buffer overflow!");
		return ret;
	}

	void swap()
	{
		m_ptr = m_firstPage ? m_mem + SV_PAGE_SIZE : m_mem;
		m_firstPage = !m_firstPage;
	}

	uint8_t* m_mem;
	uint8_t* m_ptr;
	bool m_firstPage;
};
static ShadowVolumeAllocator s_svAllocator;

struct ShadowVolumeImpl
{
	enum Enum
	{
		DepthPass,
		DepthFail,
	};
};

struct ShadowVolumeAlgorithm
{
	enum Enum
	{
		FaceBased,
		EdgeBased,
	};
};

struct ShadowVolume
{
	bgfx::VertexBufferHandle m_vbSides;
	bgfx::IndexBufferHandle m_ibSides;
	bgfx::IndexBufferHandle m_ibFrontCap;
	bgfx::IndexBufferHandle m_ibBackCap;

	uint32_t m_numVertices;
	uint32_t m_numIndices;

	const float* m_mtx;
	const float* m_lightPos;

	bool m_cap;
};

void shadowVolumeLightTransform(float* __restrict _outLightPos
							  , const float* __restrict _scale
							  , const float* __restrict _rotate
							  , const float* __restrict _translate
							  , const float* __restrict _lightPos // world pos
							  )
{
	/**
	 * Instead of transforming all the vertices, transform light instead:
	 * mtx = pivotTranslate -> rotateZYX -> invScale
	 * light = mtx * origin
	 */

	float pivot[16];
	mtxTranslate(pivot
		, _lightPos[0] - _translate[0]
		, _lightPos[1] - _translate[1]
		, _lightPos[2] - _translate[2]
		);

	float mzyx[16];
	mtxRotateZYX(mzyx
		, -_rotate[0]
		, -_rotate[1]
		, -_rotate[2]
		);

	float invScale[16];
	mtxScale(invScale
		, 1.0f / _scale[0]
		, 1.0f / _scale[1]
		, 1.0f / _scale[2]
		);

	float tmp0[16];
	mtxMul(tmp0, pivot, mzyx);

	float mtx[16];
	mtxMul(mtx, tmp0, invScale);

	float origin[3] = { 0.0f, 0.0f, 0.0f };
	vec3MulMtx(_outLightPos, origin, mtx);
}

void shadowVolumeCreate(ShadowVolume& _shadowVolume
					  , Group& _group
					  , uint16_t _stride
					  , const float* _mtx
					  , const float* _light // in model space
					  , ShadowVolumeImpl::Enum _impl = ShadowVolumeImpl::DepthPass
					  , ShadowVolumeAlgorithm::Enum _algo = ShadowVolumeAlgorithm::FaceBased
					  , bool _textureAsStencil = false
					  )
{
	const uint8_t*    vertices   = _group.m_vertices;
	const FaceArray&  faces      = _group.m_faces;
	const Edge*       edges      = _group.m_edges;
	const Plane*      edgePlanes = _group.m_edgePlanes;
	const uint32_t    numEdges   = _group.m_numEdges;
	HalfEdges&        halfEdges  = _group.m_halfEdges;

	struct VertexData
	{
		VertexData()
		{
		}

		VertexData(const float* _v3, float _extrude = 0.0f, float _k = 1.0f)
		{
			memcpy(m_v, _v3, 3*sizeof(float) );
			m_extrude = _extrude;
			m_k = _k;
		}

		float m_v[3];
		float m_extrude;
		float m_k;
	};

	bool cap = (ShadowVolumeImpl::DepthFail == _impl);

	VertexData* verticesSide    = (VertexData*) s_svAllocator.alloc(20000 * sizeof(VertexData) );
	uint16_t*   indicesSide     = (uint16_t*)   s_svAllocator.alloc(20000 * 3*sizeof(uint16_t) );
	uint16_t*   indicesFrontCap = 0;
	uint16_t*   indicesBackCap  = 0;

	if (cap)
	{
		indicesFrontCap = (uint16_t*)s_svAllocator.alloc(80000 * 3*sizeof(uint16_t) );
		indicesBackCap  = (uint16_t*)s_svAllocator.alloc(80000 * 3*sizeof(uint16_t) );
	}

	uint32_t vsideI    = 0;
	uint32_t sideI     = 0;
	uint32_t frontCapI = 0;
	uint32_t backCapI  = 0;

	uint16_t indexSide = 0;

	if (ShadowVolumeAlgorithm::FaceBased == _algo)
	{
		for (FaceArray::const_iterator iter = faces.begin(), end = faces.end(); iter != end; ++iter)
		{
			const Face& face = *iter;

			bool frontFacing = false;
			float f = vec3Dot(face.m_plane, _light) + face.m_plane[3];
			if (f > 0.0f)
			{
				frontFacing = true;
				uint16_t triangleEdges[3][2] =
				{
					{ face.m_i[0], face.m_i[1] },
					{ face.m_i[1], face.m_i[2] },
					{ face.m_i[2], face.m_i[0] },
				};

				for (uint8_t ii = 0; ii < 3; ++ii)
				{
					uint16_t first  = triangleEdges[ii][0];
					uint16_t second = triangleEdges[ii][1];

					if (!halfEdges.unmark(second, first) )
					{
						halfEdges.mark(first, second);
					}
				}
			}

			if (cap)
			{
				if (frontFacing)
				{
					indicesFrontCap[frontCapI++] = face.m_i[0];
					indicesFrontCap[frontCapI++] = face.m_i[1];
					indicesFrontCap[frontCapI++] = face.m_i[2];
				}
				else
				{
					indicesBackCap[backCapI++] = face.m_i[0];
					indicesBackCap[backCapI++] = face.m_i[1];
					indicesBackCap[backCapI++] = face.m_i[2];
				}

				/**
				 * if '_useFrontFacingFacesAsBackCap' is needed, implement it as such:
				 *
				 * bool condition0 = frontFacing && _useFrontFacingFacesAsBackCap;
				 * bool condition1 = !frontFacing && !_useFrontFacingFacesAsBackCap;
				 * if (condition0 || condition1)
				 * {
				 *      indicesBackCap[backCapI++] = face.m_i[0];
				 *      indicesBackCap[backCapI++] = face.m_i[1+condition0];
				 *      indicesBackCap[backCapI++] = face.m_i[2-condition0];
				 * }
				 */
			}
		}

		// Fill side arrays.
		uint16_t firstIndex = 0;
		HalfEdge* he = halfEdges.begin();
		while (halfEdges.end() != he)
		{
			if (he->m_marked)
			{
				he->m_marked = false;

				const float* v0 = (float*)&vertices[firstIndex*_stride];
				const float* v1 = (float*)&vertices[he->m_secondIndex*_stride];

				verticesSide[vsideI++] = VertexData(v0, 0.0f);
				verticesSide[vsideI++] = VertexData(v0, 1.0f);
				verticesSide[vsideI++] = VertexData(v1, 0.0f);
				verticesSide[vsideI++] = VertexData(v1, 1.0f);

				indicesSide[sideI++] = indexSide+0;
				indicesSide[sideI++] = indexSide+1;
				indicesSide[sideI++] = indexSide+2;

				indicesSide[sideI++] = indexSide+2;
				indicesSide[sideI++] = indexSide+1;
				indicesSide[sideI++] = indexSide+3;

				indexSide += 4;
			}

			++he;
			if (INVALID_EDGE_INDEX == he->m_secondIndex)
			{
				++he;
				++firstIndex;
			}
		}
	}
	else // ShadowVolumeAlgorithm::EdgeBased:
	{
		uint32_t ii = 0;

#if SV_USE_SIMD
		uint32_t numEdgesRounded = numEdges & (~0x1);

		using namespace bx;

		const float4_t lx = float4_splat(_light[0]);
		const float4_t ly = float4_splat(_light[1]);
		const float4_t lz = float4_splat(_light[2]);

		for (; ii < numEdgesRounded; ii+=2)
		{
			const Edge& edge0 = edges[ii];
			const Edge& edge1 = edges[ii+1];
			const Plane* edgePlane0 = &edgePlanes[ii*2];
			const Plane* edgePlane1 = &edgePlanes[ii*2 + 2];

			const float4_t reverse = float4_ild(edge0.m_faceReverseOrder[0]
						 , edge1.m_faceReverseOrder[0]
						 , edge0.m_faceReverseOrder[1]
						 , edge1.m_faceReverseOrder[1]
						 );

			const float4_t v0 = float4_ld(edgePlane0[0].m_plane);
			const float4_t v1 = float4_ld(edgePlane1[0].m_plane);
			const float4_t v2 = float4_ld(edgePlane0[1].m_plane);
			const float4_t v3 = float4_ld(edgePlane1[1].m_plane);

			const float4_t xxyy0 = float4_shuf_xAyB(v0, v2);
			const float4_t zzww0 = float4_shuf_zCwD(v0, v2);
			const float4_t xxyy1 = float4_shuf_xAyB(v1, v3);
			const float4_t zzww1 = float4_shuf_zCwD(v1, v3);

			const float4_t vX = float4_shuf_xAyB(xxyy0, xxyy1);
			const float4_t vY = float4_shuf_zCwD(xxyy0, xxyy1);
			const float4_t vZ = float4_shuf_xAyB(zzww0, zzww1);
			const float4_t vW = float4_shuf_zCwD(zzww0, zzww1);

			const float4_t r0 = float4_mul(vX, lx);
			const float4_t r1 = float4_mul(vY, ly);
			const float4_t r2 = float4_mul(vZ, lz);

			const float4_t dot = float4_add(r0, float4_add(r1, r2));
			const float4_t f = float4_add(dot, vW);

			const float4_t zero = float4_zero();
			const float4_t mask = float4_cmpgt(f, zero);
			const float4_t onef = float4_splat(1.0f);
			const float4_t tmp0 = float4_and(mask, onef);
			const float4_t tmp1 = float4_ftoi(tmp0);
			const float4_t tmp2 = float4_xor(tmp1, reverse);
			const float4_t tmp3 = float4_sll(tmp2, 1);
			const float4_t onei = float4_isplat(1);
			const float4_t tmp4 = float4_isub(tmp3, onei);

			BX_ALIGN_STRUCT_16(int32_t res[4]);
			float4_st(&res, tmp4);

			for (uint16_t jj = 0; jj < 2; ++jj)
			{
				int16_t k = res[jj] + res[jj+2];
				if (k != 0)
				{
					float* v0 = (float*)&vertices[edges[ii+jj].m_i0*_stride];
					float* v1 = (float*)&vertices[edges[ii+jj].m_i1*_stride];
					verticesSide[vsideI++] = VertexData(v0, 0.0f, float(k));
					verticesSide[vsideI++] = VertexData(v0, 1.0f, float(k));
					verticesSide[vsideI++] = VertexData(v1, 0.0f, float(k));
					verticesSide[vsideI++] = VertexData(v1, 1.0f, float(k));

					k = _textureAsStencil ? 1 : k;
					uint16_t winding = uint16_t(k > 0);
					for (uint8_t ii = 0, end = abs(k); ii < end; ++ii)
					{
						indicesSide[sideI++] = indexSide;
						indicesSide[sideI++] = indexSide + 2 - winding;
						indicesSide[sideI++] = indexSide + 1 + winding;

						indicesSide[sideI++] = indexSide + 2;
						indicesSide[sideI++] = indexSide + 3 - winding*2;
						indicesSide[sideI++] = indexSide + 1 + winding*2;
					}

					indexSide += 4;
				}
			}
		}
#endif

		for (; ii < numEdges; ++ii)
		{
			const Edge& edge = edges[ii];
			const Plane* edgePlane = &edgePlanes[ii*2];

			int16_t s0 = ( (vec3Dot(edgePlane[0].m_plane, _light) + edgePlane[0].m_plane[3]) > 0.0f) ^ edge.m_faceReverseOrder[0];
			int16_t s1 = ( (vec3Dot(edgePlane[1].m_plane, _light) + edgePlane[1].m_plane[3]) > 0.0f) ^ edge.m_faceReverseOrder[1];
			int16_t k = ( (s0 + s1) << 1) - 2;

			if (k != 0)
			{
				float* v0 = (float*)&vertices[edge.m_i0*_stride];
				float* v1 = (float*)&vertices[edge.m_i1*_stride];
				verticesSide[vsideI++] = VertexData(v0, 0.0f, k);
				verticesSide[vsideI++] = VertexData(v0, 1.0f, k);
				verticesSide[vsideI++] = VertexData(v1, 0.0f, k);
				verticesSide[vsideI++] = VertexData(v1, 1.0f, k);

				k = _textureAsStencil ? 1 : k;
				uint16_t winding = uint16_t(k > 0);
				for (uint8_t ii = 0, end = abs(k); ii < end; ++ii)
				{
					indicesSide[sideI++] = indexSide;
					indicesSide[sideI++] = indexSide + 2 - winding;
					indicesSide[sideI++] = indexSide + 1 + winding;

					indicesSide[sideI++] = indexSide + 2;
					indicesSide[sideI++] = indexSide + 3 - winding*2;
					indicesSide[sideI++] = indexSide + 1 + winding*2;
				}

				indexSide += 4;
			}
		}

		if (cap)
		{
			// This could/should be done on GPU!
			for (FaceArray::const_iterator iter = faces.begin(), end = faces.end(); iter != end; ++iter)
			{
				const Face& face = *iter;

				float f = vec3Dot(face.m_plane, _light) + face.m_plane[3];
				bool frontFacing = (f > 0.0f);

				for (uint8_t ii = 0, end = 1 + uint8_t(!_textureAsStencil); ii < end; ++ii)
				{
					if (frontFacing)
					{
						indicesFrontCap[frontCapI++] = face.m_i[0];
						indicesFrontCap[frontCapI++] = face.m_i[1];
						indicesFrontCap[frontCapI++] = face.m_i[2];
					}
					else
					{
						indicesBackCap[backCapI++] = face.m_i[0];
						indicesBackCap[backCapI++] = face.m_i[1];
						indicesBackCap[backCapI++] = face.m_i[2];
					}
				}
			}
		}
	}

	bgfx::VertexDecl decl;
	decl.begin()
		.add(bgfx::Attrib::Position,  3, bgfx::AttribType::Float)
		.add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float)
		.end();

	//fill the structure
	_shadowVolume.m_numVertices = vsideI;
	_shadowVolume.m_numIndices  = sideI + frontCapI + backCapI;
	_shadowVolume.m_mtx         = _mtx;
	_shadowVolume.m_lightPos    = _light;
	_shadowVolume.m_cap         = cap;

	const bgfx::Memory* mem;

	//sides
	uint32_t vsize = vsideI * 5*sizeof(float);
	uint32_t isize = sideI * sizeof(uint16_t);

	mem = bgfx::makeRef(verticesSide, vsize);
	_shadowVolume.m_vbSides = bgfx::createVertexBuffer(mem, decl);

	mem = bgfx::makeRef(indicesSide, isize);
	_shadowVolume.m_ibSides = bgfx::createIndexBuffer(mem);

	// bgfx::destroy*Buffer doesn't actually destroy buffers now.
	// Instead, these bgfx::destroy*Buffer commands get queued to be executed after the end of the next frame.
	bgfx::destroyVertexBuffer(_shadowVolume.m_vbSides);
	bgfx::destroyIndexBuffer(_shadowVolume.m_ibSides);

	if (cap)
	{
		//front cap
		isize = frontCapI * sizeof(uint16_t);
		mem = bgfx::makeRef(indicesFrontCap, isize);
		_shadowVolume.m_ibFrontCap = bgfx::createIndexBuffer(mem);

		//gets destroyed after the end of the next frame
		bgfx::destroyIndexBuffer(_shadowVolume.m_ibFrontCap);

		//back cap
		isize = backCapI * sizeof(uint16_t);
		mem = bgfx::makeRef(indicesBackCap, isize);
		_shadowVolume.m_ibBackCap = bgfx::createIndexBuffer(mem);

		//gets destroyed after the end of the next frame
		bgfx::destroyIndexBuffer(_shadowVolume.m_ibBackCap);
	}
}

void createNearClipVolume(float* __restrict _outPlanes24f
						, float* __restrict _lightPos
						, float* __restrict _view
						, float _fovy
						, float _aspect
						, float _near
						)
{
	float (*volumePlanes)[4] = (float(*)[4])_outPlanes24f;

	float mtxViewInv[16];
	float mtxViewTrans[16];
	mtxInverse(mtxViewInv, _view);
	mtxTranspose(mtxViewTrans, _view);

	float lightPosV[4];
	vec4MulMtx(lightPosV, _lightPos, _view);

	const float delta = 0.1f;

	float nearNormal[4] = { 0.0f, 0.0f, 1.0f, _near };
	float d = vec3Dot(lightPosV, nearNormal) + lightPosV[3] * nearNormal[3];

	// Light is:
	//  1.0f - in front of near plane
	//  0.0f - on the near plane
	// -1.0f - behind near plane
	float lightSide = float( (d > delta) - (d < -delta) );

	float t = tanf(_fovy*( (float)M_PI/180.0f)*0.5f) * _near;
	float b = -t;
	float r = t * _aspect;
	float l = -r;

	float cornersV[4][3] =
	{
		{ r, t, _near },
		{ l, t, _near },
		{ l, b, _near },
		{ r, b, _near },
	};

	float corners[4][3];
	vec3MulMtx(corners[0], cornersV[0], mtxViewInv);
	vec3MulMtx(corners[1], cornersV[1], mtxViewInv);
	vec3MulMtx(corners[2], cornersV[2], mtxViewInv);
	vec3MulMtx(corners[3], cornersV[3], mtxViewInv);

	float planeNormals[4][3];
	for (uint8_t ii = 0; ii < 4; ++ii)
	{
		float* normal = planeNormals[ii];
		float* plane = volumePlanes[ii];

		float planeVec[3];
		vec3Sub(planeVec, corners[ii], corners[(ii-1)%4]);

		float light[3];
		float tmp[3];
		vec3Mul(tmp, corners[ii], _lightPos[3]);
		vec3Sub(light, _lightPos, tmp);

		vec3Cross(normal, planeVec, light);

		normal[0] *= lightSide;
		normal[1] *= lightSide;
		normal[2] *= lightSide;

		float lenInv = 1.0f / sqrtf(vec3Dot(normal, normal) );

		plane[0] = normal[0] * lenInv;
		plane[1] = normal[1] * lenInv;
		plane[2] = normal[2] * lenInv;
		plane[3] = -vec3Dot(normal, corners[ii]) * lenInv;
	}

	float nearPlaneV[4] =
	{
		0.0f * lightSide,
		0.0f * lightSide,
		1.0f * lightSide,
		_near * lightSide,
	};
	vec4MulMtx(volumePlanes[4], nearPlaneV, mtxViewTrans);

	float* lightPlane = volumePlanes[5];
	float lightPlaneNormal[3] = { 0.0f, 0.0f, -_near * lightSide };
	float tmp[3];
	vec3MulMtx(tmp, lightPlaneNormal, mtxViewInv);
	vec3Sub(lightPlaneNormal, tmp, _lightPos);

	float lenInv = 1.0f / sqrtf(vec3Dot(lightPlaneNormal, lightPlaneNormal) );

	lightPlane[0] = lightPlaneNormal[0] * lenInv;
	lightPlane[1] = lightPlaneNormal[1] * lenInv;
	lightPlane[2] = lightPlaneNormal[2] * lenInv;
	lightPlane[3] = -vec3Dot(lightPlaneNormal, _lightPos) * lenInv;
}

bool clipTest(const float* _planes, uint8_t _planeNum, const Mesh& _mesh, const float* _scale, const float* _translate)
{
	float (*volumePlanes)[4] = (float(*)[4])_planes;
	float scale = fmaxf(fmaxf(_scale[0], _scale[1]), _scale[2]);

	const GroupArray& groups = _mesh.m_groups;
	for (GroupArray::const_iterator it = groups.begin(), itEnd = groups.end(); it != itEnd; ++it)
	{
		const Group& group = *it;

		Sphere sphere = group.m_sphere;
		sphere.m_center[0] = sphere.m_center[0] * scale + _translate[0];
		sphere.m_center[1] = sphere.m_center[1] * scale + _translate[1];
		sphere.m_center[2] = sphere.m_center[2] * scale + _translate[2];
		sphere.m_radius *= (scale+0.4f);

		bool isInside = true;
		for (uint8_t ii = 0; ii < _planeNum; ++ii)
		{
			const float* plane = volumePlanes[ii];

			float positiveSide = vec3Dot(plane, sphere.m_center) + plane[3] + sphere.m_radius;

			if (positiveSide < 0.0f)
			{
				isInside = false;
				break;
			}
		}

		if (isInside)
		{
			return true;
		}
	}

	return false;
}

int _main_(int /*_argc*/, char** /*_argv*/)
{
	ViewState viewState(1280, 720);
	ClearValues clearValues = {0x00000000, 1.0f, 0};

	uint32_t debug = BGFX_DEBUG_TEXT;
	uint32_t reset = BGFX_RESET_VSYNC;

	bgfx::init();
	bgfx::reset(viewState.m_width, viewState.m_height, reset);

	// Enable debug text.
	bgfx::setDebug(debug);

	// Setup root path for binary shaders. Shader binaries are different
	// for each renderer.
	switch (bgfx::getRendererType() )
	{
	default:
	case bgfx::RendererType::Direct3D9:
		s_shaderPath = "shaders/dx9/";
		s_texelHalf = 0.5f;
		break;

	case bgfx::RendererType::Direct3D11:
		s_shaderPath = "shaders/dx11/";
		break;

	case bgfx::RendererType::OpenGL:
		s_shaderPath = "shaders/glsl/";
		s_flipV = true;
		break;

	case bgfx::RendererType::OpenGLES:
		s_shaderPath = "shaders/gles/";
		s_flipV = true;
		break;
	}

	// Imgui
	FILE* file = fopen("font/droidsans.ttf", "rb");
	uint32_t size = (uint32_t)fsize(file);
	void* data = malloc(size);
	size_t ignore = fread(data, 1, size, file);
	BX_UNUSED(ignore);
	fclose(file);

	imguiCreate(data);

	free(data);

	bgfx::VertexDecl PosNormalTexcoordDecl;
	PosNormalTexcoordDecl.begin()
		.add(bgfx::Attrib::Position,  3, bgfx::AttribType::Float)
		.add(bgfx::Attrib::Normal,    4, bgfx::AttribType::Uint8, true, true)
		.add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float)
		.end();

	s_uniforms.init();
	s_uniforms.submitConstUniforms();

	const bgfx::Memory* mem;

	mem = loadTexture("figure-rgba.dds");
	bgfx::TextureHandle figureTex = bgfx::createTexture(mem);

	mem = loadTexture("flare.dds");
	bgfx::TextureHandle flareTex = bgfx::createTexture(mem);

	mem = loadTexture("fieldstone-rgba.dds");
	bgfx::TextureHandle fieldstoneTex = bgfx::createTexture(mem);

	bgfx::TextureHandle fbtextures[] =
	{
		bgfx::createTexture2D(viewState.m_width, viewState.m_height, 1, bgfx::TextureFormat::BGRA8, BGFX_TEXTURE_U_CLAMP|BGFX_TEXTURE_V_CLAMP|BGFX_TEXTURE_RT),
		bgfx::createTexture2D(viewState.m_width, viewState.m_height, 1, bgfx::TextureFormat::D16, BGFX_TEXTURE_RT_BUFFER_ONLY),
	};
	s_stencilFb  = bgfx::createFrameBuffer(BX_COUNTOF(fbtextures), fbtextures, true);

	u_texColor   = bgfx::createUniform("u_texColor",   bgfx::UniformType::Uniform1iv);
	u_texStencil = bgfx::createUniform("u_texStencil", bgfx::UniformType::Uniform1iv);

	bgfx::ProgramHandle programTextureLightning = loadProgram("vs_shadowvolume_texture_lightning", "fs_shadowvolume_texture_lightning");
	bgfx::ProgramHandle programColorLightning   = loadProgram("vs_shadowvolume_color_lightning",   "fs_shadowvolume_color_lightning"  );
	bgfx::ProgramHandle programColorTexture     = loadProgram("vs_shadowvolume_color_texture",     "fs_shadowvolume_color_texture"    );
	bgfx::ProgramHandle programTexture          = loadProgram("vs_shadowvolume_texture",           "fs_shadowvolume_texture"          );

	bgfx::ProgramHandle programBackBlank        = loadProgram("vs_shadowvolume_svback",  "fs_shadowvolume_svbackblank" );
	bgfx::ProgramHandle programSideBlank        = loadProgram("vs_shadowvolume_svside",  "fs_shadowvolume_svsideblank" );
	bgfx::ProgramHandle programFrontBlank       = loadProgram("vs_shadowvolume_svfront", "fs_shadowvolume_svfrontblank");

	bgfx::ProgramHandle programBackColor        = loadProgram("vs_shadowvolume_svback",  "fs_shadowvolume_svbackcolor" );
	bgfx::ProgramHandle programSideColor        = loadProgram("vs_shadowvolume_svside",  "fs_shadowvolume_svsidecolor" );
	bgfx::ProgramHandle programFrontColor       = loadProgram("vs_shadowvolume_svfront", "fs_shadowvolume_svfrontcolor");

	bgfx::ProgramHandle programSideTex          = loadProgram("vs_shadowvolume_svside",  "fs_shadowvolume_svsidetex"   );
	bgfx::ProgramHandle programBackTex1         = loadProgram("vs_shadowvolume_svback",  "fs_shadowvolume_svbacktex1"  );
	bgfx::ProgramHandle programBackTex2         = loadProgram("vs_shadowvolume_svback",  "fs_shadowvolume_svbacktex2"  );
	bgfx::ProgramHandle programFrontTex1        = loadProgram("vs_shadowvolume_svfront", "fs_shadowvolume_svfronttex1" );
	bgfx::ProgramHandle programFrontTex2        = loadProgram("vs_shadowvolume_svfront", "fs_shadowvolume_svfronttex2" );

	struct ShadowVolumeProgramType
	{
		enum Enum
		{
			Blank = 0,
			Color,
			Tex1,
			Tex2,

			Count
		};
	};

	struct ShadowVolumePart
	{
		enum Enum
		{
			Back = 0,
			Side,
			Front,

			Count
		};
	};

	bgfx::ProgramHandle svProgs[ShadowVolumeProgramType::Count][ShadowVolumePart::Count] =
	{
		{ programBackBlank, programSideBlank, programFrontBlank }, // Blank
		{ programBackColor, programSideColor, programFrontColor }, // Color
		{ programBackTex1,  programSideTex,   programFrontTex1  }, // Tex1
		{ programBackTex2,  programSideTex,   programFrontTex2  }, // Tex2
	};

	Model bunnyLowPolyModel;
	Model bunnyHighPolyModel;
	Model columnModel;
	Model platformModel;
	Model cubeModel;
	Model hplaneFieldModel;
	Model hplaneFigureModel;
	Model vplaneModel;

	bunnyHighPolyModel.load("meshes/bunny_patched.bin");
	bunnyHighPolyModel.m_program = programColorLightning;

	bunnyLowPolyModel.load("meshes/bunny_decimated.bin");
	bunnyLowPolyModel.m_program = programColorLightning;

	columnModel.load("meshes/column.bin");
	columnModel.m_program = programColorLightning;

	platformModel.load("meshes/platform.bin");
	platformModel.m_program = programTextureLightning;
	platformModel.m_texture = figureTex;

	cubeModel.load("meshes/cube.bin");
	cubeModel.m_program = programTextureLightning;
	cubeModel.m_texture = figureTex;

	hplaneFieldModel.load(s_hplaneVertices, s_numHPlaneVertices, PosNormalTexcoordDecl, s_planeIndices, s_numPlaneIndices);
	hplaneFieldModel.m_program = programTextureLightning;
	hplaneFieldModel.m_texture = fieldstoneTex;

	hplaneFigureModel.load(s_hplaneVertices, s_numHPlaneVertices, PosNormalTexcoordDecl, s_planeIndices, s_numPlaneIndices);
	hplaneFigureModel.m_program = programTextureLightning;
	hplaneFigureModel.m_texture = figureTex;

	vplaneModel.load(s_vplaneVertices, s_numVPlaneVertices, PosNormalTexcoordDecl, s_planeIndices, s_numPlaneIndices);
	vplaneModel.m_program = programColorTexture;
	vplaneModel.m_texture = flareTex;

	// Setup lights.
	const float rgbInnerR[MAX_LIGHTS_COUNT][4] =
	{
		{ 1.0f, 0.7f, 0.2f, 0.0f }, //yellow
		{ 0.7f, 0.2f, 1.0f, 0.0f }, //purple
		{ 0.2f, 1.0f, 0.7f, 0.0f }, //cyan
		{ 1.0f, 0.4f, 0.2f, 0.0f }, //orange
		{ 0.7f, 0.7f, 0.7f, 0.0f }, //white
	};

	float lightRgbInnerR[MAX_LIGHTS_COUNT][4];
	for (uint8_t ii = 0, jj = 0; ii < MAX_LIGHTS_COUNT; ++ii, ++jj)
	{
		const uint8_t index = jj%MAX_LIGHTS_COUNT;
		lightRgbInnerR[ii][0] = rgbInnerR[index][0];
		lightRgbInnerR[ii][1] = rgbInnerR[index][1];
		lightRgbInnerR[ii][2] = rgbInnerR[index][2];
		lightRgbInnerR[ii][3] = rgbInnerR[index][3];
	}

	int64_t profTime = 0;
	int64_t timeOffset = bx::getHPCounter();

	uint32_t numShadowVolumeVertices = 0;
	uint32_t numShadowVolumeIndices  = 0;

	uint32_t oldWidth = 0;
	uint32_t oldHeight = 0;

	// Imgui.
	bool settings_showHelp           = false;
	bool settings_updateLights       = true;
	bool settings_updateScene        = true;
	bool settings_mixedSvImpl        = true;
	bool settings_useStencilTexture  = false;
	bool settings_drawShadowVolumes  = false;
	float settings_numLights         = 1.0f;
	float settings_instanceCount     = 9.0f;
	ShadowVolumeImpl::Enum      settings_shadowVolumeImpl      = ShadowVolumeImpl::DepthFail;
	ShadowVolumeAlgorithm::Enum settings_shadowVolumeAlgorithm = ShadowVolumeAlgorithm::EdgeBased;
	int32_t scrollAreaRight = 0;

	const char* titles[2] =
	{
		"Scene 0",
		"Scene 1",
	};

	enum LightPattern
	{
		LightPattern0 = 0,
		LightPattern1
	};

	enum MeshChoice
	{
		BunnyHighPoly = 0,
		BunnyLowPoly
	};

	enum Scene
	{
		Scene0 = 0,
		Scene1,

		SceneCount
	};

	LightPattern lightPattern = LightPattern0;
	MeshChoice currentMesh = BunnyLowPoly;
	Scene currentScene = Scene0;

	// Set view and projection matrices.
	const float fov = 60.0f;
	const float aspect = float(viewState.m_width)/float(viewState.m_height);
	const float nearPlane = 1.0f;
	const float farPlane = 1000.0f;
	mtxProj(viewState.m_proj, fov, aspect, nearPlane, farPlane);

	float initialPos[3] = { 3.0f, 20.0f, -58.0f };
	cameraCreate();
	cameraSetPosition(initialPos);
	cameraSetVerticalAngle(-0.25f);
	cameraGetViewMtx(viewState.m_view);

	entry::MouseState mouseState;
	while (!entry::processEvents(viewState.m_width, viewState.m_height, debug, reset, &mouseState) )
	{
		// Respond properly on resize.
		if (oldWidth != viewState.m_width
		||  oldHeight != viewState.m_height)
		{
			oldWidth = viewState.m_width;
			oldHeight = viewState.m_height;

			bgfx::destroyFrameBuffer(s_stencilFb);

			fbtextures[0] = bgfx::createTexture2D(viewState.m_width, viewState.m_height, 1, bgfx::TextureFormat::BGRA8, BGFX_TEXTURE_U_CLAMP|BGFX_TEXTURE_V_CLAMP|BGFX_TEXTURE_RT);
			fbtextures[1] = bgfx::createTexture2D(viewState.m_width, viewState.m_height, 1, bgfx::TextureFormat::D16, BGFX_TEXTURE_RT_BUFFER_ONLY);
			s_stencilFb = bgfx::createFrameBuffer(BX_COUNTOF(fbtextures), fbtextures, true);
		}

		// Time.
		int64_t now = bx::getHPCounter();
		static int64_t last = now;
		const int64_t frameTime = now - last;
		last = now;
		const double freq = double(bx::getHPFrequency() );
		const double toMs = 1000.0/freq;
		float time = (float)( (now - timeOffset)/double(bx::getHPFrequency() ) );
		const float deltaTime = float(frameTime/freq);
		s_uniforms.m_time = time;

		// Update camera.
		cameraUpdate(deltaTime, mouseState.m_mx, mouseState.m_my, !!mouseState.m_buttons[entry::MouseButton::Right]);
		cameraGetViewMtx(viewState.m_view);

		imguiBeginFrame(mouseState.m_mx
			, mouseState.m_my
			, (mouseState.m_buttons[entry::MouseButton::Left  ] ? IMGUI_MBUT_LEFT  : 0)
			| (mouseState.m_buttons[entry::MouseButton::Right ] ? IMGUI_MBUT_RIGHT : 0)
			, 0
			, viewState.m_width
			, viewState.m_height
			);

		imguiBeginScrollArea("Settings", viewState.m_width - 256 - 10, 10, 256, 700, &scrollAreaRight);

		if (imguiCheck(titles[Scene0], Scene0 == currentScene) )
		{
			currentScene = Scene0;
		}

		if (imguiCheck(titles[Scene1], Scene1 == currentScene) )
		{
			currentScene = Scene1;
		}

		imguiSlider("Lights", &settings_numLights, 1.0f, float(MAX_LIGHTS_COUNT), 1.0f);

		if (imguiCheck("Update lights", settings_updateLights) )
		{
			settings_updateLights = !settings_updateLights;
		}

		imguiIndent();

		if (imguiCheck("Light pattern 0", LightPattern0 == lightPattern, settings_updateLights) )
		{
			lightPattern = LightPattern0;
		}

		if (imguiCheck("Light pattern 1", LightPattern1 == lightPattern, settings_updateLights) )
		{
			lightPattern = LightPattern1;
		}

		imguiUnindent();

		if (imguiCheck("Update scene", settings_updateScene, Scene0 == currentScene) )
		{
			settings_updateScene  = !settings_updateScene;
		}

		imguiSeparatorLine();
		imguiLabel("Stencil buffer implementation:");
		settings_shadowVolumeImpl = (imguiCheck("Depth fail", ShadowVolumeImpl::DepthFail == settings_shadowVolumeImpl, !settings_mixedSvImpl) ? ShadowVolumeImpl::DepthFail : settings_shadowVolumeImpl);
		settings_shadowVolumeImpl = (imguiCheck("Depth pass", ShadowVolumeImpl::DepthPass == settings_shadowVolumeImpl, !settings_mixedSvImpl) ? ShadowVolumeImpl::DepthPass : settings_shadowVolumeImpl);
		settings_mixedSvImpl = (imguiCheck("Mixed", settings_mixedSvImpl) ? !settings_mixedSvImpl : settings_mixedSvImpl);

		imguiLabel("Shadow volume implementation:");
		settings_shadowVolumeAlgorithm = (imguiCheck("Face based impl.", ShadowVolumeAlgorithm::FaceBased == settings_shadowVolumeAlgorithm) ? ShadowVolumeAlgorithm::FaceBased : settings_shadowVolumeAlgorithm);
		settings_shadowVolumeAlgorithm = (imguiCheck("Edge based impl.", ShadowVolumeAlgorithm::EdgeBased == settings_shadowVolumeAlgorithm) ? ShadowVolumeAlgorithm::EdgeBased : settings_shadowVolumeAlgorithm);

		imguiLabel("Stencil:");
		if (imguiCheck("Use stencil buffer", !settings_useStencilTexture) )
		{
			if (settings_useStencilTexture)
			{
				settings_useStencilTexture = false;
			}
		}
		if (imguiCheck("Use texture as stencil", settings_useStencilTexture) )
		{
			if (!settings_useStencilTexture)
			{
				settings_useStencilTexture = true;
			}
		}

		imguiSeparatorLine();
		imguiLabel("Mesh:");
		if (imguiCheck("Bunny - high poly", BunnyHighPoly == currentMesh) )
		{
			currentMesh = BunnyHighPoly;
		}

		if (imguiCheck("Bunny - low poly",  BunnyLowPoly  == currentMesh) )
		{
			currentMesh = BunnyLowPoly;
		}

		if (Scene1 == currentScene)
		{
			imguiSlider("Instance count", &settings_instanceCount, 1.0f, float(MAX_INSTANCE_COUNT), 1.0f);
		}

		imguiLabel("CPU Time: %7.1f [ms]", double(profTime)*toMs);
		imguiLabel("Volume Vertices: %5.uk", numShadowVolumeVertices/1000);
		imguiLabel("Volume Indices: %6.uk", numShadowVolumeIndices/1000);
		numShadowVolumeVertices = 0;
		numShadowVolumeIndices = 0;

		imguiSeparatorLine();
		settings_drawShadowVolumes = imguiCheck("Draw Shadow Volumes", settings_drawShadowVolumes)
			? !settings_drawShadowVolumes
			: settings_drawShadowVolumes
			;
		imguiIndent();
		imguiUnindent();

		imguiEndScrollArea();

		static int32_t scrollAreaLeft = 0;
		imguiBeginScrollArea("Show help:", 10, viewState.m_height - 77 - 10, 120, 77, &scrollAreaLeft);
		settings_showHelp = imguiButton(settings_showHelp ? "ON" : "OFF")
			? !settings_showHelp
			: settings_showHelp
			;

		imguiEndScrollArea();

		imguiEndFrame();

		//update settings
		s_uniforms.m_params.m_ambientPass     = 1.0f;
		s_uniforms.m_params.m_lightningPass   = 1.0f;
		s_uniforms.m_params.m_texelHalf       = s_texelHalf;
		s_uniforms.m_svparams.m_useStencilTex = float(settings_useStencilTexture);
		s_uniforms.submitPerFrameUniforms();

		//set picked bunny model
		Model* bunnyModel = BunnyLowPoly == currentMesh ? &bunnyLowPolyModel : &bunnyHighPolyModel;

		//update time accumulators
		static float sceneTimeAccumulator = 0.0f;
		if (settings_updateScene)
		{
			sceneTimeAccumulator += deltaTime;
		}

		static float lightTimeAccumulator = 0.0f;
		if (settings_updateLights)
		{
			lightTimeAccumulator += deltaTime;
		}

		//setup light positions
		float lightPosRadius[MAX_LIGHTS_COUNT][4];
		if (LightPattern0 == lightPattern)
		{
			for (uint8_t ii = 0; ii < settings_numLights; ++ii)
			{
				lightPosRadius[ii][0] = cos(2.0f*float(M_PI)/settings_numLights * float(ii) + lightTimeAccumulator * 1.1f + 3.0f) * 20.0f;
				lightPosRadius[ii][1] = 20.0f;
				lightPosRadius[ii][2] = sin(2.0f*float(M_PI)/settings_numLights * float(ii) + lightTimeAccumulator * 1.1f + 3.0f) * 20.0f;
				lightPosRadius[ii][3] = 20.0f;
			}
		}
		else
		{
			for (uint8_t ii = 0; ii < settings_numLights; ++ii)
			{
				lightPosRadius[ii][0] = cos(float(ii) * 2.0f/settings_numLights + lightTimeAccumulator * 1.3f + float(M_PI) ) * 40.0f;
				lightPosRadius[ii][1] = 20.0f;
				lightPosRadius[ii][2] = sin(float(ii) * 2.0f/settings_numLights + lightTimeAccumulator * 1.3f + float(M_PI) ) * 40.0f;
				lightPosRadius[ii][3] = 20.0f;
			}
		}

		//use debug font to print information about this example.
		bgfx::dbgTextClear();
		bgfx::dbgTextPrintf(0, 1, 0x4f, "bgfx/examples/14-shadowvolumes");
		bgfx::dbgTextPrintf(0, 2, 0x6f, "Description: Shadow volumes.");
		bgfx::dbgTextPrintf(0, 3, 0x0f, "Frame: % 7.3f[ms]", double(frameTime)*toMs);

		if (settings_showHelp)
		{
			uint8_t row = 5;
			bgfx::dbgTextPrintf(3, row++, 0x0f, "Stencil buffer implementation:");
			bgfx::dbgTextPrintf(8, row++, 0x0f, "Depth fail - Robust, but slower than 'Depth pass'. Requires computing and drawing of shadow volume caps.");
			bgfx::dbgTextPrintf(8, row++, 0x0f, "Depth pass - Faster, but not stable. Shadows are wrong when camera is in the shadow.");
			bgfx::dbgTextPrintf(8, row++, 0x0f, "Mixed      - 'Depth pass' where possible, 'Depth fail' where necessary. Best of both words.");

			row++;
			bgfx::dbgTextPrintf(3, row++, 0x0f, "Shadow volume implementation:");
			bgfx::dbgTextPrintf(8, row++, 0x0f, "Face Based - Slower. Works fine with either stencil buffer or texture as stencil.");
			bgfx::dbgTextPrintf(8, row++, 0x0f, "Edge Based - Faster, but requires +2 incr/decr on stencil buffer. To avoid massive redraw, use RGBA texture as stencil.");

			row++;
			bgfx::dbgTextPrintf(3, row++, 0x0f, "Stencil:");
			bgfx::dbgTextPrintf(8, row++, 0x0f, "Stencil buffer     - Faster, but capable only of +1 incr.");
			bgfx::dbgTextPrintf(8, row++, 0x0f, "Texture as stencil - Slower, but capable of +2 incr.");
		}

		// Setup instances
		Instance shadowCasters[SceneCount][60];
		uint16_t shadowCastersCount[SceneCount];
		for (uint8_t ii = 0; ii < SceneCount; ++ii)
		{
			shadowCastersCount[ii] = 0;
		}

		Instance shadowReceivers[SceneCount][10];
		uint16_t shadowReceiversCount[SceneCount];
		for (uint8_t ii = 0; ii < SceneCount; ++ii)
		{
			shadowReceiversCount[ii] = 0;
		}

		// Scene 0 - shadow casters - Bunny
		{
			Instance& inst = shadowCasters[Scene0][shadowCastersCount[Scene0]++];
			inst.m_scale[0]    = 5.0f;
			inst.m_scale[1]    = 5.0f;
			inst.m_scale[2]    = 5.0f;
			inst.m_rotation[0] = 0.0f;
			inst.m_rotation[1] = float(4.0f - sceneTimeAccumulator * 0.7f);
			inst.m_rotation[2] = 0.0f;
			inst.m_pos[0]      = 0.0f;
			inst.m_pos[1]      = 10.0f;
			inst.m_pos[2]      = 0.0f;
			inst.m_color[0]    = 0.68f;
			inst.m_color[1]    = 0.65f;
			inst.m_color[2]    = 0.60f;
			inst.m_model       = bunnyModel;
		}

		// Scene 0 - shadow casters - Cubes top.
		const uint8_t numCubesTop = 9;
		for (uint16_t ii = 0; ii < numCubesTop; ++ii)
		{
			Instance& inst = shadowCasters[Scene0][shadowCastersCount[Scene0]++];
			inst.m_scale[0]    = 1.0f;
			inst.m_scale[1]    = 1.0f;
			inst.m_scale[2]    = 1.0f;
			inst.m_rotation[0] = 0.0f;
			inst.m_rotation[1] = 0.0f;
			inst.m_rotation[2] = 0.0f;
			inst.m_pos[0]      = sin(ii * 2.0f + 13.0f + sceneTimeAccumulator * 1.1f) * 13.0f;
			inst.m_pos[1]      = 6.0f;
			inst.m_pos[2]      = cos(ii * 2.0f + 13.0f + sceneTimeAccumulator * 1.1f) * 13.0f;
			inst.m_model       = &cubeModel;
		}

		// Scene 0 - shadow casters - Cubes bottom.
		const uint8_t numCubesBottom = 9;
		for (uint16_t ii = 0; ii < numCubesBottom; ++ii)
		{
			Instance& inst = shadowCasters[Scene0][shadowCastersCount[Scene0]++];
			inst.m_scale[0]    = 1.0f;
			inst.m_scale[1]    = 1.0f;
			inst.m_scale[2]    = 1.0f;
			inst.m_rotation[0] = 0.0f;
			inst.m_rotation[1] = 0.0f;
			inst.m_rotation[2] = 0.0f;
			inst.m_pos[0]      = sin(ii * 2.0f + 13.0f + sceneTimeAccumulator * 1.1f) * 13.0f;
			inst.m_pos[1]      = 22.0f;
			inst.m_pos[2]      = cos(ii * 2.0f + 13.0f + sceneTimeAccumulator * 1.1f) * 13.0f;
			inst.m_model       = &cubeModel;
		}

		// Scene 0 - shadow casters - Columns.
		const float dist = 16.0f;
		const float columnPositions[4][3] =
		{
			{  dist, 3.3f,  dist },
			{ -dist, 3.3f,  dist },
			{  dist, 3.3f, -dist },
			{ -dist, 3.3f, -dist },
		};

		for (uint8_t ii = 0; ii < 4; ++ii)
		{
			Instance& inst = shadowCasters[Scene0][shadowCastersCount[Scene0]++];
			inst.m_scale[0]    = 1.5f;
			inst.m_scale[1]    = 1.5f;
			inst.m_scale[2]    = 1.5f;
			inst.m_rotation[0] = 0.0f;
			inst.m_rotation[1] = 1.57f;
			inst.m_rotation[2] = 0.0f;
			inst.m_pos[0]      = columnPositions[ii][0];
			inst.m_pos[1]      = columnPositions[ii][1];
			inst.m_pos[2]      = columnPositions[ii][2];
			inst.m_color[0]    = 0.25f;
			inst.m_color[1]    = 0.25f;
			inst.m_color[2]    = 0.25f;
			inst.m_model       = &columnModel;
		}

		// Scene 0 - shadow casters - Ceiling.
		{
			Instance& inst = shadowCasters[Scene0][shadowCastersCount[Scene0]++];
			inst.m_scale[0]    = 21.0f;
			inst.m_scale[1]    = 21.0f;
			inst.m_scale[2]    = 21.0f;
			inst.m_rotation[0] = float(M_PI);
			inst.m_rotation[1] = 0.0f;
			inst.m_rotation[2] = 0.0f;
			inst.m_pos[0]      = 0.0f;
			inst.m_pos[1]      = 28.2f;
			inst.m_pos[2]      = 0.0f;
			inst.m_model       = &platformModel;
			inst.m_svExtrusionDistance = 2.0f; //prevent culling on tight view frustum
		}

		// Scene 0 - shadow casters - Platform.
		{
			Instance& inst = shadowCasters[Scene0][shadowCastersCount[Scene0]++];
			inst.m_scale[0]    = 24.0f;
			inst.m_scale[1]    = 24.0f;
			inst.m_scale[2]    = 24.0f;
			inst.m_rotation[0] = 0.0f;
			inst.m_rotation[1] = 0.0f;
			inst.m_rotation[2] = 0.0f;
			inst.m_pos[0]      = 0.0f;
			inst.m_pos[1]      = 0.0f;
			inst.m_pos[2]      = 0.0f;
			inst.m_model       = &platformModel;
			inst.m_svExtrusionDistance = 2.0f; //prevent culling on tight view frustum
		}

		// Scene 0 - shadow receivers - Floor.
		{
			Instance& inst = shadowReceivers[Scene0][shadowReceiversCount[Scene0]++];
			inst.m_scale[0]    = 500.0f;
			inst.m_scale[1]    = 500.0f;
			inst.m_scale[2]    = 500.0f;
			inst.m_rotation[0] = 0.0f;
			inst.m_rotation[1] = 0.0f;
			inst.m_rotation[2] = 0.0f;
			inst.m_pos[0]      = 0.0f;
			inst.m_pos[1]      = 0.0f;
			inst.m_pos[2]      = 0.0f;
			inst.m_model       = &hplaneFieldModel;
		}

		// Scene 1 - shadow casters - Bunny instances
		{
			enum Direction
			{
				Left  = 0x0,
				Down  = 0x1,
				Right = 0x2,
				Up    = 0x3,
			};
			const uint8_t directionMask = 0x3;

			uint8_t currentDirection = Left;
			float currX = 0.0f;
			float currY = 0.0f;
			const float stepX = 20.0f;
			const float stepY = 20.0f;
			uint8_t stateStep = 0;
			uint8_t stateChange = 1;

			for (uint8_t ii = 0; ii < settings_instanceCount; ++ii)
			{
				Instance& inst = shadowCasters[Scene1][shadowCastersCount[Scene1]++];
				inst.m_scale[0]    = 5.0f;
				inst.m_scale[1]    = 5.0f;
				inst.m_scale[2]    = 5.0f;
				inst.m_rotation[0] = 0.0f;
				inst.m_rotation[1] = float(M_PI);
				inst.m_rotation[2] = 0.0f;
				inst.m_pos[0]      = currX;
				inst.m_pos[1]      = 0.0f;
				inst.m_pos[2]      = currY;
				inst.m_model       = bunnyModel;

				++stateStep;
				if (stateStep >= ( (stateChange & ~0x1) >> 1) )
				{
					currentDirection = (currentDirection + 1) & directionMask;
					stateStep = 0;
					++stateChange;
				}

				switch (currentDirection)
				{
				case Left:  currX -= stepX; break;
				case Down:  currY -= stepY; break;
				case Right: currX += stepX; break;
				case Up:    currY += stepY; break;
				}
			}
		}

		// Scene 1 - shadow receivers - Floor.
		{
			Instance& inst = shadowReceivers[Scene1][shadowReceiversCount[Scene1]++];
			inst.m_scale[0]    = 500.0f;
			inst.m_scale[1]    = 500.0f;
			inst.m_scale[2]    = 500.0f;
			inst.m_rotation[0] = 0.0f;
			inst.m_rotation[1] = 0.0f;
			inst.m_rotation[2] = 0.0f;
			inst.m_pos[0]      = 0.0f;
			inst.m_pos[1]      = 0.0f;
			inst.m_pos[2]      = 0.0f;
			inst.m_model       = &hplaneFigureModel;
		}

		// Make sure at the beginning everything gets cleared.
		bgfx::setViewClear(0
				, BGFX_CLEAR_COLOR_BIT
				| BGFX_CLEAR_DEPTH_BIT
				| BGFX_CLEAR_STENCIL_BIT
				, clearValues.m_clearRgba
				, clearValues.m_clearDepth
				, clearValues.m_clearStencil
				);

		::submit(0);

		// Draw ambient only.
		s_uniforms.m_params.m_ambientPass = 1.0f;
		s_uniforms.m_params.m_lightningPass = 0.0f;

		s_uniforms.m_color[0] = 1.0f;
		s_uniforms.m_color[1] = 1.0f;
		s_uniforms.m_color[2] = 1.0f;

		const RenderState& drawAmbient = (settings_useStencilTexture ?
			s_renderStates[RenderState::ShadowVolume_UsingStencilTexture_DrawAmbient]:
		s_renderStates[RenderState::ShadowVolume_UsingStencilBuffer_DrawAmbient]);

		// Draw shadow casters.
		for (uint8_t ii = 0; ii < shadowCastersCount[currentScene]; ++ii)
		{
			shadowCasters[currentScene][ii].submit(VIEWID_RANGE1_PASS0, drawAmbient);
		}

		// Draw shadow receivers.
		for (uint8_t ii = 0; ii < shadowReceiversCount[currentScene]; ++ii)
		{
			shadowReceivers[currentScene][ii].submit(VIEWID_RANGE1_PASS0, drawAmbient);
		}

		// Using stencil texture requires rendering to separate render target. first pass is building depth buffer.
		if (settings_useStencilTexture)
		{
			bgfx::setViewClear(VIEWID_RANGE1_RT_PASS1, BGFX_CLEAR_DEPTH_BIT, 0x00000000, 1.0f, 0);
			bgfx::setViewFrameBuffer(VIEWID_RANGE1_RT_PASS1, s_stencilFb);

			const RenderState& renderState = s_renderStates[RenderState::ShadowVolume_UsingStencilTexture_BuildDepth];

			for (uint8_t ii = 0; ii < shadowCastersCount[currentScene]; ++ii)
			{
				shadowCasters[currentScene][ii].submit(VIEWID_RANGE1_RT_PASS1, renderState);
			}

			for (uint8_t ii = 0; ii < shadowReceiversCount[currentScene]; ++ii)
			{
				shadowReceivers[currentScene][ii].submit(VIEWID_RANGE1_RT_PASS1, renderState);
			}
		}

		profTime = bx::getHPCounter();

		/**
		 * For each light:
		 * 1. Compute and draw shadow volume to stencil buffer
		 * 2. Draw diffuse with stencil test
		 */
		for (uint8_t ii = 0, viewId = VIEWID_RANGE15_PASS2; ii < settings_numLights; ++ii, ++viewId)
		{
			const float* lightPos = lightPosRadius[ii];

			memcpy(s_uniforms.m_lightPosRadius, lightPosRadius[ii], 4*sizeof(float) );
			memcpy(s_uniforms.m_lightRgbInnerR, lightRgbInnerR[ii], 3*sizeof(float) );
			memcpy(s_uniforms.m_color,          lightRgbInnerR[ii], 3*sizeof(float) );

			if (settings_useStencilTexture)
			{
				bgfx::setViewFrameBuffer(viewId, s_stencilFb);

				bgfx::setViewClear(viewId
						, BGFX_CLEAR_COLOR_BIT
						, 0x00000000
						, 1.0f
						, 0
						);
			}
			else
			{
				const bgfx::FrameBufferHandle invalid = BGFX_INVALID_HANDLE;
				bgfx::setViewFrameBuffer(viewId, invalid);

				bgfx::setViewClear(viewId
						, BGFX_CLEAR_STENCIL_BIT
						, clearValues.m_clearRgba
						, clearValues.m_clearDepth
						, clearValues.m_clearStencil
						);
			}

			// Create near clip volume for current light.
			float nearClipVolume[6 * 4] = {};
			float pointLight[4];
			if (settings_mixedSvImpl)
			{
				pointLight[0] = lightPos[0];
				pointLight[1] = lightPos[1];
				pointLight[2] = lightPos[2];
				pointLight[3] = 1.0f;
				createNearClipVolume(nearClipVolume, pointLight, viewState.m_view, fov, aspect, nearPlane);
			}

			for (uint8_t jj = 0; jj < shadowCastersCount[currentScene]; ++jj)
			{
				const Instance& instance = shadowCasters[currentScene][jj];
				Model* model = instance.m_model;

				ShadowVolumeImpl::Enum shadowVolumeImpl = settings_shadowVolumeImpl;
				if (settings_mixedSvImpl)
				{
					// If instance is inside near clip volume, depth fail must be used, else depth pass is fine.
					bool isInsideVolume = clipTest(nearClipVolume, 6, model->m_mesh, instance.m_scale, instance.m_pos);
					shadowVolumeImpl = (isInsideVolume ? ShadowVolumeImpl::DepthFail : ShadowVolumeImpl::DepthPass);
				}
				s_uniforms.m_svparams.m_dfail = float(ShadowVolumeImpl::DepthFail == shadowVolumeImpl);

				// Compute virtual light position for shadow volume generation.
				float transformedLightPos[3];
				shadowVolumeLightTransform(transformedLightPos
					, instance.m_scale
					, instance.m_rotation
					, instance.m_pos
					, lightPos
					);

				// Set virtual light pos.
				memcpy(s_uniforms.m_virtualLightPos_extrusionDist, transformedLightPos, 3*sizeof(float) );
				s_uniforms.m_virtualLightPos_extrusionDist[3] = instance.m_svExtrusionDistance;

				// Compute transform for shadow volume.
				float shadowVolumeMtx[16];
				mtxSRT(shadowVolumeMtx
						, instance.m_scale[0]
						, instance.m_scale[1]
						, instance.m_scale[2]
						, instance.m_rotation[0]
						, instance.m_rotation[1]
						, instance.m_rotation[2]
						, instance.m_pos[0]
						, instance.m_pos[1]
						, instance.m_pos[2]
						);

				GroupArray& groups = model->m_mesh.m_groups;
				const uint16_t stride = model->m_mesh.m_decl.getStride();
				for (GroupArray::iterator it = groups.begin(), itEnd = groups.end(); it != itEnd; ++it)
				{
					Group& group = *it;

					// Create shadow volume.
					ShadowVolume shadowVolume;
					shadowVolumeCreate(shadowVolume
						, group
						, stride
						, shadowVolumeMtx
						, transformedLightPos
						, shadowVolumeImpl
						, settings_shadowVolumeAlgorithm
						, settings_useStencilTexture
						);

					numShadowVolumeVertices += shadowVolume.m_numVertices;
					numShadowVolumeIndices += shadowVolume.m_numIndices;

					ShadowVolumeProgramType::Enum programIndex = ShadowVolumeProgramType::Blank;
					RenderState::Enum renderStateIndex;
					if (settings_useStencilTexture)
					{
						renderStateIndex = ShadowVolumeImpl::DepthFail == shadowVolumeImpl
							? RenderState::ShadowVolume_UsingStencilTexture_CraftStencil_DepthFail
							: RenderState::ShadowVolume_UsingStencilTexture_CraftStencil_DepthPass
							;

						programIndex = ShadowVolumeAlgorithm::FaceBased == settings_shadowVolumeAlgorithm
							? ShadowVolumeProgramType::Tex1
							: ShadowVolumeProgramType::Tex2
							;
					}
					else
					{
						renderStateIndex = ShadowVolumeImpl::DepthFail == shadowVolumeImpl
							? RenderState::ShadowVolume_UsingStencilBuffer_CraftStencil_DepthFail
							: RenderState::ShadowVolume_UsingStencilBuffer_CraftStencil_DepthPass
							;
					}
					const RenderState& renderStateCraftStencil = s_renderStates[renderStateIndex];

					s_uniforms.submitPerDrawUniforms();
					bgfx::setProgram(svProgs[programIndex][ShadowVolumePart::Side]);
					bgfx::setTransform(shadowVolumeMtx);
					bgfx::setVertexBuffer(shadowVolume.m_vbSides);
					bgfx::setIndexBuffer(shadowVolume.m_ibSides);
					::setRenderState(renderStateCraftStencil);
					::submit(viewId);

					if (shadowVolume.m_cap)
					{
						s_uniforms.submitPerDrawUniforms();
						bgfx::setProgram(svProgs[programIndex][ShadowVolumePart::Front]);
						bgfx::setTransform(shadowVolumeMtx);
						bgfx::setVertexBuffer(group.m_vbh);
						bgfx::setIndexBuffer(shadowVolume.m_ibFrontCap);
						::setRenderState(renderStateCraftStencil);
						::submit(viewId);

						s_uniforms.submitPerDrawUniforms();
						bgfx::setProgram(svProgs[programIndex][ShadowVolumePart::Back]);
						bgfx::setTransform(shadowVolumeMtx);
						bgfx::setVertexBuffer(group.m_vbh);
						bgfx::setIndexBuffer(shadowVolume.m_ibBackCap);
						::setRenderState(renderStateCraftStencil);
						::submit(viewId);
					}

					if (settings_drawShadowVolumes)
					{
						const RenderState& renderState = s_renderStates[RenderState::Custom_DrawShadowVolume_Lines];

						s_uniforms.submitPerDrawUniforms();
						bgfx::setProgram(svProgs[ShadowVolumeProgramType::Color][ShadowVolumePart::Side]);
						bgfx::setTransform(shadowVolumeMtx);
						bgfx::setVertexBuffer(shadowVolume.m_vbSides);
						bgfx::setIndexBuffer(shadowVolume.m_ibSides);
						::setRenderState(renderState);
						::submit(VIEWID_RANGE1_PASS3);

						if (shadowVolume.m_cap)
						{
							s_uniforms.submitPerDrawUniforms();
							bgfx::setProgram(svProgs[ShadowVolumeProgramType::Color][ShadowVolumePart::Front]);
							bgfx::setTransform(shadowVolumeMtx);
							bgfx::setVertexBuffer(group.m_vbh);
							bgfx::setIndexBuffer(shadowVolume.m_ibFrontCap);
							::setRenderState(renderState);
							::submit(VIEWID_RANGE1_PASS3);

							s_uniforms.submitPerDrawUniforms();
							bgfx::setProgram(svProgs[ShadowVolumeProgramType::Color][ShadowVolumePart::Back]);
							bgfx::setTransform(shadowVolumeMtx);
							bgfx::setVertexBuffer(group.m_vbh);
							bgfx::setIndexBuffer(shadowVolume.m_ibBackCap);
							::setRenderState(renderState);
							::submit(VIEWID_RANGE1_PASS3);
						}
					}
				}
			}

			// Draw diffuse only.
			s_uniforms.m_params.m_ambientPass = 0.0f;
			s_uniforms.m_params.m_lightningPass = 1.0f;

			RenderState& drawDiffuse = settings_useStencilTexture
				? s_renderStates[RenderState::ShadowVolume_UsingStencilTexture_DrawDiffuse]
				: s_renderStates[RenderState::ShadowVolume_UsingStencilBuffer_DrawDiffuse]
				;

			// If using stencil texture, viewId is set to render target. Incr it to render to default back buffer.
			viewId += uint8_t(settings_useStencilTexture);

			// Draw shadow casters.
			for (uint8_t ii = 0; ii < shadowCastersCount[currentScene]; ++ii)
			{
				shadowCasters[currentScene][ii].submit(viewId, drawDiffuse);
			}

			// Draw shadow receivers.
			for (uint8_t ii = 0; ii < shadowReceiversCount[currentScene]; ++ii)
			{
				shadowReceivers[currentScene][ii].submit(viewId, drawDiffuse);
			}
		}

		profTime = bx::getHPCounter() - profTime;

		// Lights.
		const float lightScale[3] = { 1.5f, 1.5f, 1.5f };
		for (uint8_t ii = 0; ii < settings_numLights; ++ii)
		{
			memcpy(s_uniforms.m_color, lightRgbInnerR[ii], 3*sizeof(float) );

			float lightMtx[16];
			mtxBillboard(lightMtx, viewState.m_view, lightPosRadius[ii], lightScale);

			vplaneModel.submit(VIEWID_RANGE1_PASS3, lightMtx, s_renderStates[RenderState::Custom_BlendLightTexture]);
		}

		// Setup view rect and transform for all used views.
		bgfx::setViewRectMask(s_viewMask, 0, 0, viewState.m_width, viewState.m_height);
		bgfx::setViewTransformMask(s_viewMask, viewState.m_view, viewState.m_proj);
		s_viewMask = 0;

		// Advance to next frame. Rendering thread will be kicked to
		// process submitted rendering primitives.
		bgfx::frame();

		// Swap memory pages.
		s_svAllocator.swap();

		// Reset clear values.
		bgfx::setViewClearMask(UINT32_MAX
			, BGFX_CLEAR_NONE
			, clearValues.m_clearRgba
			, clearValues.m_clearDepth
			, clearValues.m_clearStencil
			);
	}

	// Cleanup
	bunnyLowPolyModel.unload();
	bunnyHighPolyModel.unload();
	columnModel.unload();
	cubeModel.unload();
	platformModel.unload();
	hplaneFieldModel.unload();
	hplaneFigureModel.unload();
	vplaneModel.unload();

	s_uniforms.destroy();

	bgfx::destroyUniform(u_texColor);
	bgfx::destroyUniform(u_texStencil);
	bgfx::destroyFrameBuffer(s_stencilFb);

	bgfx::destroyTexture(figureTex);
	bgfx::destroyTexture(fieldstoneTex);
	bgfx::destroyTexture(flareTex);

	bgfx::destroyProgram(programTextureLightning);
	bgfx::destroyProgram(programColorLightning);
	bgfx::destroyProgram(programColorTexture);
	bgfx::destroyProgram(programTexture);

	bgfx::destroyProgram(programBackBlank);
	bgfx::destroyProgram(programSideBlank);
	bgfx::destroyProgram(programFrontBlank);
	bgfx::destroyProgram(programBackColor);
	bgfx::destroyProgram(programSideColor);
	bgfx::destroyProgram(programFrontColor);
	bgfx::destroyProgram(programSideTex);
	bgfx::destroyProgram(programBackTex1);
	bgfx::destroyProgram(programBackTex2);
	bgfx::destroyProgram(programFrontTex1);
	bgfx::destroyProgram(programFrontTex2);

	cameraDestroy();
	imguiDestroy();

	// Shutdown bgfx.
	bgfx::shutdown();

	return 0;
}