565 lines
13 KiB
C++
565 lines
13 KiB
C++
/*
|
|
* Copyright 2016 Dario Manesku. All rights reserved.
|
|
* License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause
|
|
*/
|
|
|
|
#include "common.h"
|
|
#include "bgfx_utils.h"
|
|
#include "imgui/imgui.h"
|
|
|
|
class Wireframe : public entry::AppI
|
|
{
|
|
struct DrawMode
|
|
{
|
|
enum
|
|
{
|
|
WireframeShaded,
|
|
Wireframe,
|
|
Shaded,
|
|
};
|
|
};
|
|
|
|
struct Camera
|
|
{
|
|
Camera()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
m_target.curr[0] = 0.0f;
|
|
m_target.curr[1] = 0.0f;
|
|
m_target.curr[2] = 0.0f;
|
|
m_target.dest[0] = 0.0f;
|
|
m_target.dest[1] = 0.0f;
|
|
m_target.dest[2] = 0.0f;
|
|
|
|
m_pos.curr[0] = 0.0f;
|
|
m_pos.curr[1] = 0.0f;
|
|
m_pos.curr[2] = -2.0f;
|
|
m_pos.dest[0] = 0.0f;
|
|
m_pos.dest[1] = 0.0f;
|
|
m_pos.dest[2] = -2.0f;
|
|
|
|
m_orbit[0] = 0.0f;
|
|
m_orbit[1] = 0.0f;
|
|
}
|
|
|
|
void mtxLookAt(float* _outViewMtx)
|
|
{
|
|
bx::mtxLookAt(_outViewMtx, m_pos.curr, m_target.curr);
|
|
}
|
|
|
|
void orbit(float _dx, float _dy)
|
|
{
|
|
m_orbit[0] += _dx;
|
|
m_orbit[1] += _dy;
|
|
}
|
|
|
|
void dolly(float _dz)
|
|
{
|
|
const float cnear = 0.01f;
|
|
const float cfar = 10.0f;
|
|
|
|
const float toTarget[3] =
|
|
{
|
|
m_target.dest[0] - m_pos.dest[0],
|
|
m_target.dest[1] - m_pos.dest[1],
|
|
m_target.dest[2] - m_pos.dest[2],
|
|
};
|
|
const float toTargetLen = bx::vec3Length(toTarget);
|
|
const float invToTargetLen = 1.0f/(toTargetLen+FLT_MIN);
|
|
const float toTargetNorm[3] =
|
|
{
|
|
toTarget[0]*invToTargetLen,
|
|
toTarget[1]*invToTargetLen,
|
|
toTarget[2]*invToTargetLen,
|
|
};
|
|
|
|
float delta = toTargetLen*_dz;
|
|
float newLen = toTargetLen + delta;
|
|
if ( (cnear < newLen || _dz < 0.0f)
|
|
&& (newLen < cfar || _dz > 0.0f) )
|
|
{
|
|
m_pos.dest[0] += toTargetNorm[0]*delta;
|
|
m_pos.dest[1] += toTargetNorm[1]*delta;
|
|
m_pos.dest[2] += toTargetNorm[2]*delta;
|
|
}
|
|
}
|
|
|
|
void consumeOrbit(float _amount)
|
|
{
|
|
float consume[2];
|
|
consume[0] = m_orbit[0]*_amount;
|
|
consume[1] = m_orbit[1]*_amount;
|
|
m_orbit[0] -= consume[0];
|
|
m_orbit[1] -= consume[1];
|
|
|
|
const float toPos[3] =
|
|
{
|
|
m_pos.curr[0] - m_target.curr[0],
|
|
m_pos.curr[1] - m_target.curr[1],
|
|
m_pos.curr[2] - m_target.curr[2],
|
|
};
|
|
const float toPosLen = bx::vec3Length(toPos);
|
|
const float invToPosLen = 1.0f/(toPosLen+FLT_MIN);
|
|
const float toPosNorm[3] =
|
|
{
|
|
toPos[0]*invToPosLen,
|
|
toPos[1]*invToPosLen,
|
|
toPos[2]*invToPosLen,
|
|
};
|
|
|
|
float ll[2];
|
|
latLongFromVec(ll[0], ll[1], toPosNorm);
|
|
ll[0] += consume[0];
|
|
ll[1] -= consume[1];
|
|
ll[1] = bx::fclamp(ll[1], 0.02f, 0.98f);
|
|
|
|
float tmp[3];
|
|
vecFromLatLong(tmp, ll[0], ll[1]);
|
|
|
|
float diff[3];
|
|
diff[0] = (tmp[0]-toPosNorm[0])*toPosLen;
|
|
diff[1] = (tmp[1]-toPosNorm[1])*toPosLen;
|
|
diff[2] = (tmp[2]-toPosNorm[2])*toPosLen;
|
|
|
|
m_pos.curr[0] += diff[0];
|
|
m_pos.curr[1] += diff[1];
|
|
m_pos.curr[2] += diff[2];
|
|
m_pos.dest[0] += diff[0];
|
|
m_pos.dest[1] += diff[1];
|
|
m_pos.dest[2] += diff[2];
|
|
}
|
|
|
|
void update(float _dt)
|
|
{
|
|
const float amount = bx::fmin(_dt/0.12f, 1.0f);
|
|
|
|
consumeOrbit(amount);
|
|
|
|
m_target.curr[0] = bx::flerp(m_target.curr[0], m_target.dest[0], amount);
|
|
m_target.curr[1] = bx::flerp(m_target.curr[1], m_target.dest[1], amount);
|
|
m_target.curr[2] = bx::flerp(m_target.curr[2], m_target.dest[2], amount);
|
|
m_pos.curr[0] = bx::flerp(m_pos.curr[0], m_pos.dest[0], amount);
|
|
m_pos.curr[1] = bx::flerp(m_pos.curr[1], m_pos.dest[1], amount);
|
|
m_pos.curr[2] = bx::flerp(m_pos.curr[2], m_pos.dest[2], amount);
|
|
}
|
|
|
|
static inline void vecFromLatLong(float _vec[3], float _u, float _v)
|
|
{
|
|
const float phi = _u * 2.0f*bx::pi;
|
|
const float theta = _v * bx::pi;
|
|
|
|
const float st = bx::fsin(theta);
|
|
const float sp = bx::fsin(phi);
|
|
const float ct = bx::fcos(theta);
|
|
const float cp = bx::fcos(phi);
|
|
|
|
_vec[0] = -st*sp;
|
|
_vec[1] = ct;
|
|
_vec[2] = -st*cp;
|
|
}
|
|
|
|
static inline void latLongFromVec(float& _u, float& _v, const float _vec[3])
|
|
{
|
|
const float phi = atan2f(_vec[0], _vec[2]);
|
|
const float theta = acosf(_vec[1]);
|
|
|
|
_u = (bx::pi + phi)*bx::invPi*0.5f;
|
|
_v = theta*bx::invPi;
|
|
}
|
|
|
|
struct Interp3f
|
|
{
|
|
float curr[3];
|
|
float dest[3];
|
|
};
|
|
|
|
Interp3f m_target;
|
|
Interp3f m_pos;
|
|
float m_orbit[2];
|
|
};
|
|
|
|
struct Mouse
|
|
{
|
|
Mouse()
|
|
{
|
|
m_dx = 0.0f;
|
|
m_dy = 0.0f;
|
|
m_prevMx = 0.0f;
|
|
m_prevMx = 0.0f;
|
|
m_scroll = 0;
|
|
m_scrollPrev = 0;
|
|
}
|
|
|
|
void update(float _mx, float _my, int32_t _mz, uint32_t _width, uint32_t _height)
|
|
{
|
|
const float widthf = float(int32_t(_width));
|
|
const float heightf = float(int32_t(_height));
|
|
|
|
// Delta movement.
|
|
m_dx = float(_mx - m_prevMx)/widthf;
|
|
m_dy = float(_my - m_prevMy)/heightf;
|
|
|
|
m_prevMx = _mx;
|
|
m_prevMy = _my;
|
|
|
|
// Scroll.
|
|
m_scroll = _mz - m_scrollPrev;
|
|
m_scrollPrev = _mz;
|
|
}
|
|
|
|
float m_dx; // Screen space.
|
|
float m_dy;
|
|
float m_prevMx;
|
|
float m_prevMy;
|
|
int32_t m_scroll;
|
|
int32_t m_scrollPrev;
|
|
};
|
|
|
|
struct MeshMtx
|
|
{
|
|
MeshMtx()
|
|
{
|
|
m_mesh = NULL;
|
|
}
|
|
|
|
void init(const char* _path
|
|
, float _scale = 1.0f
|
|
, float _rotX = 0.0f
|
|
, float _rotY = 0.0f
|
|
, float _rotZ = 0.0f
|
|
, float _transX = 0.0f
|
|
, float _transY = 0.0f
|
|
, float _transZ = 0.0f
|
|
)
|
|
{
|
|
m_mesh = meshLoad(_path);
|
|
bx::mtxSRT(m_mtx
|
|
, _scale
|
|
, _scale
|
|
, _scale
|
|
, _rotX
|
|
, _rotY
|
|
, _rotZ
|
|
, _transX
|
|
, _transY
|
|
, _transZ
|
|
);
|
|
}
|
|
|
|
void destroy()
|
|
{
|
|
if (NULL != m_mesh)
|
|
{
|
|
meshUnload(m_mesh);
|
|
}
|
|
}
|
|
|
|
Mesh* m_mesh;
|
|
float m_mtx[16];
|
|
};
|
|
|
|
struct Uniforms
|
|
{
|
|
enum { NumVec4 = 3 };
|
|
|
|
void init()
|
|
{
|
|
m_camPos[0] = 0.0f;
|
|
m_camPos[1] = 1.0f;
|
|
m_camPos[2] = -2.5f;
|
|
m_wfColor[0] = 1.0f;
|
|
m_wfColor[1] = 0.0f;
|
|
m_wfColor[2] = 0.0f;
|
|
m_wfOpacity = 0.7f;
|
|
m_drawEdges = 0.0f;
|
|
m_wfThickness = 1.5f;
|
|
|
|
u_params = bgfx::createUniform("u_params", bgfx::UniformType::Vec4, NumVec4);
|
|
}
|
|
|
|
void submit()
|
|
{
|
|
bgfx::setUniform(u_params, m_params, NumVec4);
|
|
}
|
|
|
|
void destroy()
|
|
{
|
|
bgfx::destroyUniform(u_params);
|
|
}
|
|
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
/*0*/struct { float m_camPos[3], m_unused0; };
|
|
/*1*/struct { float m_wfColor[3], m_wfOpacity; };
|
|
/*2*/struct { float m_drawEdges, m_wfThickness, m_unused2[2]; };
|
|
};
|
|
|
|
float m_params[NumVec4*4];
|
|
};
|
|
|
|
bgfx::UniformHandle u_params;
|
|
};
|
|
|
|
void init(int _argc, char** _argv) BX_OVERRIDE
|
|
{
|
|
Args args(_argc, _argv);
|
|
|
|
m_width = 1280;
|
|
m_height = 720;
|
|
m_debug = BGFX_DEBUG_TEXT;
|
|
m_reset = BGFX_RESET_VSYNC;
|
|
|
|
bgfx::init(args.m_type, args.m_pciId);
|
|
bgfx::reset(m_width, m_height, m_reset);
|
|
|
|
// 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_wfProgram = loadProgram("vs_wf_wireframe", "fs_wf_wireframe");
|
|
m_meshProgram = loadProgram("vs_wf_mesh", "fs_wf_mesh");
|
|
|
|
m_uniforms.init();
|
|
|
|
m_meshes[0].init("meshes/bunny.bin", 1.0f, 0.0f, bx::pi, 0.0f, 0.0f, -0.8f, 0.0f);
|
|
m_meshes[1].init("meshes/hollowcube.bin", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
|
|
m_meshes[2].init("meshes/orb.bin", 1.2f, 0.0f, 0.0f, 0.0f, 0.0f, -0.65f, 0.0f);
|
|
|
|
// Imgui.
|
|
imguiCreate();
|
|
|
|
m_oldWidth = 0;
|
|
m_oldHeight = 0;
|
|
m_oldReset = m_reset;
|
|
|
|
m_meshSelection = 1;
|
|
m_drawMode = DrawMode::WireframeShaded;
|
|
m_scrollArea = 0;
|
|
m_showWfColor = true;
|
|
}
|
|
|
|
virtual int shutdown() BX_OVERRIDE
|
|
{
|
|
// Cleanup.
|
|
imguiDestroy();
|
|
|
|
m_meshes[0].destroy();
|
|
m_meshes[1].destroy();
|
|
m_meshes[2].destroy();
|
|
|
|
bgfx::destroyProgram(m_wfProgram);
|
|
bgfx::destroyProgram(m_meshProgram);
|
|
|
|
m_uniforms.destroy();
|
|
|
|
// Shutdown bgfx.
|
|
bgfx::shutdown();
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool update() BX_OVERRIDE
|
|
{
|
|
if (!entry::processEvents(m_width, m_height, m_debug, m_reset, &m_mouseState) )
|
|
{
|
|
if (m_oldWidth != m_width
|
|
|| m_oldHeight != m_height
|
|
|| m_oldReset != m_reset)
|
|
{
|
|
// Recreate variable size render targets when resolution changes.
|
|
m_oldWidth = m_width;
|
|
m_oldHeight = m_height;
|
|
m_oldReset = m_reset;
|
|
}
|
|
|
|
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
|
|
, m_width
|
|
, m_height
|
|
);
|
|
|
|
imguiBeginScrollArea("Settings"
|
|
, m_width - m_width / 5 - 10
|
|
, 10
|
|
, m_width / 5
|
|
, 492
|
|
, &m_scrollArea
|
|
);
|
|
|
|
imguiSeparatorLine(1); imguiIndent(8); imguiLabel("Draw mode:"); imguiUnindent(8); imguiSeparatorLine(1);
|
|
imguiSeparator(4);
|
|
{
|
|
imguiIndent();
|
|
m_drawMode = imguiChoose(m_drawMode
|
|
, "Wireframe + Shaded"
|
|
, "Wireframe"
|
|
, "Shaded"
|
|
);
|
|
imguiUnindent();
|
|
}
|
|
imguiSeparator(8);
|
|
|
|
const bool wfEnabled = (DrawMode::Shaded != m_drawMode);
|
|
imguiSeparatorLine(1); imguiIndent(8); imguiLabel("Wireframe:", wfEnabled); imguiUnindent(8); imguiSeparatorLine(1);
|
|
imguiSeparator(4);
|
|
{
|
|
imguiColorWheel("Color", m_uniforms.m_wfColor, m_showWfColor, 0.6f, wfEnabled);
|
|
imguiIndent();
|
|
imguiSlider("Opacity", m_uniforms.m_wfOpacity, 0.1f, 1.0f, 0.1f, wfEnabled);
|
|
imguiSlider("Thickness", m_uniforms.m_wfThickness, 0.6f, 2.2f, 0.1f, wfEnabled);
|
|
imguiUnindent();
|
|
}
|
|
imguiSeparator(8);
|
|
|
|
imguiSeparatorLine(1); imguiIndent(8); imguiLabel("Mesh:"); imguiUnindent(8); imguiSeparatorLine(1);
|
|
imguiSeparator(4);
|
|
{
|
|
imguiIndent();
|
|
const uint32_t prevMeshSel = m_meshSelection;
|
|
m_meshSelection = imguiChoose(m_meshSelection
|
|
, "Bunny"
|
|
, "Orb"
|
|
, "Hollowcubes"
|
|
);
|
|
if (prevMeshSel != m_meshSelection)
|
|
{
|
|
m_camera.reset();
|
|
}
|
|
imguiUnindent();
|
|
}
|
|
imguiSeparator(8);
|
|
|
|
imguiEndScrollArea();
|
|
imguiEndFrame();
|
|
|
|
// This dummy draw call is here to make sure that view 0 is cleared
|
|
// if no other draw calls are submitted to view 0.
|
|
bgfx::touch(0);
|
|
|
|
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;
|
|
const double deltaTimeSec = double(frameTime)/freq;
|
|
|
|
// Use m_debug font to print information about this example.
|
|
bgfx::dbgTextClear();
|
|
bgfx::dbgTextPrintf(0, 1, 0x4f, "bgfx/examples/28-wirefame");
|
|
bgfx::dbgTextPrintf(0, 2, 0x6f, "Description: Drawing wireframe mesh.");
|
|
bgfx::dbgTextPrintf(0, 3, 0x0f, "Frame: % 7.3f[ms]", double(frameTime)*toMs);
|
|
|
|
// Setup view.
|
|
bgfx::setViewRect(0, 0, 0, bgfx::BackbufferRatio::Equal);
|
|
bgfx::setViewClear(0, BGFX_CLEAR_COLOR|BGFX_CLEAR_DEPTH, 0x303030ff, 1.0f, 0);
|
|
|
|
const bool mouseOverGui = imguiMouseOverArea();
|
|
m_mouse.update(m_mouseState.m_mx, m_mouseState.m_my, m_mouseState.m_mz, m_width, m_height);
|
|
if (!mouseOverGui)
|
|
{
|
|
if (m_mouseState.m_buttons[entry::MouseButton::Left])
|
|
{
|
|
m_camera.orbit(m_mouse.m_dx, m_mouse.m_dy);
|
|
}
|
|
else if (m_mouseState.m_buttons[entry::MouseButton::Right])
|
|
{
|
|
m_camera.dolly(m_mouse.m_dx + m_mouse.m_dy);
|
|
}
|
|
else if (0 != m_mouse.m_scroll)
|
|
{
|
|
m_camera.dolly(float(m_mouse.m_scroll)*0.1f);
|
|
}
|
|
}
|
|
|
|
float view[16];
|
|
float proj[16];
|
|
m_camera.update(deltaTimeSec);
|
|
memcpy(m_uniforms.m_camPos, m_camera.m_pos.curr, 3*sizeof(float));
|
|
m_camera.mtxLookAt(view);
|
|
bx::mtxProj(proj, 60.0f, float(m_width)/float(m_height), 0.1f, 100.0f);
|
|
bgfx::setViewTransform(0, view, proj);
|
|
|
|
m_uniforms.m_drawEdges = (DrawMode::WireframeShaded == m_drawMode) ? 1.0f : 0.0;
|
|
m_uniforms.submit();
|
|
|
|
if (DrawMode::Wireframe == m_drawMode)
|
|
{
|
|
uint64_t state = 0
|
|
| BGFX_STATE_RGB_WRITE
|
|
| BGFX_STATE_ALPHA_WRITE
|
|
| BGFX_STATE_DEPTH_WRITE
|
|
| BGFX_STATE_CULL_CCW
|
|
| BGFX_STATE_MSAA
|
|
| BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_ALPHA)
|
|
;
|
|
meshSubmit(m_meshes[m_meshSelection].m_mesh, 0, m_wfProgram, m_meshes[m_meshSelection].m_mtx, state);
|
|
}
|
|
else
|
|
{
|
|
uint64_t state = 0
|
|
| BGFX_STATE_RGB_WRITE
|
|
| BGFX_STATE_ALPHA_WRITE
|
|
| BGFX_STATE_DEPTH_TEST_LESS
|
|
| BGFX_STATE_DEPTH_WRITE
|
|
| BGFX_STATE_CULL_CCW
|
|
| BGFX_STATE_MSAA
|
|
;
|
|
meshSubmit(m_meshes[m_meshSelection].m_mesh, 0, m_meshProgram, m_meshes[m_meshSelection].m_mtx, state);
|
|
}
|
|
|
|
// Advance to next frame. Rendering thread will be kicked to
|
|
// process submitted rendering primitives.
|
|
bgfx::frame();
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
entry::MouseState m_mouseState;
|
|
|
|
bgfx::ProgramHandle m_wfProgram;
|
|
bgfx::ProgramHandle m_meshProgram;
|
|
|
|
uint32_t m_width;
|
|
uint32_t m_height;
|
|
uint32_t m_debug;
|
|
uint32_t m_reset;
|
|
uint32_t m_lumBgra8;
|
|
|
|
uint32_t m_oldWidth;
|
|
uint32_t m_oldHeight;
|
|
uint32_t m_oldReset;
|
|
|
|
Camera m_camera;
|
|
Mouse m_mouse;
|
|
Uniforms m_uniforms;
|
|
MeshMtx m_meshes[3];
|
|
uint32_t m_meshSelection;
|
|
uint32_t m_drawMode; // Holds data for 'DrawMode'.
|
|
|
|
bool m_showWfColor;
|
|
int32_t m_scrollArea;
|
|
};
|
|
|
|
ENTRY_IMPLEMENT_MAIN(Wireframe);
|