mirrors
/
bgfx
mirror of https://github.com/bkaradzic/bgfx
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
bgfx/examples/29-debugdraw/debugdraw.cpp

1236 lines
30 KiB
C++
Raw Blame History

/*
* Copyright 2011-2024 Branimir Karadzic. All rights reserved.
* License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE
*/
#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,
};
struct Shape
{
struct Type
{
enum Enum
{
Sphere,
Aabb,
Triangle,
Capsule,
Plane,
Disk,
Obb,
Cone,
Cylinder,
Count
};
};
Shape() : type(uint8_t(Type::Count) ) {}
Shape(const bx::Aabb & _a) : type(uint8_t(Type::Aabb ) ) { bx::memCopy(data, &_a, sizeof(_a) ); }
Shape(const bx::Capsule & _a) : type(uint8_t(Type::Capsule ) ) { bx::memCopy(data, &_a, sizeof(_a) ); }
Shape(const bx::Cone & _a) : type(uint8_t(Type::Cone ) ) { bx::memCopy(data, &_a, sizeof(_a) ); }
Shape(const bx::Cylinder & _a) : type(uint8_t(Type::Cylinder) ) { bx::memCopy(data, &_a, sizeof(_a) ); }
Shape(const bx::Disk & _a) : type(uint8_t(Type::Disk ) ) { bx::memCopy(data, &_a, sizeof(_a) ); }
Shape(const bx::Obb & _a) : type(uint8_t(Type::Obb ) ) { bx::memCopy(data, &_a, sizeof(_a) ); }
Shape(const bx::Plane & _a) : type(uint8_t(Type::Plane ) ) { bx::memCopy(data, &_a, sizeof(_a) ); }
Shape(const bx::Sphere & _a) : type(uint8_t(Type::Sphere ) ) { bx::memCopy(data, &_a, sizeof(_a) ); }
Shape(const bx::Triangle & _a) : type(uint8_t(Type::Triangle) ) { bx::memCopy(data, &_a, sizeof(_a) ); }
uint8_t data[64];
uint8_t type;
};
#define OVERLAP(_shapeType) \
bool overlap(const _shapeType& _shapeA, const Shape& _shapeB) \
{ \
switch (_shapeB.type) \
{ \
case Shape::Type::Aabb: return bx::overlap(_shapeA, *reinterpret_cast<const bx::Aabb *>(_shapeB.data) ); \
case Shape::Type::Capsule: return bx::overlap(_shapeA, *reinterpret_cast<const bx::Capsule *>(_shapeB.data) ); \
case Shape::Type::Cone: return bx::overlap(_shapeA, *reinterpret_cast<const bx::Cone *>(_shapeB.data) ); \
case Shape::Type::Cylinder: return bx::overlap(_shapeA, *reinterpret_cast<const bx::Cylinder *>(_shapeB.data) ); \
case Shape::Type::Disk: return bx::overlap(_shapeA, *reinterpret_cast<const bx::Disk *>(_shapeB.data) ); \
case Shape::Type::Obb: return bx::overlap(_shapeA, *reinterpret_cast<const bx::Obb *>(_shapeB.data) ); \
case Shape::Type::Plane: return bx::overlap(_shapeA, *reinterpret_cast<const bx::Plane *>(_shapeB.data) ); \
case Shape::Type::Sphere: return bx::overlap(_shapeA, *reinterpret_cast<const bx::Sphere *>(_shapeB.data) ); \
case Shape::Type::Triangle: return bx::overlap(_shapeA, *reinterpret_cast<const bx::Triangle *>(_shapeB.data) ); \
} \
return false; \
}
OVERLAP(bx::Aabb);
OVERLAP(bx::Capsule);
OVERLAP(bx::Cone);
OVERLAP(bx::Cylinder);
OVERLAP(bx::Disk);
OVERLAP(bx::Obb);
OVERLAP(bx::Plane);
OVERLAP(bx::Sphere);
OVERLAP(bx::Triangle);
#undef OVERLAP
void initA(Shape& _outShape, Shape::Type::Enum _type, bx::Vec3 _pos)
{
switch (_type)
{
case Shape::Type::Aabb:
{
bx::Aabb aabb;
toAabb(aabb, _pos, { 0.5f, 0.5f, 0.5f });
_outShape = Shape(aabb);
}
break;
case Shape::Type::Capsule:
_outShape = Shape(bx::Capsule
{
{ bx::add(_pos, {0.0f, -1.0f, 0.0f}) },
{ bx::add(_pos, {0.0f, 1.0f, 0.0f}) },
0.5f,
});
break;
case Shape::Type::Cone:
_outShape = Shape(bx::Cone
{
{ bx::add(_pos, {0.0f, -1.0f, 0.0f}) },
{ bx::add(_pos, {0.0f, 1.0f, 0.0f}) },
0.5f,
});
break;
case Shape::Type::Cylinder:
_outShape = Shape(bx::Cylinder
{
{ bx::add(_pos, {0.0f, -1.0f, 0.0f}) },
{ bx::add(_pos, {0.0f, 1.0f, 0.0f}) },
0.5f,
});
break;
case Shape::Type::Disk:
_outShape = Shape(bx::Disk
{
_pos,
bx::normalize(bx::Vec3{0.0f, 1.0f, 1.0f}),
0.5f,
});
break;
case Shape::Type::Obb:
{
bx::Obb obb;
bx::mtxSRT(obb.mtx
, 0.25f
, 1.0f
, 0.25f
, bx::toRad(50.0f)
, bx::toRad(15.0f)
, bx::toRad(45.0f)
, _pos.x
, _pos.y
, _pos.z
);
_outShape = Shape(obb);
}
break;
case Shape::Type::Sphere:
_outShape = Shape(bx::Sphere{_pos, 0.5f});
break;
case Shape::Type::Plane:
{
bx::Plane plane(bx::InitNone);
bx::calcPlane(plane, bx::normalize(bx::Vec3{0.0f, 1.0f, 1.0f}), _pos);
_outShape = Shape(plane);
}
break;
case Shape::Type::Triangle:
_outShape = Shape(bx::Triangle
{
{ bx::add(_pos, {-0.4f, 0.0f, -0.4f}) },
{ bx::add(_pos, { 0.0f, -0.3f, 0.5f}) },
{ bx::add(_pos, { 0.0f, 0.5f, 0.3f}) },
});
break;
default: break;
}
}
void initB(Shape& _outShape, Shape::Type::Enum _type, bx::Vec3 _pos)
{
switch (_type)
{
case Shape::Type::Aabb:
{
bx::Aabb aabb;
toAabb(aabb, _pos, { 0.5f, 0.5f, 0.5f });
_outShape = Shape(aabb);
}
break;
case Shape::Type::Capsule:
_outShape = Shape(bx::Capsule
{
{ bx::add(_pos, {0.0f, -1.0f, 0.1f}) },
{ bx::add(_pos, {0.0f, 1.0f, 0.0f}) },
0.2f,
});
break;
case Shape::Type::Cone:
_outShape = Shape(bx::Cone
{
{ bx::add(_pos, {0.0f, -1.0f, 0.1f}) },
{ bx::add(_pos, {0.0f, 1.0f, 0.0f}) },
0.2f,
});
break;
case Shape::Type::Cylinder:
_outShape = Shape(bx::Cylinder
{
{ bx::add(_pos, {0.0f, -1.0f, 0.1f}) },
{ bx::add(_pos, {0.0f, 1.0f, 0.0f}) },
0.2f,
});
break;
case Shape::Type::Disk:
_outShape = Shape(bx::Disk
{
_pos,
bx::normalize(bx::Vec3{1.0f, 1.0f, 0.0f}),
0.5f,
});
break;
case Shape::Type::Obb:
{
bx::Obb obb;
bx::mtxSRT(obb.mtx
, 1.0f
, 0.25f
, 0.25f
, bx::toRad(10.0f)
, bx::toRad(30.0f)
, bx::toRad(70.0f)
, _pos.x
, _pos.y
, _pos.z
);
_outShape = Shape(obb);
}
break;
case Shape::Type::Plane:
{
bx::Plane plane(bx::InitNone);
bx::calcPlane(plane, bx::normalize(bx::Vec3{1.0f, 1.0f, 0.0f}), _pos);
_outShape = Shape(plane);
}
break;
case Shape::Type::Sphere:
_outShape = Shape(bx::Sphere{_pos, 0.5f});
break;
case Shape::Type::Triangle:
_outShape = Shape(bx::Triangle
{
{ bx::add(_pos, {-0.4f, 0.0f, -0.4f}) },
{ bx::add(_pos, {-0.5f, -0.3f, 0.0f}) },
{ bx::add(_pos, { 0.3f, 0.5f, 0.0f}) },
});
break;
default: break;
}
}
int32_t overlap(const Shape& _shapeA, const Shape& _shapeB)
{
switch (_shapeA.type)
{
case Shape::Type::Aabb: return ::overlap(*reinterpret_cast<const bx::Aabb *>(_shapeA.data), _shapeB);
case Shape::Type::Capsule: return ::overlap(*reinterpret_cast<const bx::Capsule *>(_shapeA.data), _shapeB);
case Shape::Type::Cone: return ::overlap(*reinterpret_cast<const bx::Cone *>(_shapeA.data), _shapeB);
case Shape::Type::Cylinder: return ::overlap(*reinterpret_cast<const bx::Cylinder *>(_shapeA.data), _shapeB);
case Shape::Type::Disk: return ::overlap(*reinterpret_cast<const bx::Disk *>(_shapeA.data), _shapeB);
case Shape::Type::Obb: return ::overlap(*reinterpret_cast<const bx::Obb *>(_shapeA.data), _shapeB);
case Shape::Type::Plane: return ::overlap(*reinterpret_cast<const bx::Plane *>(_shapeA.data), _shapeB);
case Shape::Type::Sphere: return ::overlap(*reinterpret_cast<const bx::Sphere *>(_shapeA.data), _shapeB);
case Shape::Type::Triangle: return ::overlap(*reinterpret_cast<const bx::Triangle *>(_shapeA.data), _shapeB);
}
return 2;
}
void draw(DebugDrawEncoder& _dde, const Shape& _shape, const bx::Vec3 _pos)
{
switch (_shape.type)
{
case Shape::Type::Aabb: _dde.draw (*reinterpret_cast<const bx::Aabb *>(_shape.data) ); break;
case Shape::Type::Capsule: _dde.draw (*reinterpret_cast<const bx::Capsule *>(_shape.data) ); break;
case Shape::Type::Cone: _dde.draw (*reinterpret_cast<const bx::Cone *>(_shape.data) ); break;
case Shape::Type::Cylinder: _dde.draw (*reinterpret_cast<const bx::Cylinder *>(_shape.data) ); break;
case Shape::Type::Disk: _dde.draw (*reinterpret_cast<const bx::Disk *>(_shape.data) ); break;
case Shape::Type::Obb: _dde.draw (*reinterpret_cast<const bx::Obb *>(_shape.data) ); break;
case Shape::Type::Plane: { _dde.drawGrid( reinterpret_cast<const bx::Plane *>(_shape.data)->normal, _pos, 9, 0.3f); } break;
case Shape::Type::Sphere: _dde.draw (*reinterpret_cast<const bx::Sphere *>(_shape.data) ); break;
case Shape::Type::Triangle: _dde.draw (*reinterpret_cast<const bx::Triangle *>(_shape.data) ); break;
}
}
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;
}
}
}
class ExampleDebugDraw : public entry::AppI
{
public:
ExampleDebugDraw(const char* _name, const char* _description, const char* _url)
: entry::AppI(_name, _description, _url)
{
}
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.platformData.nwh = entry::getNativeWindowHandle(entry::kDefaultWindowHandle);
init.platformData.ndt = entry::getNativeDisplayHandle();
init.platformData.type = entry::getNativeWindowHandleType();
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 bx::Ray& _ray, const Ty& _shape)
{
bx::Hit hit;
if (bx::intersect(_ray, _shape, &hit) )
{
_dde->push();
_dde->setWireframe(false);
_dde->setColor(0xff0000ff);
_dde->drawCone(hit.pos, bx::mad(hit.plane.normal, 0.7f, hit.pos), 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);
ImGui::SetNextWindowPos(
ImVec2(m_width - m_width / 5.0f - 10.0f, 10.0f)
, ImGuiCond_FirstUseEver
);
ImGui::SetNextWindowSize(
ImVec2(m_width / 5.0f, m_height / 3.0f)
, ImGuiCond_FirstUseEver
);
ImGui::Begin("Settings"
, NULL
, 0
);
static float amplitudeMul = 0.0f;
ImGui::SliderFloat("Amplitude", &amplitudeMul, 0.0f, 1.0f);
static float timeScale = 1.0f;
ImGui::SliderFloat("T scale", &timeScale, -1.0f, 1.0f);
ImGui::End();
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, ImGui::MouseOverArea() );
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);
bx::Ray ray = bx::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 kOverlapA = 0xff0000ff;
constexpr uint32_t kOverlapB = 0xff8080ff;
DebugDrawEncoder dde;
dde.begin(0);
dde.drawAxis(0.0f, 0.0f, 0.0f);
dde.push();
bx::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();
static float time = 0.0f;
time += deltaTime*timeScale;
bx::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();
bx::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::InitNone);
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();
bx::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);
{
bx::Cone cone =
{
{ -11.0f, 4.0f, 0.0f },
{ -13.0f, 6.0f, 1.0f },
1.0f
};
bx::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);
bx::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
);
bx::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();
{
constexpr uint32_t colorA[] =
{
0xffffffff,
kOverlapA,
0xff666666,
0xff6666ff,
};
constexpr uint32_t colorB[] =
{
0xffffffff,
kOverlapB,
0xff888888,
0xff8888ff,
};
constexpr float kStep = 3.0f;
bx::Vec3 posA =
{
-4.5f*kStep,
1.0f,
20.0f,
};
for (uint32_t ii = 0; ii < Shape::Type::Count; ++ii)
{
const bx::Vec3 posB = bx::add(posA,
{
amplitudeMul*bx::sin(time*0.39f) * 1.03f,
amplitudeMul*bx::cos(time*0.79f) * 1.03f,
amplitudeMul*bx::cos(time) * 1.03f,
});
for (uint32_t jj = 0; jj < Shape::Type::Count; ++jj)
{
const bx::Vec3 pa = bx::add(posA, {jj*kStep, 0.0f, 0.0f});
const bx::Vec3 pb = bx::add(posB, {jj*kStep, 0.0f, 0.0f});
Shape shapeA, shapeB;
initA(shapeA, Shape::Type::Enum(ii), pa);
initB(shapeB, Shape::Type::Enum(jj), pb);
int32_t olp = overlap(shapeA, shapeB);
dde.setColor(colorA[olp]);
dde.setWireframe(false);
draw(dde, shapeA, pa);
dde.setColor(colorB[olp]);
dde.setWireframe(true);
draw(dde, shapeB, pb);
}
posA = bx::add(posA, {0.0f, 0.0f, kStep});
}
}
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."
, "https://bkaradzic.github.io/bgfx/examples.html#debugdraw"
);
Reference in New Issue View Git Blame Copy Permalink