bgfx/examples/29-debugdraw/debugdraw.cpp

/*
 * Copyright 2011-2019 Branimir Karadzic. All rights reserved.
 * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause
 */

#include "common.h"
#include "bgfx_utils.h"
#include <entry/cmd.h>
#include <entry/input.h>
#include <debugdraw/debugdraw.h>
#include "camera.h"
#include "imgui/imgui.h"

#include <bx/uint32_t.h>

namespace
{

static DdVertex s_bunnyVertices[] =
{
	{   25.0883f,  -44.2788f,   31.0055f },
	{  0.945623f,   53.5504f,  -24.6146f },
	{  -0.94455f,  -14.3443f,  -16.8223f },
	{  -20.1103f,  -48.6664f,   12.6763f },
	{  -1.60652f,  -26.3165f,  -24.5424f },
	{  -30.6284f,  -53.6299f,   14.7666f },
	{   1.69145f,  -43.8075f,  -15.2065f },
	{  -20.5139f,   21.0521f,  -5.40868f },
	{  -13.9518f,   53.6299f,  -39.1193f },
	{  -21.7912f,   48.7801f,  -42.0995f },
	{  -26.8408f,   23.6537f,  -17.7324f },
	{  -23.1196f,   33.9692f,   4.91483f },
	{  -12.3236f,  -41.6303f,   31.8324f },
	{   27.6427f,  -5.05034f,  -11.3201f },
	{   32.2565f,   1.30521f,   30.2671f },
	{   47.2723f,  -27.0974f,   11.1774f },
	{    33.598f,   10.5888f,   7.95916f },
	{  -13.2898f,   12.6234f,   5.55953f },
	{  -32.7364f,   19.0648f,  -10.5736f },
	{  -32.7536f,   31.4158f,  -1.40712f },
	{  -25.3672f,   30.2874f,  -12.4682f },
	{    32.921f,  -36.8408f,  -12.0254f },
	{  -37.7251f,  -33.8989f,  0.378443f },
	{  -35.6341f, -0.246891f,  -9.25165f },
	{  -16.7041f,  -50.0254f,  -15.6177f },
	{   24.6604f,  -53.5319f,  -11.1059f },
	{  -7.77574f,  -53.5719f,  -16.6655f },
	{   20.6241f,   13.3489f,  0.376349f },
	{  -44.2889f,   29.5222f,   18.7918f },
	{   18.5805f,   16.3651f,   12.6351f },
	{  -23.7853f,   31.7598f,  -6.54093f },
	{   24.7518f,  -53.5075f,   2.14984f },
	{  -45.7912f,  -17.6301f,   21.1198f },
	{   51.8403f,  -33.1847f,   24.3337f },
	{  -47.5343f,  -4.32792f,   4.06232f },
	{  -50.6832f,   -12.442f,   11.0994f },
	{  -49.5132f,   19.2782f,   3.17559f },
	{  -39.4881f,   29.0208f,  -6.70431f },
	{  -52.7286f,   1.23232f,   9.74872f },
	{    26.505f,  -16.1297f,  -17.0487f },
	{   -25.367f,   20.0473f,  -8.44282f },
	{  -24.5797f,  -10.3143f,  -18.3154f },
	{  -28.6707f,   6.12074f,   27.8025f },
	{  -16.9868f,   22.6819f,   1.37408f },
	{  -37.2678f,   23.9443f,   -9.4945f },
	{  -24.8562f,   21.3763f,   18.8847f },
	{  -47.1879f,    3.8542f,  -4.74621f },
	{   38.0706f,  -7.33673f,   -7.6099f },
	{  -34.8833f,  -3.57074f,   26.4838f },
	{   12.3797f,   5.46782f,   32.9762f },
	{  -31.5974f,   -22.956f,   30.5827f },
	{  -6.80953f,    48.055f,  -18.5116f },
	{    6.3474f,  -15.1622f,  -24.4726f },
	{  -25.5733f,   25.2452f,  -34.4736f },
	{  -23.8955f,   31.8323f,  -40.8696f },
	{  -11.8622f,   38.2304f,  -43.3125f },
	{  -20.4918f,   41.2409f,  -3.11271f },
	{   24.9806f,  -8.53455f,   37.2862f },
	{  -52.8935f,    5.3376f,    28.246f },
	{    34.106f,  -41.7941f,    30.962f },
	{  -1.26914f,   35.6664f,  -18.7177f },
	{  -0.13048f,   44.7288f,  -28.7163f },
	{   2.47929f,  0.678165f,  -14.6892f },
	{  -31.8649f,  -14.2299f,   32.2998f },
	{   -19.774f,   30.8258f,   5.77293f },
	{   49.8059f,   -37.125f,   4.97284f },
	{  -28.0581f,   -26.439f,  -14.8316f },
	{  -9.12066f,  -27.3987f,  -12.8592f },
	{  -13.8752f,  -29.9821f,   32.5962f },
	{   -6.6222f,  -10.9884f,   33.5007f },
	{  -21.2664f,  -53.6089f,  -3.49195f },
	{ -0.628672f,   52.8093f,  -9.88088f },
	{   8.02417f,   51.8956f,  -21.5834f },
	{  -44.6547f,   11.9973f,   34.7897f },
	{  -7.55466f,   37.9035f, -0.574101f },
	{   52.8252f,  -27.1986f,   11.6429f },
	{ -0.934591f,   9.81861f,  0.512566f },
	{  -3.01043f,   5.70605f,   22.0954f },
	{  -34.6337f,   44.5964f,  -31.1713f },
	{  -26.9017f,   35.1991f,  -32.4307f },
	{   15.9884f,  -8.92223f,  -14.7411f },
	{  -22.8337f,   -43.458f,   26.7274f },
	{  -31.9864f,  -47.0243f,   9.36972f },
	{  -36.9436f,   24.1866f,   29.2521f },
	{  -26.5411f,   29.6549f,   21.2867f },
	{   33.7644f,  -24.1886f,  -13.8513f },
	{  -2.44749f,  -17.0148f,   41.6617f },
	{   -38.364f,  -13.9823f,  -12.5705f },
	{  -10.2972f,  -51.6584f,    38.935f },
	{   1.28109f,  -43.4943f,   36.6288f },
	{  -19.7784f,  -44.0413f,  -4.23994f },
	{   37.0944f,  -53.5479f,   27.6467f },
	{   24.9642f,  -37.1722f,   35.7038f },
	{   37.5851f,   5.64874f,   21.6702f },
	{  -17.4738f,  -53.5734f,   30.0664f },
	{  -8.93088f,   45.3429f,  -34.4441f },
	{  -17.7111f,   -6.5723f,   29.5162f },
	{   44.0059f,  -17.4408f,  -5.08686f },
	{  -46.2534f,  -22.6115f,  0.702059f },
	{   43.9321f,  -33.8575f,   4.31819f },
	{   41.6762f,  -7.37115f,   27.6798f },
	{   8.20276f,  -42.0948f,  -18.0893f },
	{   26.2678f,  -44.6777f,  -10.6835f },
	{    17.709f,   13.1542f,   25.1769f },
	{  -35.9897f,   3.92007f,   35.8198f },
	{  -23.9323f,  -37.3142f,  -2.39396f },
	{   5.19169f,   46.8851f,  -28.7587f },
	{  -37.3072f,  -35.0484f,   16.9719f },
	{   45.0639f,  -28.5255f,   22.3465f },
	{  -34.4175f,   35.5861f,  -21.7562f },
	{   9.32684f,  -12.6655f,    42.189f },
	{   1.00938f,  -31.7694f,   43.1914f },
	{  -45.4666f,  -3.71104f,   19.2248f },
	{  -28.7999f,  -50.8481f,   31.5232f },
	{   35.2212f,  -45.9047f,  0.199736f },
	{      40.3f,  -53.5889f,   7.47622f },
	{   29.0515f,    5.1074f,   -10.002f },
	{   13.4336f,   4.84341f,  -9.72327f },
	{   11.0617f,   -26.245f,  -24.9471f },
	{  -35.6056f,  -51.2531f,  0.436527f },
	{  -10.6863f,   34.7374f,  -36.7452f },
	{  -51.7652f,   27.4957f,   7.79363f },
	{  -50.1898f,    18.379f,   26.3763f },
	{  -49.6836f,  -1.32722f,   26.2828f },
	{   19.0363f,  -16.9114f,   41.8511f },
	{   32.7141f,   -21.501f,   36.0025f },
	{   12.5418f,  -28.4244f,   43.3125f },
	{  -19.5634f,   42.6328f,  -27.0687f },
	{  -16.1942f,   6.55011f,   19.4066f },
	{   46.9886f,  -18.8482f,   22.1332f },
	{   45.9697f,  -3.76781f,   4.10111f },
	{  -28.2912f,   51.3277f,  -35.1815f },
	{  -40.2796f,  -27.7518f,   22.8684f },
	{  -22.7984f,  -38.9977f,    22.158f },
	{   54.0614f,  -35.6096f,    12.694f },
	{   44.2064f,  -53.6029f,   18.8679f },
	{    19.789f,   -29.517f,  -19.6094f },
	{  -34.3769f,   34.8566f,   9.92517f },
	{  -23.7518f,  -45.0319f,   8.71282f },
	{  -12.7978f,   3.55087f,  -13.7108f },
	{  -54.0614f,   8.83831f,   8.91353f },
	{   16.2986f,  -53.5717f,    34.065f },
	{  -36.6243f,  -53.5079f,   24.6495f },
	{   16.5794f,  -48.5747f,   35.5681f },
	{  -32.3263f,   41.4526f,  -18.7388f },
	{  -18.8488f,   9.62627f,  -8.81052f },
	{   5.35849f,   36.3616f,  -12.9346f },
	{   6.19167f,    34.497f,   -17.965f },
};

static const uint16_t s_bunnyTriList[] =
{
	 80,   2,  52,
	  0, 143,  92,
	 51,   1,  71,
	 96, 128,  77,
	 67,   2,  41,
	 85,  39,  52,
	 58, 123,  38,
	 99,  21, 114,
	 55,   9,  54,
	136, 102,  21,
	  3, 133,  81,
	101, 136,   4,
	  5,  82,   3,
	  6,  90,  24,
	  7,  40, 145,
	 33,  75, 134,
	 55,   8,   9,
	 10,  40,  20,
	 46, 140,  38,
	 74,  64,  11,
	 89,  88,  12,
	147,  60,   7,
	 47, 116,  13,
	 59, 129, 108,
	147,  72, 106,
	 33, 108,  75,
	100,  57,  14,
	129, 130,  15,
	 32,  35, 112,
	 16,  29,  27,
	107,  98, 132,
	130, 116,  47,
	 17,  43,   7,
	 54,  44,  53,
	 46,  34,  23,
	 87,  41,  23,
	 40,  10,  18,
	  8, 131,   9,
	 11,  19,  56,
	 11, 137,  19,
	 19,  20,  30,
	 28, 121, 137,
	122, 140,  36,
	 15, 130,  97,
	 28,  84,  83,
	114,  21, 102,
	 87,  98,  22,
	 41, 145,  23,
	133,  68,  12,
	 90,  70,  24,
	 31,  25,  26,
	 98,  34,  35,
	 16,  27, 116,
	 28,  83, 122,
	 29, 103,  77,
	 40,  30,  20,
	 14,  49, 103,
	 31,  26, 142,
	 78,   9, 131,
	 80,  62,   2,
	  6,  67, 105,
	 32,  48,  63,
	 60,  30,   7,
	 33, 135,  91,
	116, 130,  16,
	 47,  13,  39,
	 70, 119,   5,
	 24,  26,   6,
	102,  25,  31,
	103,  49,  77,
	 16, 130,  93,
	125, 126, 124,
	111,  86, 110,
	  4,  52,   2,
	 87,  34,  98,
	  4,   6, 101,
	 29,  76,  27,
	112,  35,  34,
	  6,   4,  67,
	 72,   1, 106,
	 26,  24,  70,
	 36,  37, 121,
	 81, 113, 142,
	 44, 109,  37,
	122,  58,  38,
	 96,  48, 128,
	 71,  11,  56,
	 73, 122,  83,
	 52,  39,  80,
	 40,  18, 145,
	 82,   5, 119,
	 10,  20, 120,
	139, 145,  41,
	  3, 142,   5,
	 76, 117,  27,
	 95, 120,  20,
	104,  45,  42,
	128,  43,  17,
	 44,  37,  36,
	128,  45,  64,
	143, 111, 126,
	 34,  46,  38,
	 97, 130,  47,
	142,  91, 115,
	114,  31, 115,
	125, 100, 129,
	 48,  96,  63,
	 62,  41,   2,
	 69,  77,  49,
	133,  50,  68,
	 60,  51,  30,
	  4, 118,  52,
	 53,  55,  54,
	 95,   8,  55,
	121,  37,  19,
	 65,  75,  99,
	 51,  56,  30,
	 14,  57, 110,
	 58, 122,  73,
	 59,  92, 125,
	 42,  45, 128,
	 49,  14, 110,
	 60, 147,  61,
	 76,  62, 117,
	 69,  49,  86,
	 26,   5, 142,
	 46,  44,  36,
	 63,  50, 132,
	128,  64,  43,
	 75, 108,  15,
	134,  75,  65,
	 68,  69,  86,
	 62,  76, 145,
	142, 141,  91,
	 67,  66, 105,
	 69,  68,  96,
	119,  70,  90,
	 33,  91, 108,
	136, 118,   4,
	 56,  51,  71,
	  1,  72,  71,
	 23,  18,  44,
	104, 123,  73,
	106,   1,  61,
	 86, 111,  68,
	 83,  45, 104,
	 30,  56,  19,
	 15,  97,  99,
	 71,  74,  11,
	 15,  99,  75,
	 25, 102,   6,
	 12,  94,  81,
	135,  33, 134,
	138, 133,   3,
	 76,  29,  77,
	 94,  88, 141,
	115,  31, 142,
	 36, 121, 122,
	  4,   2,  67,
	  9,  78,  79,
	137, 121,  19,
	 69,  96,  77,
	 13,  62,  80,
	  8, 127, 131,
	143, 141,  89,
	133,  12,  81,
	 82, 119, 138,
	 45,  83,  84,
	 21,  85, 136,
	126, 110, 124,
	 86,  49, 110,
	 13, 116, 117,
	 22,  66,  87,
	141,  88,  89,
	 64,  45,  84,
	 79,  78, 109,
	 26,  70,   5,
	 14,  93, 100,
	 68,  50,  63,
	 90, 105, 138,
	141,   0,  91,
	105,  90,   6,
	  0,  92,  59,
	 17, 145,  76,
	 29,  93, 103,
	113,  81,  94,
	 39,  85,  47,
	132,  35,  32,
	128,  48,  42,
	 93,  29,  16,
	145,  18,  23,
	108, 129,  15,
	 32, 112,  48,
	 66,  41,  87,
	120,  95,  55,
	 96,  68,  63,
	 85,  99,  97,
	 18,  53,  44,
	 22,  98, 107,
	 98,  35, 132,
	 95, 127,   8,
	137,  64,  84,
	 18,  10,  53,
	 21,  99,  85,
	 54,  79,  44,
	100,  93, 130,
	142,   3,  81,
	102, 101,   6,
	 93,  14, 103,
	 42,  48, 104,
	 87,  23,  34,
	 66,  22, 105,
	106,  61, 147,
	 72,  74,  71,
	109, 144,  37,
	115,  65,  99,
	107, 132, 133,
	 94,  12,  88,
	108,  91,  59,
	 43,  64,  74,
	109,  78, 144,
	 43, 147,   7,
	 91, 135, 115,
	111, 110, 126,
	 38, 112,  34,
	142, 113,  94,
	 54,   9,  79,
	120,  53,  10,
	138,   3,  82,
	114, 102,  31,
	134,  65, 115,
	105,  22, 107,
	125, 129,  59,
	 37, 144,  19,
	 17,  76,  77,
	 89,  12, 111,
	 41,  66,  67,
	 13, 117,  62,
	116,  27, 117,
	136,  52, 118,
	 51,  60,  61,
	138, 119,  90,
	 53, 120,  55,
	 68, 111,  12,
	122, 121,  28,
	123,  58,  73,
	110,  57, 124,
	 47,  85,  97,
	 44,  79, 109,
	126, 125,  92,
	 43,  74, 146,
	 20,  19, 127,
	128,  17,  77,
	 72, 146,  74,
	115,  99, 114,
	140, 122,  38,
	133, 105, 107,
	129, 100, 130,
	131, 144,  78,
	 95,  20, 127,
	123,  48, 112,
	102, 136, 101,
	 89, 111, 143,
	 28, 137,  84,
	133, 132,  50,
	125,  57, 100,
	 38, 123, 112,
	124,  57, 125,
	135, 134, 115,
	 23,  44,  46,
	136,  85,  52,
	 41,  62, 139,
	137,  11,  64,
	104,  48, 123,
	133, 138, 105,
	145, 139,  62,
	 25,   6,  26,
	  7,  30,  40,
	 46,  36, 140,
	141, 143,   0,
	132,  32,  63,
	 83, 104,  73,
	 19, 144, 127,
	142,  94, 141,
	 39,  13,  80,
	 92, 143, 126,
	127, 144, 131,
	 51,  61,   1,
	 91,   0,  59,
	 17,   7, 145,
	 43, 146, 147,
	146,  72, 147,
};

void imageCheckerboard(void* _dst, uint32_t _width, uint32_t _height, uint32_t _step, uint32_t _0, uint32_t _1)
{
	uint32_t* dst = (uint32_t*)_dst;
	for (uint32_t yy = 0; yy < _height; ++yy)
	{
		for (uint32_t xx = 0; xx < _width; ++xx)
		{
			uint32_t abgr = ( (xx/_step)&1) ^ ( (yy/_step)&1) ? _1 : _0;
			*dst++ = abgr;
		}
	}
}

void translate(Triangle& _inout, bx::Vec3 _pos)
{
	_inout.v0 = bx::add(_inout.v0, _pos);
	_inout.v1 = bx::add(_inout.v1, _pos);
	_inout.v2 = bx::add(_inout.v2, _pos);
}

class ExampleDebugDraw : public entry::AppI
{
public:
	ExampleDebugDraw(const char* _name, const char* _description)
		: entry::AppI(_name, _description)
	{
	}

	void init(int32_t _argc, const char* const* _argv, uint32_t _width, uint32_t _height) override
	{
		Args args(_argc, _argv);

		m_width  = _width;
		m_height = _height;
		m_debug  = BGFX_DEBUG_NONE;
		m_reset  = BGFX_RESET_VSYNC | BGFX_RESET_MSAA_X16;

		bgfx::Init init;
		init.type     = args.m_type;
		init.vendorId = args.m_pciId;
		init.resolution.width  = m_width;
		init.resolution.height = m_height;
		init.resolution.reset  = m_reset;
		bgfx::init(init);

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

		// Set view 0 clear state.
		bgfx::setViewClear(0
				, BGFX_CLEAR_COLOR|BGFX_CLEAR_DEPTH
				, 0x303030ff
				, 1.0f
				, 0
				);

		m_timeOffset = bx::getHPCounter();

		cameraCreate();

		cameraSetPosition({ 0.0f, 2.0f, -12.0f });
		cameraSetVerticalAngle(0.0f);

		ddInit();

		uint8_t data[32*32*4];
		imageCheckerboard(data, 32, 32, 4, 0xff808080, 0xffc0c0c0);

		m_sprite = ddCreateSprite(32, 32, data);
		m_bunny  = ddCreateGeometry(
			  BX_COUNTOF(s_bunnyVertices)
			, s_bunnyVertices
			, BX_COUNTOF(s_bunnyTriList)
			, s_bunnyTriList
			);

		imguiCreate();
	}

	virtual int shutdown() override
	{
		imguiDestroy();

		ddDestroy(m_bunny);
		ddDestroy(m_sprite);

		ddShutdown();

		cameraDestroy();

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

		return 0;
	}

	template<typename Ty>
	bool intersect(DebugDrawEncoder* _dde, const Ray& _ray, const Ty& _shape)
	{
		Hit hit;
		if (::intersect(_ray, _shape, &hit) )
		{
			_dde->push();

			_dde->setWireframe(false);

			_dde->setColor(0xff0000ff);

			const bx::Vec3 tmp = bx::mul(hit.plane.normal, 0.7f);
			const bx::Vec3 end = bx::add(hit.pos, tmp);

			_dde->drawCone(hit.pos, end, 0.1f);

			_dde->pop();

			return true;
		}

		return false;
	}

	bool update() override
	{
		if (!entry::processEvents(m_width, m_height, m_debug, m_reset, &m_mouseState) )
		{
			imguiBeginFrame(
				   m_mouseState.m_mx
				,  m_mouseState.m_my
				, (m_mouseState.m_buttons[entry::MouseButton::Left  ] ? IMGUI_MBUT_LEFT   : 0)
				| (m_mouseState.m_buttons[entry::MouseButton::Right ] ? IMGUI_MBUT_RIGHT  : 0)
				| (m_mouseState.m_buttons[entry::MouseButton::Middle] ? IMGUI_MBUT_MIDDLE : 0)
				,  m_mouseState.m_mz
				, uint16_t(m_width)
				, uint16_t(m_height)
				);

			showExampleDialog(this);

			imguiEndFrame();

			int64_t now = bx::getHPCounter() - m_timeOffset;
			static int64_t last = now;
			const int64_t frameTime = now - last;
			last = now;
			const double freq = double(bx::getHPFrequency() );
			const float deltaTime = float(frameTime/freq);

			// Update camera.
			cameraUpdate(deltaTime, m_mouseState);

			float view[16];
			cameraGetViewMtx(view);

			float proj[16];

			// Set view and projection matrix for view 0.
			{
				bx::mtxProj(proj, 60.0f, float(m_width)/float(m_height), 0.1f, 100.0f, bgfx::getCaps()->homogeneousDepth);

				bgfx::setViewTransform(0, view, proj);
				bgfx::setViewRect(0, 0, 0, uint16_t(m_width), uint16_t(m_height) );
			}

			float mtxVp[16];
			bx::mtxMul(mtxVp, view, proj);

			float mtxInvVp[16];
			bx::mtxInverse(mtxInvVp, mtxVp);

			const bx::Vec3 at  = { 0.0f,  0.0f, 0.0f };
			const bx::Vec3 eye = { 5.0f, 10.0f, 5.0f };
			bx::mtxLookAt(view, eye, at);
			bx::mtxProj(proj, 45.0f, float(m_width)/float(m_height), 1.0f, 15.0f, bgfx::getCaps()->homogeneousDepth);
			bx::mtxMul(mtxVp, view, proj);

			Ray ray = makeRay(
				   (float(m_mouseState.m_mx)/float(m_width)  * 2.0f - 1.0f)
				, -(float(m_mouseState.m_my)/float(m_height) * 2.0f - 1.0f)
				, mtxInvVp
				);

			constexpr uint32_t kSelected = 0xff80ffff;
			constexpr uint32_t kOverlap  = 0xff0000ff;

			DebugDrawEncoder dde;

			dde.begin(0);
			dde.drawAxis(0.0f, 0.0f, 0.0f);

			dde.push();
				Aabb aabb =
				{
					{  5.0f, 1.0f, 1.0f },
					{ 10.0f, 5.0f, 5.0f },
				};
				dde.setWireframe(true);
				dde.setColor(intersect(&dde, ray, aabb) ? kSelected : 0xff00ff00);
				dde.draw(aabb);
			dde.pop();

			float time = float(now/freq);

			Obb obb;
			bx::mtxRotateX(obb.mtx, time);
			dde.setWireframe(true);
			dde.setColor(intersect(&dde, ray, obb) ? kSelected : 0xffffffff);
			dde.draw(obb);

			bx::mtxSRT(obb.mtx, 1.0f, 1.0f, 1.0f, time*0.23f, time, 0.0f, 3.0f, 0.0f, 0.0f);

			dde.push();
				toAabb(aabb, obb);
				dde.setWireframe(true);
				dde.setColor(0xff0000ff);
				dde.draw(aabb);
			dde.pop();

			dde.setWireframe(false);
			dde.setColor(intersect(&dde, ray, obb) ? kSelected : 0xffffffff);
			dde.draw(obb);

			dde.setColor(0xffffffff);

			dde.push();
			{
				float bunny[16];
				bx::mtxSRT(bunny, 0.03f, 0.03f, 0.03f, 0.0f, 0.0f, 0.0f, -3.0f, 0.0f, 0.0f);

				dde.setTransform(bunny);
				const bool wireframe = bx::mod(time, 2.0f) > 1.0f;
				dde.setWireframe(wireframe);
				dde.setColor(wireframe ? 0xffff00ff : 0xff00ff00);
				dde.draw(m_bunny);
				dde.setTransform(NULL);
			}
			dde.pop();

			{
				const bx::Vec3 normal = { 0.0f,  1.0f, 0.0f };
				const bx::Vec3 pos    = { 0.0f, -2.0f, 0.0f };

				bx::Plane plane;
				bx::calcPlane(plane, normal, pos);

				dde.setColor(false
					|| intersect(&dde, ray, plane)
					? kSelected
					: 0xffffffff
					);

				dde.drawGrid(Axis::Y, pos, 128, 1.0f);
			}

			dde.drawFrustum(mtxVp);

			dde.push();
				Sphere sphere = { { 0.0f, 5.0f, 0.0f }, 1.0f };
				dde.setColor(intersect(&dde, ray, sphere) ? kSelected : 0xfff0c0ff);
				dde.setWireframe(true);
				dde.setLod(3);
				dde.draw(sphere);
				dde.setWireframe(false);

				sphere.center.x = -2.0f;
				dde.setColor(intersect(&dde, ray, sphere) ? kSelected : 0xc0ffc0ff);
				dde.setLod(2);
				dde.draw(sphere);

				sphere.center.x = -4.0f;
				dde.setColor(intersect(&dde, ray, sphere) ? kSelected : 0xa0f0ffff);
				dde.setLod(1);
				dde.draw(sphere);

				sphere.center.x = -6.0f;
				dde.setColor(intersect(&dde, ray, sphere) ? kSelected : 0xffc0ff00);
				dde.setLod(0);
				dde.draw(sphere);
			dde.pop();

			dde.setColor(0xffffffff);

			dde.push();
			{
				const bx::Vec3 normal = {  0.0f, 0.0f, 1.0f };
				const bx::Vec3 center = { -8.0f, 0.0f, 0.0f };
				dde.push();
					dde.setStipple(true, 1.0f, time*0.1f);
					dde.setColor(0xff0000ff);
					dde.drawCircle(normal, center, 1.0f, 0.5f + bx::sin(time*10.0f) );
				dde.pop();

				dde.setSpin(time);
				dde.drawQuad(m_sprite, normal, center, 2.0f);
			}
			dde.pop();

			dde.push();
				dde.setStipple(true, 1.0f, -time*0.1f);
				dde.drawCircle(Axis::Z, -8.0f, 0.0f, 0.0f, 1.25f, 2.0f);
			dde.pop();

			dde.push();
				dde.setLod(UINT8_MAX);

				dde.push();
					dde.setSpin(time*0.3f);
					{
						Cone cone =
						{
							{ -11.0f, 4.0f,  0.0f },
							{ -13.0f, 6.0f,  1.0f },
							1.0f
						};

						Cylinder cylinder =
						{
							{  -9.0f, 2.0f, -1.0f },
							{ -11.0f, 4.0f,  0.0f },
							0.5f
						};

						dde.setColor(false
							|| intersect(&dde, ray, cone)
							|| intersect(&dde, ray, cylinder)
							? kSelected
							: 0xffffffff
							);

						dde.draw(cone);
						dde.draw(cylinder);
					}
				dde.pop();

				{
					dde.setLod(0);
					Capsule capsule =
					{
						{  0.0f, 7.0f, 0.0f },
						{ -6.0f, 7.0f, 0.0f },
						0.5f
					};
					dde.setColor(intersect(&dde, ray, capsule) ? kSelected : 0xffffffff);
					dde.draw(capsule);
				}
			dde.pop();

			dde.push();

				float mtx[16];
				bx::mtxSRT(mtx
					, 1.0f, 1.0f, 1.0f
					, 0.0f, time, time*0.53f
					, -10.0f, 1.0f, 10.0f
					);

				Cylinder cylinder =
				{
					{ -10.0f, 1.0f, 10.0f },
					{ 0.0f, 0.0f, 0.0f },
					1.0f
				};

				cylinder.end = bx::mul({ 0.0f, 4.0f, 0.0f }, mtx);
				dde.setColor(intersect(&dde, ray, cylinder) ? kSelected : 0xffffffff);
				dde.draw(cylinder);

				dde.push();
					toAabb(aabb, cylinder);
					dde.setWireframe(true);
					dde.setColor(0xff0000ff);
					dde.draw(aabb);
				dde.pop();

			dde.pop();

			dde.drawOrb(-11.0f, 0.0f, 0.0f, 1.0f);

			dde.push();
				{
					bool olp;

					constexpr float kStepX = 3.0f;
					constexpr float kStepZ = 3.0f;

					const float px = 0.0f;
					const float py = 1.0f;
					const float pz = 10.0f;
					const float xx = bx::sin(time*0.39f) * 1.03f + px;
					const float yy = bx::cos(time*0.79f) * 1.03f + py;
					const float zz = bx::cos(time)       * 1.03f + pz;

					// Sphere ---
					{
						Sphere sphereA = { { px+kStepX*0.0f, py, pz+kStepZ*0.0f }, 0.5f };
						Sphere sphereB = { { xx+kStepX*0.0f, yy, zz+kStepZ*0.0f }, 0.5f };
						olp = overlap(sphereA, sphereB);;

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(sphereA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.draw(sphereB);
					}

					{
						Sphere sphereA = { { px+kStepX*1.0f, py, pz+kStepZ*0.0f }, 0.5f };
						Aabb aabbB;
						toAabb(aabbB, { xx+kStepX*1.0f, yy, zz+kStepZ*0.0f }, { 0.5f, 0.5f, 0.5f });
						olp = overlap(sphereA, aabbB);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(sphereA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.draw(aabbB);
					}

					{
						Sphere sphereA     = { { px+kStepX*2.0f, py, pz+kStepZ*0.0f }, 0.5f };
						Triangle triangleB =
						{
							{ xx-0.4f, yy+0.0f, zz-0.4f },
							{ xx-0.5f, yy-0.3f, zz+0.0f },
							{ xx+0.3f, yy+0.5f, zz+0.0f },
						};

						translate(triangleB, {kStepX*2.0f, 0.0f, kStepZ*0.0f});

						olp = overlap(sphereA, triangleB);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(sphereA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.draw(triangleB);
					}

					{
						Sphere sphereA     = { { px+kStepX*3.0f, py, pz+kStepZ*0.0f }, 0.5f };
						Triangle triangleB =
						{
							{ xx-0.4f, yy+0.0f, zz-0.4f },
							{ xx-0.5f, yy-0.3f, zz+0.0f },
							{ xx+0.3f, yy+0.5f, zz+0.0f },
						};

						translate(triangleB, {kStepX*3.0f, 0.0f, kStepZ*0.0f});

						bx::Plane planeB;
						bx::calcPlane(planeB, triangleB.v0, triangleB.v1, triangleB.v2);

						olp = overlap(sphereA, planeB);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(sphereA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.drawGrid(planeB.normal, triangleB.v0, 10, 0.3f);
					}

					{
						Sphere sphereA     = { { px+kStepX*4.0f, py, pz+kStepZ*0.0f }, 0.5f };
						Triangle triangleB =
						{
							{ xx-0.4f, yy+0.0f, zz-0.4f },
							{ xx-0.5f, yy-0.3f, zz+0.0f },
							{ xx+0.3f, yy+0.5f, zz+0.0f },
						};

						translate(triangleB, {kStepX*4.0f, 0.0f, kStepZ*0.0f});

						bx::Plane planeB;
						bx::calcPlane(planeB, triangleB.v0, triangleB.v1, triangleB.v2);

						const Disk diskB = { getCenter(triangleB), planeB.normal, 0.5f };

						olp = overlap(sphereA, diskB);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(sphereA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.draw(diskB);
					}

					// AABB ---
					{
						Aabb aabbA, aabbB;
						toAabb(aabbA, { px+kStepX*1.0f, py, pz+kStepZ*1.0f }, { 0.5f, 0.5f, 0.5f });
						toAabb(aabbB, { xx+kStepX*1.0f, yy, zz+kStepZ*1.0f }, { 0.5f, 0.5f, 0.5f });
						olp = overlap(aabbA, aabbB);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(aabbA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.draw(aabbB);
					}

					{
						Aabb aabbA;
						toAabb(aabbA, { px+kStepX*2.0f, py, pz+kStepZ*1.0f }, { 0.5f, 0.5f, 0.5f });
						Triangle triangleB =
						{
							{ xx-0.4f, yy+0.0f, zz-0.4f },
							{ xx-0.5f, yy-0.3f, zz+0.0f },
							{ xx+0.3f, yy+0.5f, zz+0.0f },
						};

						translate(triangleB, {kStepX*2.0f, 0.0f, kStepZ*1.0f});

						olp = overlap(aabbA, triangleB);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(aabbA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.draw(triangleB);
					}

					{
						Aabb aabbA;
						toAabb(aabbA, { px+kStepX*3.0f, py, pz+kStepZ*1.0f }, { 0.5f, 0.5f, 0.5f });
						Triangle triangleB =
						{
							{ xx-0.4f, yy+0.0f, zz-0.4f },
							{ xx-0.5f, yy-0.3f, zz+0.0f },
							{ xx+0.3f, yy+0.5f, zz+0.0f },
						};

						translate(triangleB, {kStepX*3.0f, 0.0f, kStepZ*1.0f});

						bx::Plane planeB;
						bx::calcPlane(planeB, triangleB.v0, triangleB.v1, triangleB.v2);

						olp = overlap(aabbA, planeB);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(aabbA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.drawGrid(planeB.normal, triangleB.v0, 10, 0.3f);
					}

					{
						Aabb aabbA;
						toAabb(aabbA, { px+kStepX*4.0f, py, pz+kStepZ*1.0f }, { 0.5f, 0.5f, 0.5f });
						Triangle triangleB =
						{
							{ xx-0.4f, yy+0.0f, zz-0.4f },
							{ xx-0.5f, yy-0.3f, zz+0.0f },
							{ xx+0.3f, yy+0.5f, zz+0.0f },
						};

						translate(triangleB, {kStepX*4.0f, 0.0f, kStepZ*1.0f});

						bx::Plane planeB;
						bx::calcPlane(planeB, triangleB.v0, triangleB.v1, triangleB.v2);

						const Disk diskB = { getCenter(triangleB), planeB.normal, 0.5f };

						olp = overlap(aabbA, diskB);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(aabbA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.draw(diskB);
					}

					// Triangle ---
					{
						Triangle triangleA =
						{
							{ px-0.4f, py+0.0f, pz-0.4f },
							{ px+0.0f, py-0.3f, pz-0.5f },
							{ px+0.0f, py+0.5f, pz+0.3f },
						};

						translate(triangleA, {kStepX*2.0f, 0.0f, kStepZ*2.0f});

						Triangle triangleB =
						{
							{ xx-0.4f, yy+0.0f, zz-0.4f },
							{ xx-0.5f, yy-0.3f, zz+0.0f },
							{ xx+0.3f, yy+0.5f, zz+0.0f },
						};

						translate(triangleB, {kStepX*2.0f, 0.0f, kStepZ*2.0f});

						olp = overlap(triangleA, triangleB);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(triangleA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.draw(triangleB);
					}

					{
						Triangle triangleA =
						{
							{ px-0.4f, py+0.0f, pz-0.4f },
							{ px+0.0f, py-0.3f, pz-0.5f },
							{ px+0.0f, py+0.5f, pz+0.3f },
						};

						translate(triangleA, {kStepX*3.0f, 0.0f, kStepZ*2.0f});

						Triangle triangleB =
						{
							{ xx-0.4f, yy+0.0f, zz-0.4f },
							{ xx-0.5f, yy-0.3f, zz+0.0f },
							{ xx+0.3f, yy+0.5f, zz+0.0f },
						};

						translate(triangleB, {kStepX*3.0f, 0.0f, kStepZ*2.0f});

						bx::Plane planeB;
						bx::calcPlane(planeB, triangleB.v0, triangleB.v1, triangleB.v2);

						olp = overlap(triangleA, planeB);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(triangleA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.drawGrid(planeB.normal, triangleB.v0, 10, 0.3f);
					}

					{
						Triangle triangleA =
						{
							{ px-0.4f, py+0.0f, pz-0.4f },
							{ px+0.0f, py-0.3f, pz-0.5f },
							{ px+0.0f, py+0.5f, pz+0.3f },
						};

						translate(triangleA, {kStepX*4.0f, 0.0f, kStepZ*2.0f});

						Triangle triangleB =
						{
							{ xx-0.4f, yy+0.0f, zz-0.4f },
							{ xx-0.5f, yy-0.3f, zz+0.0f },
							{ xx+0.3f, yy+0.5f, zz+0.0f },
						};

						translate(triangleB, {kStepX*4.0f, 0.0f, kStepZ*2.0f});

						bx::Plane planeB;
						bx::calcPlane(planeB, triangleB.v0, triangleB.v1, triangleB.v2);

						const Disk diskB = { getCenter(triangleB), planeB.normal, 0.5f };

						olp = overlap(triangleA, diskB);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(false);
						dde.draw(triangleA);

						dde.setColor(olp ? kOverlap : 0xffffffff);
						dde.setWireframe(true);
						dde.draw(diskB);
					}
				}
			dde.pop();

			dde.end();

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

			return true;
		}

		return false;
	}

	entry::MouseState m_mouseState;

	SpriteHandle   m_sprite;
	GeometryHandle m_bunny;

	int64_t m_timeOffset;

	uint32_t m_width;
	uint32_t m_height;
	uint32_t m_debug;
	uint32_t m_reset;
};

} // namespace

ENTRY_IMPLEMENT_MAIN(ExampleDebugDraw, "29-debugdraw", "Debug draw.");