From f3313f825a1912bd040a1d3fe6ca4afc92e4a47f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Branimir=20Karad=C5=BEi=C4=87?= Date: Wed, 11 Apr 2018 17:26:55 -0700 Subject: [PATCH] debugdraw: Added encoder to allow MT submit. --- examples/29-debugdraw/debugdraw.cpp | 182 ++++---- examples/common/debugdraw/debugdraw.cpp | 568 +++++++++++++++++------- examples/common/debugdraw/debugdraw.h | 135 ++++++ 3 files changed, 632 insertions(+), 253 deletions(-) diff --git a/examples/29-debugdraw/debugdraw.cpp b/examples/29-debugdraw/debugdraw.cpp index 41efa239e..70f62ce18 100644 --- a/examples/29-debugdraw/debugdraw.cpp +++ b/examples/29-debugdraw/debugdraw.cpp @@ -550,16 +550,16 @@ public: } template - bool intersect(const Ray& _ray, const Ty& _shape) + bool intersect(DebugDrawEncoder* _dde, const Ray& _ray, const Ty& _shape) { Hit hit; if (::intersect(_ray, _shape, &hit) ) { - ddPush(); + _dde->push(); - ddSetWireframe(false); + _dde->setWireframe(false); - ddSetColor(0xff0000ff); + _dde->setColor(0xff0000ff); float tmp[3]; bx::vec3Mul(tmp, hit.m_normal, 0.7f); @@ -567,9 +567,9 @@ public: float end[3]; bx::vec3Add(end, hit.m_pos, tmp); - ddDrawCone(hit.m_pos, end, 0.1f); + _dde->drawCone(hit.m_pos, end, 0.1f); - ddPop(); + _dde->pop(); return true; } @@ -649,113 +649,115 @@ public: const uint32_t selected = 0xff80ffff; - ddBegin(0); - ddDrawAxis(0.0f, 0.0f, 0.0f); + DebugDrawEncoder dde; - ddPush(); + 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 }, }; - ddSetWireframe(true); - ddSetColor(intersect(ray, aabb) ? selected : 0xff00ff00); - ddDraw(aabb); - ddPop(); + dde.setWireframe(true); + dde.setColor(intersect(&dde, ray, aabb) ? selected : 0xff00ff00); + dde.draw(aabb); + dde.pop(); float time = float(now/freq); Obb obb; bx::mtxRotateX(obb.m_mtx, time); - ddSetWireframe(true); - ddSetColor(intersect(ray, obb) ? selected : 0xffffffff); - ddDraw(obb); + dde.setWireframe(true); + dde.setColor(intersect(&dde, ray, obb) ? selected : 0xffffffff); + dde.draw(obb); bx::mtxSRT(obb.m_mtx, 1.0f, 1.0f, 1.0f, time*0.23f, time, 0.0f, 3.0f, 0.0f, 0.0f); - ddPush(); + dde.push(); toAabb(aabb, obb); - ddSetWireframe(true); - ddSetColor(0xff0000ff); - ddDraw(aabb); - ddPop(); + dde.setWireframe(true); + dde.setColor(0xff0000ff); + dde.draw(aabb); + dde.pop(); - ddSetWireframe(false); - ddSetColor(intersect(ray, obb) ? selected : 0xffffffff); - ddDraw(obb); + dde.setWireframe(false); + dde.setColor(intersect(&dde, ray, obb) ? selected : 0xffffffff); + dde.draw(obb); - ddSetColor(0xffffffff); + dde.setColor(0xffffffff); - ddPush(); + 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); - ddSetTransform(bunny); + dde.setTransform(bunny); const bool wireframe = bx::mod(time, 2.0f) > 1.0f; - ddSetWireframe(wireframe); - ddSetColor(wireframe ? 0xffff00ff : 0xff00ff00); - ddDraw(m_bunny); + dde.setWireframe(wireframe); + dde.setColor(wireframe ? 0xffff00ff : 0xff00ff00); + dde.draw(m_bunny); } - ddPop(); + dde.pop(); - ddSetTranslate(0.0f, -2.0f, 0.0f); - ddDrawGrid(Axis::Y, zero, 20, 1.0f); - ddSetTransform(NULL); + dde.setTranslate(0.0f, -2.0f, 0.0f); + dde.drawGrid(Axis::Y, zero, 20, 1.0f); + dde.setTransform(NULL); - ddDrawFrustum(mtxVp); + dde.drawFrustum(mtxVp); - ddPush(); + dde.push(); Sphere sphere = { { 0.0f, 5.0f, 0.0f }, 1.0f }; - ddSetColor(intersect(ray, sphere) ? selected : 0xfff0c0ff); - ddSetWireframe(true); - ddSetLod(3); - ddDraw(sphere); - ddSetWireframe(false); + dde.setColor(intersect(&dde, ray, sphere) ? selected : 0xfff0c0ff); + dde.setWireframe(true); + dde.setLod(3); + dde.draw(sphere); + dde.setWireframe(false); sphere.m_center[0] = -2.0f; - ddSetColor(intersect(ray, sphere) ? selected : 0xc0ffc0ff); - ddSetLod(2); - ddDraw(sphere); + dde.setColor(intersect(&dde, ray, sphere) ? selected : 0xc0ffc0ff); + dde.setLod(2); + dde.draw(sphere); sphere.m_center[0] = -4.0f; - ddSetColor(intersect(ray, sphere) ? selected : 0xa0f0ffff); - ddSetLod(1); - ddDraw(sphere); + dde.setColor(intersect(&dde, ray, sphere) ? selected : 0xa0f0ffff); + dde.setLod(1); + dde.draw(sphere); sphere.m_center[0] = -6.0f; - ddSetColor(intersect(ray, sphere) ? selected : 0xffc0ff00); - ddSetLod(0); - ddDraw(sphere); - ddPop(); + dde.setColor(intersect(&dde, ray, sphere) ? selected : 0xffc0ff00); + dde.setLod(0); + dde.draw(sphere); + dde.pop(); - ddSetColor(0xffffffff); + dde.setColor(0xffffffff); - ddPush(); + dde.push(); { float normal[3] = { 0.0f, 0.0f, 1.0f }; float center[3] = { -8.0f, 0.0f, 0.0f }; - ddPush(); - ddSetStipple(true, 1.0f, time*0.1f); - ddSetColor(0xff0000ff); - ddDrawCircle(normal, center, 1.0f, 0.5f + bx::sin(time*10.0f) ); - ddPop(); + 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(); - ddSetSpin(time); - ddDrawQuad(m_sprite, normal, center, 2.0f); + dde.setSpin(time); + dde.drawQuad(m_sprite, normal, center, 2.0f); } - ddPop(); + dde.pop(); - ddPush(); - ddSetStipple(true, 1.0f, -time*0.1f); - ddDrawCircle(Axis::Z, -8.0f, 0.0f, 0.0f, 1.25f, 2.0f); - ddPop(); + 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(); - ddPush(); - ddSetLod(UINT8_MAX); + dde.push(); + dde.setLod(UINT8_MAX); - ddPush(); - ddSetSpin(time*0.3f); + dde.push(); + dde.setSpin(time*0.3f); { Cone cone = { @@ -771,32 +773,32 @@ public: 0.5f }; - ddSetColor(false - || intersect(ray, cone) - || intersect(ray, cylinder) + dde.setColor(false + || intersect(&dde, ray, cone) + || intersect(&dde, ray, cylinder) ? selected : 0xffffffff ); - ddDraw(cone); - ddDraw(cylinder); + dde.draw(cone); + dde.draw(cylinder); } - ddPop(); + dde.pop(); { - ddSetLod(0); + dde.setLod(0); Capsule capsule = { { 0.0f, 7.0f, 0.0f }, { -6.0f, 7.0f, 0.0f }, 0.5f }; - ddSetColor(intersect(ray, capsule) ? selected : 0xffffffff); - ddDraw(capsule); + dde.setColor(intersect(&dde, ray, capsule) ? selected : 0xffffffff); + dde.draw(capsule); } - ddPop(); + dde.pop(); - ddPush(); + dde.push(); float mtx[16]; bx::mtxSRT(mtx @@ -814,21 +816,21 @@ public: float up[3] = { 0.0f, 4.0f, 0.0f }; bx::vec3MulMtx(cylinder.m_end, up, mtx); - ddSetColor(intersect(ray, cylinder) ? selected : 0xffffffff); - ddDraw(cylinder); + dde.setColor(intersect(&dde, ray, cylinder) ? selected : 0xffffffff); + dde.draw(cylinder); - ddPush(); + dde.push(); toAabb(aabb, cylinder); - ddSetWireframe(true); - ddSetColor(0xff0000ff); - ddDraw(aabb); - ddPop(); + dde.setWireframe(true); + dde.setColor(0xff0000ff); + dde.draw(aabb); + dde.pop(); - ddPop(); + dde.pop(); - ddDrawOrb(-11.0f, 0.0f, 0.0f, 1.0f); + dde.drawOrb(-11.0f, 0.0f, 0.0f, 1.0f); - ddEnd(); + dde.end(); // Advance to next frame. Rendering thread will be kicked to // process submitted rendering primitives. diff --git a/examples/common/debugdraw/debugdraw.cpp b/examples/common/debugdraw/debugdraw.cpp index 3e08e5c3b..60fe7d109 100644 --- a/examples/common/debugdraw/debugdraw.cpp +++ b/examples/common/debugdraw/debugdraw.cpp @@ -9,6 +9,7 @@ #include "../bgfx_utils.h" #include "../packrect.h" +#include #include #include #include @@ -491,26 +492,78 @@ struct Attrib uint8_t m_lod; }; -struct DebugDraw +struct Program { - DebugDraw() - : m_depthTestLess(true) - , m_state(State::Count) + enum Enum { - } + Lines, + LinesStipple, + Fill, + FillMesh, + FillLit, + FillLitMesh, + FillTexture, - void init(bool _depthTestLess, bx::AllocatorI* _allocator) + Count + }; +}; + +struct Mesh +{ + enum Enum { - m_encoder = NULL; - m_defaultEncoder = bgfx::begin(); - m_allocator = _allocator; - m_depthTestLess = _depthTestLess; + Sphere0, + Sphere1, + Sphere2, + Sphere3, + Cone0, + Cone1, + Cone2, + Cone3, + + Cylinder0, + Cylinder1, + Cylinder2, + Cylinder3, + + Capsule0, + Capsule1, + Capsule2, + Capsule3, + + Cube, + + Count, + + SphereMaxLod = Sphere3 - Sphere0, + ConeMaxLod = Cone3 - Cone0, + CylinderMaxLod = Cylinder3 - Cylinder0, + CapsuleMaxLod = Capsule3 - Capsule0, + }; + + uint32_t m_startVertex; + uint32_t m_numVertices; + uint32_t m_startIndex[2]; + uint32_t m_numIndices[2]; +}; + +typedef SpriteT<256, SPRITE_TEXTURE_SIZE> Sprite; +typedef GeometryT<256> Geometry; + +struct DebugDrawShared +{ + void init(bx::AllocatorI* _allocator) + { if (NULL == _allocator) { static bx::DefaultAllocator allocator; m_allocator = &allocator; } + else + { + m_allocator = _allocator; + } DebugVertex::init(); DebugUvVertex::init(); @@ -866,12 +919,6 @@ struct DebugDraw m_vbh = bgfx::createVertexBuffer(vb, DebugShapeVertex::ms_decl); m_ibh = bgfx::createIndexBuffer(ib); - - m_viewId = 0; - m_pos = 0; - m_indexPos = 0; - m_vertexPos = 0; - m_posQuad = 0; } void shutdown() @@ -889,6 +936,8 @@ struct DebugDraw SpriteHandle createSprite(uint16_t _width, uint16_t _height, const void* _data) { + bx::MutexScope lock(m_lock); + SpriteHandle handle = m_sprite.create(_width, _height); if (isValid(handle) ) @@ -911,28 +960,77 @@ struct DebugDraw void destroy(SpriteHandle _handle) { + bx::MutexScope lock(m_lock); + m_sprite.destroy(_handle); } GeometryHandle createGeometry(uint32_t _numVertices, const DdVertex* _vertices, uint32_t _numIndices, const uint16_t* _indices) { + bx::MutexScope lock(m_lock); + return m_geometry.create(_numVertices, _vertices, _numIndices, _indices); } void destroy(GeometryHandle _handle) { + bx::MutexScope lock(m_lock); + m_geometry.destroy(_handle); } + bx::AllocatorI* m_allocator; + bx::Mutex m_lock; + + Sprite m_sprite; + Geometry m_geometry; + + Mesh m_mesh[Mesh::Count]; + + bgfx::UniformHandle s_texColor; + bgfx::TextureHandle m_texture; + bgfx::ProgramHandle m_program[Program::Count]; + bgfx::UniformHandle u_params; + + bgfx::VertexBufferHandle m_vbh; + bgfx::IndexBufferHandle m_ibh; +}; + +static DebugDrawShared s_dds; + +struct DebugDrawEncoderImpl +{ + DebugDrawEncoderImpl() + : m_depthTestLess(true) + , m_state(State::Count) + , m_defaultEncoder(NULL) + { + } + + void init(bool _depthTestLess, bgfx::Encoder* _encoder) + { + m_defaultEncoder = _encoder; + m_depthTestLess = _depthTestLess; + } + + void shutdown() + { + } + void begin(bgfx::ViewId _viewId, bgfx::Encoder* _encoder) { BX_CHECK(State::Count == m_state); - m_encoder = NULL != _encoder ? _encoder : m_defaultEncoder; m_viewId = _viewId; + m_encoder = _encoder == NULL ? m_defaultEncoder : _encoder; m_state = State::None; m_stack = 0; + m_pos = 0; + m_indexPos = 0; + m_vertexPos = 0; + m_posQuad = 0; + Attrib& attrib = m_attrib[0]; attrib.m_state = 0 | BGFX_STATE_WRITE_RGB @@ -1396,7 +1494,7 @@ struct DebugDraw }; bx::vec3Norm(params[0], params[0]); - m_encoder->setUniform(u_params, params, 4); + m_encoder->setUniform(s_dds.u_params, params, 4); m_encoder->setState(0 | _attrib.m_state @@ -1407,7 +1505,7 @@ struct DebugDraw void draw(GeometryHandle _handle) { - Geometry::Geometry& geometry = m_geometry.m_geometry[_handle.idx]; + const Geometry::Geometry& geometry = s_dds.m_geometry.m_geometry[_handle.idx]; m_encoder->setVertexBuffer(0, geometry.m_vbh); const Attrib& attrib = m_attrib[m_stack]; @@ -1432,7 +1530,7 @@ struct DebugDraw } m_encoder->setTransform(m_mtxStack[m_mtxStackCurrent].mtx); - bgfx::ProgramHandle program = m_program[wireframe ? Program::FillMesh : Program::FillLitMesh]; + bgfx::ProgramHandle program = s_dds.m_program[wireframe ? Program::FillMesh : Program::FillLitMesh]; m_encoder->submit(m_viewId, program); } @@ -1460,7 +1558,7 @@ struct DebugDraw setUParams(attrib, wireframe); m_encoder->setTransform(m_mtxStack[m_mtxStackCurrent].mtx); - bgfx::ProgramHandle program = m_program[wireframe ? Program::FillMesh : Program::FillLitMesh]; + bgfx::ProgramHandle program = s_dds.m_program[wireframe ? Program::FillMesh : Program::FillLitMesh]; m_encoder->submit(m_viewId, program); } } @@ -1691,7 +1789,7 @@ struct DebugDraw bx::vec3TangentFrame(_normal, udir, vdir, attrib.m_spin); - const Pack2D& pack = m_sprite.get(_handle); + const Pack2D& pack = s_dds.m_sprite.get(_handle); const float invTextureSize = 1.0f/SPRITE_TEXTURE_SIZE; const float us = pack.m_x * invTextureSize; const float vs = pack.m_y * invTextureSize; @@ -2025,72 +2123,15 @@ struct DebugDraw pop(); } -private: - struct Mesh - { - enum Enum - { - Sphere0, - Sphere1, - Sphere2, - Sphere3, - - Cone0, - Cone1, - Cone2, - Cone3, - - Cylinder0, - Cylinder1, - Cylinder2, - Cylinder3, - - Capsule0, - Capsule1, - Capsule2, - Capsule3, - - Cube, - - Count, - - SphereMaxLod = Sphere3 - Sphere0, - ConeMaxLod = Cone3 - Cone0, - CylinderMaxLod = Cylinder3 - Cylinder0, - CapsuleMaxLod = Capsule3 - Capsule0, - }; - - uint32_t m_startVertex; - uint32_t m_numVertices; - uint32_t m_startIndex[2]; - uint32_t m_numIndices[2]; - }; - - struct Program - { - enum Enum - { - Lines, - LinesStipple, - Fill, - FillMesh, - FillLit, - FillLitMesh, - FillTexture, - - Count - }; - }; - void draw(Mesh::Enum _mesh, const float* _mtx, uint16_t _num, bool _wireframe) { pushTransform(_mtx, _num); - const Mesh& mesh = m_mesh[_mesh]; + const Mesh& mesh = s_dds.m_mesh[_mesh]; if (0 != mesh.m_numIndices[_wireframe]) { - m_encoder->setIndexBuffer(m_ibh + m_encoder->setIndexBuffer(s_dds.m_ibh , mesh.m_startIndex[_wireframe] , mesh.m_numIndices[_wireframe] ); @@ -2102,8 +2143,8 @@ private: MatrixStack& stack = m_mtxStack[m_mtxStackCurrent]; m_encoder->setTransform(stack.mtx, stack.num); - m_encoder->setVertexBuffer(0, m_vbh, mesh.m_startVertex, mesh.m_numVertices); - m_encoder->submit(m_viewId, m_program[_wireframe ? Program::Fill : Program::FillLit]); + m_encoder->setVertexBuffer(0, s_dds.m_vbh, mesh.m_startVertex, mesh.m_numVertices); + m_encoder->submit(m_viewId, s_dds.m_program[_wireframe ? Program::Fill : Program::FillLit]); popTransform(); } @@ -2142,7 +2183,7 @@ private: | BGFX_STATE_BLEND_ALPHA ); m_encoder->setTransform(m_mtxStack[m_mtxStackCurrent].mtx); - bgfx::ProgramHandle program = m_program[attrib.m_stipple ? 1 : 0]; + bgfx::ProgramHandle program = s_dds.m_program[attrib.m_stipple ? 1 : 0]; m_encoder->submit(m_viewId, program); } @@ -2187,8 +2228,8 @@ private: | (attrib.m_state & ~BGFX_STATE_CULL_MASK) ); m_encoder->setTransform(m_mtxStack[m_mtxStackCurrent].mtx); - m_encoder->setTexture(0, s_texColor, m_texture); - m_encoder->submit(m_viewId, m_program[Program::FillTexture]); + m_encoder->setTexture(0, s_dds.s_texColor, s_dds.m_texture); + m_encoder->submit(m_viewId, s_dds.m_program[Program::FillTexture]); } m_posQuad = 0; @@ -2207,19 +2248,18 @@ private: }; }; - static const uint32_t cacheSize = 1024; - static const uint32_t stackSize = 16; - BX_STATIC_ASSERT(cacheSize >= 3, "Cache must be at least 3 elements."); - DebugVertex m_cache[cacheSize+1]; - uint16_t m_indices[cacheSize*2]; + static const uint32_t kCacheSize = 1024; + static const uint32_t kStackSize = 16; + static const uint32_t kCacheQuadSize = 1024; + BX_STATIC_ASSERT(kCacheSize >= 3, "Cache must be at least 3 elements."); + + DebugVertex m_cache[kCacheSize+1]; + DebugUvVertex m_cacheQuad[kCacheQuadSize]; + uint16_t m_indices[kCacheSize*2]; uint16_t m_pos; + uint16_t m_posQuad; uint16_t m_indexPos; uint16_t m_vertexPos; - - static const uint32_t cacheQuadSize = 1024; - DebugUvVertex m_cacheQuad[cacheQuadSize]; - uint16_t m_posQuad; - uint32_t m_mtxStackCurrent; struct MatrixStack @@ -2242,265 +2282,467 @@ private: uint8_t m_stack; bool m_depthTestLess; - Attrib m_attrib[stackSize]; + Attrib m_attrib[kStackSize]; State::Enum m_state; - Mesh m_mesh[Mesh::Count]; - - typedef SpriteT<256, SPRITE_TEXTURE_SIZE> Sprite; - Sprite m_sprite; - - typedef GeometryT<256> Geometry; - Geometry m_geometry; - bgfx::Encoder* m_encoder; bgfx::Encoder* m_defaultEncoder; - - bgfx::UniformHandle s_texColor; - bgfx::TextureHandle m_texture; - bgfx::ProgramHandle m_program[Program::Count]; - bgfx::UniformHandle u_params; - - bgfx::VertexBufferHandle m_vbh; - bgfx::IndexBufferHandle m_ibh; - - bx::AllocatorI* m_allocator; }; -static DebugDraw s_dd; +static DebugDrawEncoderImpl s_dde; +BX_STATIC_ASSERT(sizeof(DebugDrawEncoderImpl) <= sizeof(DebugDrawEncoder), "Size must match"); void ddInit(bool _depthTestLess, bx::AllocatorI* _allocator) { - s_dd.init(_depthTestLess, _allocator); + s_dds.init(_allocator); + s_dde.init(_depthTestLess, bgfx::begin() ); } void ddShutdown() { - s_dd.shutdown(); + s_dde.shutdown(); + s_dds.shutdown(); } SpriteHandle ddCreateSprite(uint16_t _width, uint16_t _height, const void* _data) { - return s_dd.createSprite(_width, _height, _data); + return s_dds.createSprite(_width, _height, _data); } void ddDestroy(SpriteHandle _handle) { - s_dd.destroy(_handle); + s_dds.destroy(_handle); } GeometryHandle ddCreateGeometry(uint32_t _numVertices, const DdVertex* _vertices, uint32_t _numIndices, const uint16_t* _indices) { - return s_dd.createGeometry(_numVertices, _vertices, _numIndices, _indices); + return s_dds.createGeometry(_numVertices, _vertices, _numIndices, _indices); } void ddDestroy(GeometryHandle _handle) { - s_dd.destroy(_handle); + s_dds.destroy(_handle); } void ddBegin(uint16_t _viewId, bgfx::Encoder* _encoder) { - s_dd.begin(_viewId, _encoder); + s_dde.begin(_viewId, _encoder); } void ddEnd() { - s_dd.end(); + s_dde.end(); } void ddPush() { - s_dd.push(); + s_dde.push(); } void ddPop() { - s_dd.pop(); + s_dde.pop(); } void ddSetState(bool _depthTest, bool _depthWrite, bool _clockwise) { - s_dd.setState(_depthTest, _depthWrite, _clockwise); + s_dde.setState(_depthTest, _depthWrite, _clockwise); } void ddSetColor(uint32_t _abgr) { - s_dd.setColor(_abgr); + s_dde.setColor(_abgr); } void ddSetLod(uint8_t _lod) { - s_dd.setLod(_lod); + s_dde.setLod(_lod); } void ddSetWireframe(bool _wireframe) { - s_dd.setWireframe(_wireframe); + s_dde.setWireframe(_wireframe); } void ddSetStipple(bool _stipple, float _scale, float _offset) { - s_dd.setStipple(_stipple, _scale, _offset); + s_dde.setStipple(_stipple, _scale, _offset); } void ddSetSpin(float _spin) { - s_dd.setSpin(_spin); + s_dde.setSpin(_spin); } void ddSetTransform(const void* _mtx) { - s_dd.setTransform(_mtx); + s_dde.setTransform(_mtx); } void ddSetTranslate(float _x, float _y, float _z) { - s_dd.setTranslate(_x, _y, _z); + s_dde.setTranslate(_x, _y, _z); } void ddMoveTo(float _x, float _y, float _z) { - s_dd.moveTo(_x, _y, _z); + s_dde.moveTo(_x, _y, _z); } void ddMoveTo(const void* _pos) { - s_dd.moveTo(_pos); + s_dde.moveTo(_pos); } void ddLineTo(float _x, float _y, float _z) { - s_dd.lineTo(_x, _y, _z); + s_dde.lineTo(_x, _y, _z); } void ddLineTo(const void* _pos) { - s_dd.lineTo(_pos); + s_dde.lineTo(_pos); } void ddClose() { - s_dd.close(); + s_dde.close(); } void ddDraw(const Aabb& _aabb) { - s_dd.draw(_aabb); + s_dde.draw(_aabb); } void ddDraw(const Cylinder& _cylinder) { - s_dd.draw(_cylinder, false); + s_dde.draw(_cylinder, false); } void ddDraw(const Capsule& _capsule) { - s_dd.draw( *( (const Cylinder*)&_capsule), true); + s_dde.draw(*( (const Cylinder*)&_capsule), true); } void ddDraw(const Disk& _disk) { - s_dd.draw(_disk); + s_dde.draw(_disk); } void ddDraw(const Obb& _obb) { - s_dd.draw(_obb); + s_dde.draw(_obb); } void ddDraw(const Sphere& _sphere) { - s_dd.draw(_sphere); + s_dde.draw(_sphere); } void ddDraw(const Cone& _cone) { - ddDrawCone(_cone.m_pos, _cone.m_end, _cone.m_radius); + s_dde.drawCone(_cone.m_pos, _cone.m_end, _cone.m_radius); } void ddDraw(GeometryHandle _handle) { - s_dd.draw(_handle); + s_dde.draw(_handle); } void ddDrawLineList(uint32_t _numVertices, const DdVertex* _vertices, uint32_t _numIndices, const uint16_t* _indices) { - s_dd.draw(true, _numVertices, _vertices, _numIndices, _indices); + s_dde.draw(true, _numVertices, _vertices, _numIndices, _indices); } void ddDrawTriList(uint32_t _numVertices, const DdVertex* _vertices, uint32_t _numIndices, const uint16_t* _indices) { - s_dd.draw(false, _numVertices, _vertices, _numIndices, _indices); + s_dde.draw(false, _numVertices, _vertices, _numIndices, _indices); } void ddDrawFrustum(const void* _viewProj) { - s_dd.drawFrustum(_viewProj); + s_dde.drawFrustum(_viewProj); } void ddDrawArc(Axis::Enum _axis, float _x, float _y, float _z, float _radius, float _degrees) { - s_dd.drawArc(_axis, _x, _y, _z, _radius, _degrees); + s_dde.drawArc(_axis, _x, _y, _z, _radius, _degrees); } void ddDrawCircle(const void* _normal, const void* _center, float _radius, float _weight) { - s_dd.drawCircle(_normal, _center, _radius, _weight); + s_dde.drawCircle(_normal, _center, _radius, _weight); } void ddDrawCircle(Axis::Enum _axis, float _x, float _y, float _z, float _radius, float _weight) { - s_dd.drawCircle(_axis, _x, _y, _z, _radius, _weight); + s_dde.drawCircle(_axis, _x, _y, _z, _radius, _weight); } void ddDrawQuad(const float* _normal, const float* _center, float _size) { - s_dd.drawQuad(_normal, _center, _size); + s_dde.drawQuad(_normal, _center, _size); } void ddDrawQuad(SpriteHandle _handle, const float* _normal, const float* _center, float _size) { - s_dd.drawQuad(_handle, _normal, _center, _size); + s_dde.drawQuad(_handle, _normal, _center, _size); } void ddDrawQuad(bgfx::TextureHandle _handle, const float* _normal, const float* _center, float _size) { - s_dd.drawQuad(_handle, _normal, _center, _size); + s_dde.drawQuad(_handle, _normal, _center, _size); } void ddDrawCone(const void* _from, const void* _to, float _radius) { - s_dd.drawCone(_from, _to, _radius); + s_dde.drawCone(_from, _to, _radius); } void ddDrawCylinder(const void* _from, const void* _to, float _radius) { - s_dd.drawCylinder(_from, _to, _radius, false); + s_dde.drawCylinder(_from, _to, _radius, false); } void ddDrawCapsule(const void* _from, const void* _to, float _radius) { - s_dd.drawCylinder(_from, _to, _radius, true); + s_dde.drawCylinder(_from, _to, _radius, true); } void ddDrawAxis(float _x, float _y, float _z, float _len, Axis::Enum _hightlight, float _thickness) { - s_dd.drawAxis(_x, _y, _z, _len, _hightlight, _thickness); + s_dde.drawAxis(_x, _y, _z, _len, _hightlight, _thickness); } void ddDrawGrid(const void* _normal, const void* _center, uint32_t _size, float _step) { - s_dd.drawGrid(_normal, _center, _size, _step); + s_dde.drawGrid(_normal, _center, _size, _step); } void ddDrawGrid(Axis::Enum _axis, const void* _center, uint32_t _size, float _step) { - s_dd.drawGrid(_axis, _center, _size, _step); + s_dde.drawGrid(_axis, _center, _size, _step); } void ddDrawOrb(float _x, float _y, float _z, float _radius, Axis::Enum _hightlight) { - s_dd.drawOrb(_x, _y, _z, _radius, _hightlight); + s_dde.drawOrb(_x, _y, _z, _radius, _hightlight); +} + +#define DEBUG_DRAW_ENCODER(_func) reinterpret_cast(this)->_func + +DebugDrawEncoder::DebugDrawEncoder() +{ + DEBUG_DRAW_ENCODER(init(true, s_dde.m_defaultEncoder) ); +} + +DebugDrawEncoder::~DebugDrawEncoder() +{ + DEBUG_DRAW_ENCODER(shutdown() ); +} + +void DebugDrawEncoder::begin(uint16_t _viewId, bgfx::Encoder* _encoder) +{ + DEBUG_DRAW_ENCODER(begin(_viewId, _encoder) ); +} + +void DebugDrawEncoder::end() +{ + DEBUG_DRAW_ENCODER(end() ); +} + +void DebugDrawEncoder::push() +{ + DEBUG_DRAW_ENCODER(push() ); +} + +void DebugDrawEncoder::pop() +{ + DEBUG_DRAW_ENCODER(pop() ); +} + +void DebugDrawEncoder::setState(bool _depthTest, bool _depthWrite, bool _clockwise) +{ + DEBUG_DRAW_ENCODER(setState(_depthTest, _depthWrite, _clockwise) ); +} + +void DebugDrawEncoder::setColor(uint32_t _abgr) +{ + DEBUG_DRAW_ENCODER(setColor(_abgr) ); +} + +void DebugDrawEncoder::setLod(uint8_t _lod) +{ + DEBUG_DRAW_ENCODER(setLod(_lod) ); +} + +void DebugDrawEncoder::setWireframe(bool _wireframe) +{ + DEBUG_DRAW_ENCODER(setWireframe(_wireframe) ); +} + +void DebugDrawEncoder::setStipple(bool _stipple, float _scale, float _offset) +{ + DEBUG_DRAW_ENCODER(setStipple(_stipple, _scale, _offset) ); +} + +void DebugDrawEncoder::setSpin(float _spin) +{ + DEBUG_DRAW_ENCODER(setSpin(_spin) ); +} + +void DebugDrawEncoder::setTransform(const void* _mtx) +{ + DEBUG_DRAW_ENCODER(setTransform(_mtx) ); +} + +void DebugDrawEncoder::setTranslate(float _x, float _y, float _z) +{ + DEBUG_DRAW_ENCODER(setTranslate(_x, _y, _z) ); +} + +void DebugDrawEncoder::moveTo(float _x, float _y, float _z) +{ + DEBUG_DRAW_ENCODER(moveTo(_x, _y, _z) ); +} + +void DebugDrawEncoder::moveTo(const void* _pos) +{ + DEBUG_DRAW_ENCODER(moveTo(_pos) ); +} + +void DebugDrawEncoder::lineTo(float _x, float _y, float _z) +{ + DEBUG_DRAW_ENCODER(lineTo(_x, _y, _z) ); +} + +void DebugDrawEncoder::lineTo(const void* _pos) +{ + DEBUG_DRAW_ENCODER(lineTo(_pos) ); +} + +void DebugDrawEncoder::close() +{ + DEBUG_DRAW_ENCODER(close() ); +} + +void DebugDrawEncoder::draw(const Aabb& _aabb) +{ + DEBUG_DRAW_ENCODER(draw(_aabb) ); +} + +void DebugDrawEncoder::draw(const Cylinder& _cylinder) +{ + DEBUG_DRAW_ENCODER(draw(_cylinder, false) ); +} + +void DebugDrawEncoder::draw(const Capsule& _capsule) +{ + DEBUG_DRAW_ENCODER(draw(*( (const Cylinder*)&_capsule), true) ); +} + +void DebugDrawEncoder::draw(const Disk& _disk) +{ + DEBUG_DRAW_ENCODER(draw(_disk) ); +} + +void DebugDrawEncoder::draw(const Obb& _obb) +{ + DEBUG_DRAW_ENCODER(draw(_obb) ); +} + +void DebugDrawEncoder::draw(const Sphere& _sphere) +{ + DEBUG_DRAW_ENCODER(draw(_sphere) ); +} + +void DebugDrawEncoder::draw(const Cone& _cone) +{ + DEBUG_DRAW_ENCODER(drawCone(_cone.m_pos, _cone.m_end, _cone.m_radius) ); +} + +void DebugDrawEncoder::draw(GeometryHandle _handle) +{ + DEBUG_DRAW_ENCODER(draw(_handle) ); +} + +void DebugDrawEncoder::drawLineList(uint32_t _numVertices, const DdVertex* _vertices, uint32_t _numIndices, const uint16_t* _indices) +{ + DEBUG_DRAW_ENCODER(draw(true, _numVertices, _vertices, _numIndices, _indices) ); +} + +void DebugDrawEncoder::drawTriList(uint32_t _numVertices, const DdVertex* _vertices, uint32_t _numIndices, const uint16_t* _indices) +{ + DEBUG_DRAW_ENCODER(draw(false, _numVertices, _vertices, _numIndices, _indices) ); +} + +void DebugDrawEncoder::drawFrustum(const void* _viewProj) +{ + DEBUG_DRAW_ENCODER(drawFrustum(_viewProj) ); +} + +void DebugDrawEncoder::drawArc(Axis::Enum _axis, float _x, float _y, float _z, float _radius, float _degrees) +{ + DEBUG_DRAW_ENCODER(drawArc(_axis, _x, _y, _z, _radius, _degrees) ); +} + +void DebugDrawEncoder::drawCircle(const void* _normal, const void* _center, float _radius, float _weight) +{ + DEBUG_DRAW_ENCODER(drawCircle(_normal, _center, _radius, _weight) ); +} + +void DebugDrawEncoder::drawCircle(Axis::Enum _axis, float _x, float _y, float _z, float _radius, float _weight) +{ + DEBUG_DRAW_ENCODER(drawCircle(_axis, _x, _y, _z, _radius, _weight) ); +} + +void DebugDrawEncoder::drawQuad(const float* _normal, const float* _center, float _size) +{ + DEBUG_DRAW_ENCODER(drawQuad(_normal, _center, _size) ); +} + +void DebugDrawEncoder::drawQuad(SpriteHandle _handle, const float* _normal, const float* _center, float _size) +{ + DEBUG_DRAW_ENCODER(drawQuad(_handle, _normal, _center, _size) ); +} + +void DebugDrawEncoder::drawQuad(bgfx::TextureHandle _handle, const float* _normal, const float* _center, float _size) +{ + DEBUG_DRAW_ENCODER(drawQuad(_handle, _normal, _center, _size) ); +} + +void DebugDrawEncoder::drawCone(const void* _from, const void* _to, float _radius) +{ + DEBUG_DRAW_ENCODER(drawCone(_from, _to, _radius) ); +} + +void DebugDrawEncoder::drawCylinder(const void* _from, const void* _to, float _radius) +{ + DEBUG_DRAW_ENCODER(drawCylinder(_from, _to, _radius, false) ); +} + +void DebugDrawEncoder::drawCapsule(const void* _from, const void* _to, float _radius) +{ + DEBUG_DRAW_ENCODER(drawCylinder(_from, _to, _radius, true) ); +} + +void DebugDrawEncoder::drawAxis(float _x, float _y, float _z, float _len, Axis::Enum _highlight, float _thickness) +{ + DEBUG_DRAW_ENCODER(drawAxis(_x, _y, _z, _len, _highlight, _thickness) ); +} + +void DebugDrawEncoder::drawGrid(const void* _normal, const void* _center, uint32_t _size, float _step) +{ + DEBUG_DRAW_ENCODER(drawGrid(_normal, _center, _size, _step) ); +} + +void DebugDrawEncoder::drawGrid(Axis::Enum _axis, const void* _center, uint32_t _size, float _step) +{ + DEBUG_DRAW_ENCODER(drawGrid(_axis, _center, _size, _step) ); +} + +void DebugDrawEncoder::drawOrb(float _x, float _y, float _z, float _radius, Axis::Enum _highlight) +{ + DEBUG_DRAW_ENCODER(drawOrb(_x, _y, _z, _radius, _highlight) ); } diff --git a/examples/common/debugdraw/debugdraw.h b/examples/common/debugdraw/debugdraw.h index bdd6cee78..6b73efc96 100644 --- a/examples/common/debugdraw/debugdraw.h +++ b/examples/common/debugdraw/debugdraw.h @@ -50,6 +50,141 @@ GeometryHandle ddCreateGeometry(uint32_t _numVertices, const DdVertex* _vertices /// void ddDestroy(GeometryHandle _handle); + +struct DebugDrawEncoder +{ + /// + DebugDrawEncoder(); + + /// + ~DebugDrawEncoder(); + + /// + void begin(uint16_t _viewId, bgfx::Encoder* _encoder = NULL); + + /// + void end(); + + /// + void push(); + + /// + void pop(); + + /// + void setState(bool _depthTest, bool _depthWrite, bool _clockwise); + + /// + void setColor(uint32_t _abgr); + + /// + void setLod(uint8_t _lod); + + /// + void setWireframe(bool _wireframe); + + /// + void setStipple(bool _stipple, float _scale = 1.0f, float _offset = 0.0f); + + /// + void setSpin(float _spin); + + /// + void setTransform(const void* _mtx); + + /// + void setTranslate(float _x, float _y, float _z); + + /// + void moveTo(float _x, float _y, float _z = 0.0f); + + /// + void moveTo(const void* _pos); + + /// + void lineTo(float _x, float _y, float _z = 0.0f); + + /// + void lineTo(const void* _pos); + + /// + void close(); + + /// + void draw(const Aabb& _aabb); + + /// + void draw(const Cylinder& _cylinder); + + /// + void draw(const Capsule& _capsule); + + /// + void draw(const Disk& _disk); + + /// + void draw(const Obb& _obb); + + /// + void draw(const Sphere& _sphere); + + /// + void draw(const Cone& _cone); + + /// + void draw(GeometryHandle _handle); + + /// + void drawLineList(uint32_t _numVertices, const DdVertex* _vertices, uint32_t _numIndices = 0, const uint16_t* _indices = NULL); + + /// + void drawTriList(uint32_t _numVertices, const DdVertex* _vertices, uint32_t _numIndices = 0, const uint16_t* _indices = NULL); + + /// + void drawFrustum(const void* _viewProj); + + /// + void drawArc(Axis::Enum _axis, float _x, float _y, float _z, float _radius, float _degrees); + + /// + void drawCircle(const void* _normal, const void* _center, float _radius, float _weight = 0.0f); + + /// + void drawCircle(Axis::Enum _axis, float _x, float _y, float _z, float _radius, float _weight = 0.0f); + + /// + void drawQuad(const float* _normal, const float* _center, float _size); + + /// + void drawQuad(SpriteHandle _handle, const float* _normal, const float* _center, float _size); + + /// + void drawQuad(bgfx::TextureHandle _handle, const float* _normal, const float* _center, float _size); + + /// + void drawCone(const void* _from, const void* _to, float _radius); + + /// + void drawCylinder(const void* _from, const void* _to, float _radius); + + /// + void drawCapsule(const void* _from, const void* _to, float _radius); + + /// + void drawAxis(float _x, float _y, float _z, float _len = 1.0f, Axis::Enum _highlight = Axis::Count, float _thickness = 0.0f); + + /// + void drawGrid(const void* _normal, const void* _center, uint32_t _size = 20, float _step = 1.0f); + + /// + void drawGrid(Axis::Enum _axis, const void* _center, uint32_t _size = 20, float _step = 1.0f); + + /// + void drawOrb(float _x, float _y, float _z, float _radius, Axis::Enum _highlight = Axis::Count); + + BX_ALIGN_DECL_CACHE_LINE(uint8_t) m_internal[50<<10]; +}; + /// void ddBegin(uint16_t _viewId, bgfx::Encoder* _encoder = NULL);