void ConvexVolumeTool::handleMenu()
{
imguiSlider("Shape Height", &m_boxHeight, 0.1f, 20.0f, 0.1f);
imguiSlider("Shape Descent", &m_boxDescent, 0.1f, 20.0f, 0.1f);
imguiSlider("Poly Offset", &m_polyOffset, 0.0f, 10.0f, 0.1f);
imguiSeparator();
imguiLabel("Area Type");
imguiIndent();
if (imguiCheck("Grass", m_areaType == SAMPLE_POLYAREA_GRASS))
m_areaType = SAMPLE_POLYAREA_GRASS;
if (imguiCheck("Road", m_areaType == SAMPLE_POLYAREA_ROAD))
m_areaType = SAMPLE_POLYAREA_ROAD;
if (imguiCheck("Water", m_areaType == SAMPLE_POLYAREA_WATER))
m_areaType = SAMPLE_POLYAREA_WATER;
if (imguiCheck("Door", m_areaType == SAMPLE_POLYAREA_DOOR))
m_areaType = SAMPLE_POLYAREA_DOOR;
imguiUnindent();
imguiSeparator();
if (imguiButton("Clear Shape"))
{
m_npts = 0;
m_nhull = 0;
}
}
void Sample_SoloMesh::handleSettings()
{
Sample::handleCommonSettings();
if (imguiCheck("Keep Itermediate Results", m_keepInterResults))
m_keepInterResults = !m_keepInterResults;
imguiSeparator();
imguiIndent();
imguiIndent();
if (imguiButton("Save"))
{
Sample::saveAll("solo_navmesh.bin", m_navMesh);
}
if (imguiButton("Load"))
{
dtFreeNavMesh(m_navMesh);
m_navMesh = Sample::loadAll("solo_navmesh.bin");
m_navQuery->init(m_navMesh, 2048);
}
imguiUnindent();
imguiUnindent();
char msg[64];
snprintf(msg, 64, "Build Time: %.1fms", m_totalBuildTimeMs);
imguiLabel(msg);
imguiSeparator();
}
void Sample::handleCommonSettings()
{
imguiLabel("Rasterization");
imguiSlider("Cell Size", &m_cellSize, 0.1f, 1.0f, 0.01f);
imguiSlider("Cell Height", &m_cellHeight, 0.1f, 1.0f, 0.01f);
if (m_geom)
{
const float* bmin = m_geom->getMeshBoundsMin();
const float* bmax = m_geom->getMeshBoundsMax();
int gw = 0, gh = 0;
rcCalcGridSize(bmin, bmax, m_cellSize, &gw, &gh);
char text[64];
snprintf(text, 64, "Voxels %d x %d", gw, gh);
imguiValue(text);
}
imguiSeparator();
imguiLabel("Agent");
imguiSlider("Height", &m_agentHeight, 0.1f, 5.0f, 0.1f);
imguiSlider("Radius", &m_agentRadius, 0.0f, 5.0f, 0.1f);
imguiSlider("Max Climb", &m_agentMaxClimb, 0.1f, 5.0f, 0.1f);
imguiSlider("Max Slope", &m_agentMaxSlope, 0.0f, 90.0f, 1.0f);
imguiSeparator();
imguiLabel("Region");
imguiSlider("Min Region Size", &m_regionMinSize, 0.0f, 150.0f, 1.0f);
imguiSlider("Merged Region Size", &m_regionMergeSize, 0.0f, 150.0f, 1.0f);
if (imguiCheck("Monotore Partitioning", m_monotonePartitioning))
m_monotonePartitioning = !m_monotonePartitioning;
imguiSeparator();
imguiLabel("Polygonization");
imguiSlider("Max Edge Length", &m_edgeMaxLen, 0.0f, 50.0f, 1.0f);
imguiSlider("Max Edge Error", &m_edgeMaxError, 0.1f, 3.0f, 0.1f);
imguiSlider("Verts Per Poly", &m_vertsPerPoly, 3.0f, 12.0f, 1.0f);
imguiSeparator();
imguiLabel("Detail Mesh");
imguiSlider("Sample Distance", &m_detailSampleDist, 0.0f, 16.0f, 1.0f);
imguiSlider("Max Sample Error", &m_detailSampleMaxError, 0.0f, 16.0f, 1.0f);
imguiSeparator();
}
virtual void handleMenu()
{
imguiLabel("Create Temp Obstacles");
if (imguiButton("Remove All"))
m_sample->clearAllTempObstacles();
imguiSeparator();
imguiValue("Click LMB to create an obstacle.");
imguiValue("Shift+LMB to remove an obstacle.");
}
void Sample_TempObstacles::handleDebugMode()
{
// Check which modes are valid.
bool valid[MAX_DRAWMODE];
for (int i = 0; i < MAX_DRAWMODE; ++i)
valid[i] = false;
if (m_geom)
{
valid[DRAWMODE_NAVMESH] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_TRANS] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_BVTREE] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_NODES] = m_navQuery != 0;
valid[DRAWMODE_NAVMESH_PORTALS] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_INVIS] = m_navMesh != 0;
valid[DRAWMODE_MESH] = true;
valid[DRAWMODE_CACHE_BOUNDS] = true;
}
int unavail = 0;
for (int i = 0; i < MAX_DRAWMODE; ++i)
if (!valid[i]) unavail++;
if (unavail == MAX_DRAWMODE)
return;
imguiLabel("Draw");
if (imguiCheck("Input Mesh", m_drawMode == DRAWMODE_MESH, valid[DRAWMODE_MESH]))
m_drawMode = DRAWMODE_MESH;
if (imguiCheck("Navmesh", m_drawMode == DRAWMODE_NAVMESH, valid[DRAWMODE_NAVMESH]))
m_drawMode = DRAWMODE_NAVMESH;
if (imguiCheck("Navmesh Invis", m_drawMode == DRAWMODE_NAVMESH_INVIS, valid[DRAWMODE_NAVMESH_INVIS]))
m_drawMode = DRAWMODE_NAVMESH_INVIS;
if (imguiCheck("Navmesh Trans", m_drawMode == DRAWMODE_NAVMESH_TRANS, valid[DRAWMODE_NAVMESH_TRANS]))
m_drawMode = DRAWMODE_NAVMESH_TRANS;
if (imguiCheck("Navmesh BVTree", m_drawMode == DRAWMODE_NAVMESH_BVTREE, valid[DRAWMODE_NAVMESH_BVTREE]))
m_drawMode = DRAWMODE_NAVMESH_BVTREE;
if (imguiCheck("Navmesh Nodes", m_drawMode == DRAWMODE_NAVMESH_NODES, valid[DRAWMODE_NAVMESH_NODES]))
m_drawMode = DRAWMODE_NAVMESH_NODES;
if (imguiCheck("Navmesh Portals", m_drawMode == DRAWMODE_NAVMESH_PORTALS, valid[DRAWMODE_NAVMESH_PORTALS]))
m_drawMode = DRAWMODE_NAVMESH_PORTALS;
if (imguiCheck("Cache Bounds", m_drawMode == DRAWMODE_CACHE_BOUNDS, valid[DRAWMODE_CACHE_BOUNDS]))
m_drawMode = DRAWMODE_CACHE_BOUNDS;
if (unavail)
{
imguiValue("Tick 'Keep Itermediate Results'");
imguiValue("rebuild some tiles to see");
imguiValue("more debug mode options.");
}
}
virtual void handleMenu()
{
imguiLabel("Create Tiles");
if (imguiButton("Create All"))
{
if (m_sample)
m_sample->buildAllTiles();
}
if (imguiButton("Remove All"))
{
if (m_sample)
m_sample->removeAllTiles();
}
}
virtual void handleMenu()
{
imguiLabel("Highlight Tile Cache");
imguiValue("Click LMB to highlight a tile.");
imguiSeparator();
if (imguiCheck("Draw Areas", m_drawType == DRAWDETAIL_AREAS))
m_drawType = DRAWDETAIL_AREAS;
if (imguiCheck("Draw Regions", m_drawType == DRAWDETAIL_REGIONS))
m_drawType = DRAWDETAIL_REGIONS;
if (imguiCheck("Draw Contours", m_drawType == DRAWDETAIL_CONTOURS))
m_drawType = DRAWDETAIL_CONTOURS;
if (imguiCheck("Draw Mesh", m_drawType == DRAWDETAIL_MESH))
m_drawType = DRAWDETAIL_MESH;
}
void Sample_SoloMesh::handleSettings()
{
Sample::handleCommonSettings();
if (imguiCheck("Keep Itermediate Results", m_keepInterResults))
m_keepInterResults = !m_keepInterResults;
imguiSeparator();
char msg[64];
snprintf(msg, 64, "Build Time: %.1fms", m_totalBuildTimeMs);
imguiLabel(msg);
imguiSeparator();
}
virtual void handleMenu()
{
imguiLabel("Create Tiles");
if (imguiButton("Create All"))
{
if (m_sample)
m_sample->buildAllTiles();
}
if (imguiButton("Remove All"))
{
if (m_sample)
m_sample->removeAllTiles();
}
imguiValue("Click LMB to create a tile.");
imguiValue("Shift+LMB to remove a tile.");
}
void ConvexVolumeTool::handleMenu()
{
imguiSlider("Shape Height", &m_boxHeight, 0.1f, 20.0f, 0.1f);
imguiSlider("Shape Descent", &m_boxDescent, 0.1f, 20.0f, 0.1f);
imguiSeparator();
imguiLabel("Area Type");
imguiIndent();
if (imguiCheck("Grass", m_areaType == SAMPLE_POLYAREA_GRASS))
m_areaType = SAMPLE_POLYAREA_GRASS;
if (imguiCheck("Road", m_areaType == SAMPLE_POLYAREA_ROAD))
m_areaType = SAMPLE_POLYAREA_ROAD;
if (imguiCheck("Water", m_areaType == SAMPLE_POLYAREA_WATER))
m_areaType = SAMPLE_POLYAREA_WATER;
if (imguiCheck("Door", m_areaType == SAMPLE_POLYAREA_DOOR))
m_areaType = SAMPLE_POLYAREA_DOOR;
imguiUnindent();
imguiSeparator();
if (imguiButton("Clear Shape"))
{
m_npts = 0;
m_nhull = 0;
}
imguiSeparator();
imguiValue("Click to create points.");
imguiValue("The shape is convex hull");
imguiValue("of all the create points.");
imguiValue("Click on highlited point");
imguiValue("to finish the shape.");
imguiSeparator();
}
int _main_(int, char**)
{
uint32_t width = 800, height = 600;
uint32_t debug = BGFX_DEBUG_TEXT | BGFX_DEBUG_STATS;
uint32_t reset = BGFX_RESET_VSYNC | BGFX_RESET_MSAA_X8;
bool showStats = true;
bgfx::init();
bgfx::reset(width, height, reset);
bgfx::setDebug(debug);
size_t sz = 0;
void* fontdata = nullptr;
if(loadfile("assets/font/droidsans.ttf", fontdata, sz))
imguiCreate(fontdata, sz);
else
imguiCreate();
free(fontdata);
entry::MouseState mouseState;
float rgb[3] = {0.3f, 0.3f, 0.3f};
bool colorwheelActivated = false;
int32_t scrollArea = 0;
while(!entry::processEvents(width, height, debug, reset, &mouseState)) {
auto encodeColor = [&rgb]()->uint32_t{
return uint32_t(rgb[0]*255)<<24|uint32_t(rgb[1]*255)<<16|uint32_t(rgb[2]*255)<<8|0xff;
};
bgfx::setViewClear(0,
BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH,
encodeColor(), 1.0f, 0);
bgfx::setViewRect(0, 0, 0, width, height);
bgfx::submit(0, BGFX_INVALID_HANDLE);
bgfx::dbgTextPrintf(0, 1, 0x4f, "hello world");
bgfx::dbgTextPrintf(0, 2, 0x5f, "simple bgfx program");
imguiBeginFrame(mouseState.m_mx, mouseState.m_my,
(mouseState.m_buttons[entry::MouseButton::Left ] ? IMGUI_MBUT_LEFT : 0)
| (mouseState.m_buttons[entry::MouseButton::Right ] ? IMGUI_MBUT_RIGHT : 0)
, 0
, width
, height);
imguiBeginScrollArea("Test", width-350, 50, 330, 500, &scrollArea);
imguiSeparatorLine();
imguiLabel("foobar");
if(imguiButton("say hi"))
fprintf(stdout, "hi there\n");
imguiBool("show stats", showStats);
uint32_t newDebug = BGFX_DEBUG_TEXT | (showStats ? BGFX_DEBUG_STATS : 0);
if(newDebug != debug) {
debug = newDebug;
bgfx::setDebug(debug);
}
imguiColorWheel("bg color", rgb, colorwheelActivated);
ImGui::ColorEdit3("bg color", rgb);
imguiSeparatorLine();
if(imguiButton("quit"))
break;
imguiEndScrollArea();
imguiEndFrame();
bgfx::frame();
}
imguiDestroy();
bgfx::shutdown();
return 0;
}
int main( int argc, char **argv )
{
int width = 1024, height=768;
// Initialise GLFW
if( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
exit( EXIT_FAILURE );
}
// Open a window and create its OpenGL context
if( !glfwOpenWindow( width, height, 0,0,0,0, 24,0, GLFW_WINDOW ) )
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();
exit( EXIT_FAILURE );
}
glfwSetWindowTitle( "imgui sample imguiRenderGL2" );
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
exit( EXIT_FAILURE );
}
// Ensure we can capture the escape key being pressed below
glfwEnable( GLFW_STICKY_KEYS );
// Enable vertical sync (on cards that support it)
glfwSwapInterval( 1 );
// Init UI
if (!imguiRenderGLInit("DroidSans.ttf"))
{
fprintf(stderr, "Could not init GUI renderer.\n");
exit(EXIT_FAILURE);
}
glClearColor(0.8f, 0.8f, 0.8f, 1.f);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_DEPTH_TEST);
// imgui states
bool checked1 = false;
bool checked2 = false;
bool checked3 = true;
bool checked4 = false;
float value1 = 50.f;
float value2 = 30.f;
int scrollarea1 = 0;
int scrollarea2 = 0;
// glfw scrolling
int glfwscroll = 0;
do
{
glfwGetWindowSize(&width, &height);
glViewport(0, 0, width, height);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Mouse states
unsigned char mousebutton = 0;
int currentglfwscroll = glfwGetMouseWheel();
int mscroll = 0;
if (currentglfwscroll < glfwscroll)
mscroll = 2;
if (currentglfwscroll > glfwscroll)
mscroll = -2;
glfwscroll = currentglfwscroll;
int mousex; int mousey;
glfwGetMousePos(&mousex, &mousey);
mousey = height - mousey;
int leftButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_LEFT );
int rightButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_RIGHT );
int middleButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_MIDDLE );
int toggle = 0;
if( leftButton == GLFW_PRESS )
mousebutton |= IMGUI_MBUT_LEFT;
// Draw UI
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
float projection[16] = { 2.f/width, 0.f, 0.f, 0.f,
0.f, 2.f/height, 0.f, 0.f,
0.f, 0.f, -2.f, 0.f,
-1.f, -1.f, -1.f, 1.f };
glLoadMatrixf(projection);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glUseProgram(0);
imguiBeginFrame(mousex, mousey, mousebutton, mscroll);
imguiBeginScrollArea("Scroll area", 10, 10, width / 5, height - 20, &scrollarea1);
imguiSeparatorLine();
imguiSeparator();
imguiButton("Button");
imguiButton("Disabled button", false);
imguiItem("Item");
imguiItem("Disabled item", false);
toggle = imguiCheck("Checkbox", checked1);
if (toggle)
checked1 = !checked1;
toggle = imguiCheck("Disabled checkbox", checked2, false);
if (toggle)
checked2 = !checked2;
toggle = imguiCollapse("Collapse", "subtext", checked3);
if (checked3)
{
imguiIndent();
imguiLabel("Collapsible element");
imguiUnindent();
}
if (toggle)
checked3 = !checked3;
toggle = imguiCollapse("Disabled collapse", "subtext", checked4, false);
if (toggle)
checked4 = !checked4;
imguiLabel("Label");
imguiValue("Value");
imguiSlider("Slider", &value1, 0.f, 100.f, 1.f);
imguiSlider("Disabled slider", &value2, 0.f, 100.f, 1.f, false);
imguiIndent();
imguiLabel("Indented");
imguiUnindent();
imguiLabel("Unindented");
imguiEndScrollArea();
imguiBeginScrollArea("Scroll area", 20 + width / 5, 500, width / 5, height - 510, &scrollarea2);
imguiSeparatorLine();
imguiSeparator();
for (int i = 0; i < 100; ++i)
imguiLabel("A wall of text");
imguiEndScrollArea();
imguiEndFrame();
imguiDrawText(30 + width / 5 * 2, height - 20, IMGUI_ALIGN_LEFT, "Free text", imguiRGBA(32,192, 32,192));
imguiDrawText(30 + width / 5 * 2 + 100, height - 40, IMGUI_ALIGN_RIGHT, "Free text", imguiRGBA(32, 32, 192, 192));
imguiDrawText(30 + width / 5 * 2 + 50, height - 60, IMGUI_ALIGN_CENTER, "Free text", imguiRGBA(192, 32, 32,192));
imguiDrawLine(30 + width / 5 * 2, height - 80, 30 + width / 5 * 2 + 100, height - 60, 1.f, imguiRGBA(32,192, 32,192));
imguiDrawLine(30 + width / 5 * 2, height - 100, 30 + width / 5 * 2 + 100, height - 80, 2.f, imguiRGBA(32, 32, 192, 192));
imguiDrawLine(30 + width / 5 * 2, height - 120, 30 + width / 5 * 2 + 100, height - 100, 3.f, imguiRGBA(192, 32, 32,192));
imguiDrawRoundedRect(30 + width / 5 * 2, height - 240, 100, 100, 5.f, imguiRGBA(32,192, 32,192));
imguiDrawRoundedRect(30 + width / 5 * 2, height - 350, 100, 100, 10.f, imguiRGBA(32, 32, 192, 192));
imguiDrawRoundedRect(30 + width / 5 * 2, height - 470, 100, 100, 20.f, imguiRGBA(192, 32, 32,192));
imguiDrawRect(30 + width / 5 * 2, height - 590, 100, 100, imguiRGBA(32, 192, 32, 192));
imguiDrawRect(30 + width / 5 * 2, height - 710, 100, 100, imguiRGBA(32, 32, 192, 192));
imguiDrawRect(30 + width / 5 * 2, height - 830, 100, 100, imguiRGBA(192, 32, 32,192));
imguiRenderGLDraw(width, height);
// Check for errors
GLenum err = glGetError();
if(err != GL_NO_ERROR)
{
fprintf(stderr, "OpenGL Error : %s\n", gluErrorString(err));
}
// Swap buffers
glfwSwapBuffers();
} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
glfwGetWindowParam( GLFW_OPENED ) );
// Clean UI
imguiRenderGLDestroy();
// Close OpenGL window and terminate GLFW
glfwTerminate();
exit( EXIT_SUCCESS );
}
void Sample::handleCommonSettings()
{
if (imguiCheck("TrinityCore Configs", m_trinityCoreValues))
{
m_trinityCoreValues = !m_trinityCoreValues;
if (m_trinityCoreValues)
{
m_cellSize = 0.2666666f;
m_cellHeight = 0.2666666f;
m_agentHeight = 6 * m_cellSize;
m_agentRadius = 2 * m_cellSize;
m_agentMaxClimb = 8 * m_cellSize;
m_agentMaxSlope = 70.0f;
m_regionMinSize = 60;
m_regionMergeSize = 50;
m_edgeMaxLen = 81.0f;
m_edgeMaxError = 1.8f;
m_vertsPerPoly = 6.0f;
m_detailSampleDist = 64;
m_detailSampleMaxError = 2.0f;
m_partitionType = SAMPLE_PARTITION_WATERSHED;
}
else
resetCommonSettings();
m_ctx->log(RC_LOG_WARNING, "Reload the mesh to update the Bounding Box");
}
imguiLabel("Rasterization");
imguiSlider("Cell Size", &m_cellSize, 0.1f, 1.0f, 0.01f);
imguiSlider("Cell Height", &m_cellHeight, 0.1f, 1.0f, 0.01f);
if (m_geom)
{
const float* bmin = m_geom->getNavMeshBoundsMin();
const float* bmax = m_geom->getNavMeshBoundsMax();
int gw = 0, gh = 0;
rcCalcGridSize(bmin, bmax, m_cellSize, &gw, &gh);
char text[64];
snprintf(text, 64, "Voxels %d x %d", gw, gh);
imguiValue(text);
}
imguiSeparator();
imguiLabel("Agent");
imguiSlider("Height", &m_agentHeight, 0.1f, 5.0f, 0.1f);
imguiSlider("Radius", &m_agentRadius, 0.0f, 5.0f, 0.1f);
imguiSlider("Max Climb", &m_agentMaxClimb, 0.1f, 5.0f, 0.1f);
imguiSlider("Max Slope", &m_agentMaxSlope, 0.0f, 90.0f, 1.0f);
imguiSeparator();
imguiLabel("Region");
imguiSlider("Min Region Size", &m_regionMinSize, 0.0f, 150.0f, 1.0f);
imguiSlider("Merged Region Size", &m_regionMergeSize, 0.0f, 150.0f, 1.0f);
imguiSeparator();
imguiLabel("Partitioning");
if (imguiCheck("Watershed", m_partitionType == SAMPLE_PARTITION_WATERSHED))
m_partitionType = SAMPLE_PARTITION_WATERSHED;
if (imguiCheck("Monotone", m_partitionType == SAMPLE_PARTITION_MONOTONE))
m_partitionType = SAMPLE_PARTITION_MONOTONE;
if (imguiCheck("Layers", m_partitionType == SAMPLE_PARTITION_LAYERS))
m_partitionType = SAMPLE_PARTITION_LAYERS;
imguiSeparator();
imguiLabel("Polygonization");
imguiSlider("Max Edge Length", &m_edgeMaxLen, 0.0f, 50.0f, 1.0f);
imguiSlider("Max Edge Error", &m_edgeMaxError, 0.1f, 3.0f, 0.1f);
imguiSlider("Verts Per Poly", &m_vertsPerPoly, 3.0f, 12.0f, 1.0f);
imguiSeparator();
imguiLabel("Detail Mesh");
imguiSlider("Sample Distance", &m_detailSampleDist, 0.0f, 16.0f, 1.0f);
imguiSlider("Max Sample Error", &m_detailSampleMaxError, 0.0f, 16.0f, 1.0f);
imguiSeparator();
}
int _main_(int _argc, char** _argv)
{
Args args(_argc, _argv);
uint32_t width = 1280;
uint32_t height = 720;
uint32_t debug = BGFX_DEBUG_TEXT;
uint32_t reset = 0
| BGFX_RESET_VSYNC
| BGFX_RESET_MSAA_X16
;
bgfx::init(args.m_type, args.m_pciId);
bgfx::reset(width, height, reset);
// Enable debug text.
bgfx::setDebug(debug);
// Set views clear state.
bgfx::setViewClear(0
, BGFX_CLEAR_COLOR|BGFX_CLEAR_DEPTH
, 0x303030ff
, 1.0f
, 0
);
// Imgui.
imguiCreate();
// Uniforms.
Uniforms uniforms;
uniforms.init();
// Vertex declarations.
PosColorTexCoord0Vertex::init();
LightProbe lightProbes[LightProbe::Count];
lightProbes[LightProbe::Bolonga].load("bolonga");
lightProbes[LightProbe::Kyoto ].load("kyoto");
LightProbe::Enum currentLightProbe = LightProbe::Bolonga;
bgfx::UniformHandle u_mtx = bgfx::createUniform("u_mtx", bgfx::UniformType::Mat4);
bgfx::UniformHandle u_params = bgfx::createUniform("u_params", bgfx::UniformType::Vec4);
bgfx::UniformHandle u_flags = bgfx::createUniform("u_flags", bgfx::UniformType::Vec4);
bgfx::UniformHandle u_camPos = bgfx::createUniform("u_camPos", bgfx::UniformType::Vec4);
bgfx::UniformHandle s_texCube = bgfx::createUniform("s_texCube", bgfx::UniformType::Int1);
bgfx::UniformHandle s_texCubeIrr = bgfx::createUniform("s_texCubeIrr", bgfx::UniformType::Int1);
bgfx::ProgramHandle programMesh = loadProgram("vs_ibl_mesh", "fs_ibl_mesh");
bgfx::ProgramHandle programSky = loadProgram("vs_ibl_skybox", "fs_ibl_skybox");
Mesh* meshBunny;
meshBunny = meshLoad("meshes/bunny.bin");
Mesh* meshOrb;
meshOrb = meshLoad("meshes/orb.bin");
Camera camera;
Mouse mouse;
struct Settings
{
Settings()
{
m_envRotCurr = 0.0f;
m_envRotDest = 0.0f;
m_lightDir[0] = -0.8f;
m_lightDir[1] = 0.2f;
m_lightDir[2] = -0.5f;
m_lightCol[0] = 1.0f;
m_lightCol[1] = 1.0f;
m_lightCol[2] = 1.0f;
m_glossiness = 0.7f;
m_exposure = 0.0f;
m_bgType = 3.0f;
m_radianceSlider = 2.0f;
m_reflectivity = 0.85f;
m_rgbDiff[0] = 1.0f;
m_rgbDiff[1] = 1.0f;
m_rgbDiff[2] = 1.0f;
m_rgbSpec[0] = 1.0f;
m_rgbSpec[1] = 1.0f;
m_rgbSpec[2] = 1.0f;
m_lod = 0.0f;
m_doDiffuse = false;
m_doSpecular = false;
m_doDiffuseIbl = true;
m_doSpecularIbl = true;
m_showLightColorWheel = true;
m_showDiffColorWheel = true;
m_showSpecColorWheel = true;
m_metalOrSpec = 0;
m_meshSelection = 0;
m_crossCubemapPreview = ImguiCubemap::Latlong;
}
float m_envRotCurr;
float m_envRotDest;
float m_lightDir[3];
float m_lightCol[3];
float m_glossiness;
float m_exposure;
float m_radianceSlider;
float m_bgType;
float m_reflectivity;
float m_rgbDiff[3];
float m_rgbSpec[3];
float m_lod;
bool m_doDiffuse;
bool m_doSpecular;
bool m_doDiffuseIbl;
bool m_doSpecularIbl;
bool m_showLightColorWheel;
bool m_showDiffColorWheel;
bool m_showSpecColorWheel;
uint8_t m_metalOrSpec;
uint8_t m_meshSelection;
ImguiCubemap::Enum m_crossCubemapPreview;
};
Settings settings;
int32_t leftScrollArea = 0;
entry::MouseState mouseState;
while (!entry::processEvents(width, height, debug, reset, &mouseState) )
{
imguiBeginFrame(mouseState.m_mx
, mouseState.m_my
, (mouseState.m_buttons[entry::MouseButton::Left ] ? IMGUI_MBUT_LEFT : 0)
| (mouseState.m_buttons[entry::MouseButton::Right ] ? IMGUI_MBUT_RIGHT : 0)
| (mouseState.m_buttons[entry::MouseButton::Middle] ? IMGUI_MBUT_MIDDLE : 0)
, mouseState.m_mz
, uint16_t(width)
, uint16_t(height)
);
static int32_t rightScrollArea = 0;
imguiBeginScrollArea("", width - 256 - 10, 10, 256, 700, &rightScrollArea);
imguiLabel("Environment light:");
imguiIndent();
imguiBool("IBL Diffuse", settings.m_doDiffuseIbl);
imguiBool("IBL Specular", settings.m_doSpecularIbl);
currentLightProbe = LightProbe::Enum(imguiTabs(
uint8_t(currentLightProbe)
, true
, ImguiAlign::LeftIndented
, 16
, 2
, 2
, "Bolonga"
, "Kyoto"
) );
if (imguiCube(lightProbes[currentLightProbe].m_tex, settings.m_lod, settings.m_crossCubemapPreview, true) )
{
settings.m_crossCubemapPreview = ImguiCubemap::Enum( (settings.m_crossCubemapPreview+1) % ImguiCubemap::Count);
}
imguiSlider("Texture LOD", settings.m_lod, 0.0f, 10.1f, 0.1f);
imguiUnindent();
imguiSeparator(8);
imguiLabel("Directional light:");
imguiIndent();
imguiBool("Diffuse", settings.m_doDiffuse);
imguiBool("Specular", settings.m_doSpecular);
const bool doDirectLighting = settings.m_doDiffuse || settings.m_doSpecular;
imguiSlider("Light direction X", settings.m_lightDir[0], -1.0f, 1.0f, 0.1f, doDirectLighting);
imguiSlider("Light direction Y", settings.m_lightDir[1], -1.0f, 1.0f, 0.1f, doDirectLighting);
imguiSlider("Light direction Z", settings.m_lightDir[2], -1.0f, 1.0f, 0.1f, doDirectLighting);
imguiColorWheel("Color:", settings.m_lightCol, settings.m_showLightColorWheel, 0.6f, doDirectLighting);
imguiUnindent();
imguiSeparator(8);
imguiLabel("Background:");
imguiIndent();
{
int32_t selection;
if (0.0f == settings.m_bgType) { selection = UINT8_C(0); }
else if (7.0f == settings.m_bgType) { selection = UINT8_C(2); }
else { selection = UINT8_C(1); }
selection = imguiTabs(
uint8_t(selection)
, true
, ImguiAlign::LeftIndented
, 16
, 2
, 3
, "Skybox"
, "Radiance"
, "Irradiance"
);
if (0 == selection) { settings.m_bgType = 0.0f; }
else if (2 == selection) { settings.m_bgType = 7.0f; }
else { settings.m_bgType = settings.m_radianceSlider; }
const bool isRadiance = (selection == 1);
imguiSlider("Mip level", settings.m_radianceSlider, 1.0f, 6.0f, 0.1f, isRadiance);
}
imguiUnindent();
imguiSeparator(8);
imguiLabel("Post processing:");
imguiIndent();
imguiSlider("Exposure", settings.m_exposure, -4.0f, 4.0f, 0.1f);
imguiUnindent();
imguiSeparator();
imguiEndScrollArea();
imguiBeginScrollArea("", 10, 70, 256, 636, &leftScrollArea);
imguiLabel("Mesh:");
imguiIndent();
settings.m_meshSelection = uint8_t(imguiChoose(settings.m_meshSelection, "Bunny", "Orbs") );
imguiUnindent();
const bool isBunny = (0 == settings.m_meshSelection);
if (!isBunny)
{
settings.m_metalOrSpec = 0;
}
imguiSeparator(4);
imguiLabel("Workflow:");
imguiIndent();
if (imguiCheck("Metalness", 0 == settings.m_metalOrSpec, isBunny) ) { settings.m_metalOrSpec = 0; }
if (imguiCheck("Specular", 1 == settings.m_metalOrSpec, isBunny) ) { settings.m_metalOrSpec = 1; }
imguiUnindent();
imguiSeparator(4);
imguiLabel("Material:");
imguiIndent();
imguiSlider("Glossiness", settings.m_glossiness, 0.0f, 1.0f, 0.01f, isBunny);
imguiSlider(0 == settings.m_metalOrSpec ? "Metalness" : "Diffuse - Specular", settings.m_reflectivity, 0.0f, 1.0f, 0.01f, isBunny);
imguiUnindent();
imguiColorWheel("Diffuse:", &settings.m_rgbDiff[0], settings.m_showDiffColorWheel, 0.7f);
imguiSeparator();
imguiColorWheel("Specular:", &settings.m_rgbSpec[0], settings.m_showSpecColorWheel, 0.7f, (1 == settings.m_metalOrSpec) && isBunny);
imguiEndScrollArea();
imguiEndFrame();
uniforms.m_glossiness = settings.m_glossiness;
uniforms.m_reflectivity = settings.m_reflectivity;
uniforms.m_exposure = settings.m_exposure;
uniforms.m_bgType = settings.m_bgType;
uniforms.m_metalOrSpec = float(settings.m_metalOrSpec);
uniforms.m_doDiffuse = float(settings.m_doDiffuse);
uniforms.m_doSpecular = float(settings.m_doSpecular);
uniforms.m_doDiffuseIbl = float(settings.m_doDiffuseIbl);
uniforms.m_doSpecularIbl = float(settings.m_doSpecularIbl);
bx::memCopy(uniforms.m_rgbDiff, settings.m_rgbDiff, 3*sizeof(float) );
bx::memCopy(uniforms.m_rgbSpec, settings.m_rgbSpec, 3*sizeof(float) );
bx::memCopy(uniforms.m_lightDir, settings.m_lightDir, 3*sizeof(float) );
bx::memCopy(uniforms.m_lightCol, settings.m_lightCol, 3*sizeof(float) );
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 float deltaTimeSec = float(double(frameTime)/freq);
// Use debug font to print information about this example.
bgfx::dbgTextClear();
bgfx::dbgTextPrintf(0, 1, 0x4f, "bgfx/examples/18-ibl");
bgfx::dbgTextPrintf(0, 2, 0x6f, "Description: Image-based lighting.");
bgfx::dbgTextPrintf(0, 3, 0x0f, "Frame: % 7.3f[ms]", double(frameTime)*toMs);
// Camera.
const bool mouseOverGui = imguiMouseOverArea();
mouse.update(float(mouseState.m_mx), float(mouseState.m_my), mouseState.m_mz, width, height);
if (!mouseOverGui)
{
if (mouseState.m_buttons[entry::MouseButton::Left])
{
camera.orbit(mouse.m_dx, mouse.m_dy);
}
else if (mouseState.m_buttons[entry::MouseButton::Right])
{
camera.dolly(mouse.m_dx + mouse.m_dy);
}
else if (mouseState.m_buttons[entry::MouseButton::Middle])
{
settings.m_envRotDest += mouse.m_dx*2.0f;
}
else if (0 != mouse.m_scroll)
{
camera.dolly(float(mouse.m_scroll)*0.05f);
}
}
camera.update(deltaTimeSec);
bx::memCopy(uniforms.m_cameraPos, camera.m_pos.curr, 3*sizeof(float) );
// View Transform 0.
float view[16];
float proj[16];
bx::mtxIdentity(view);
bx::mtxOrtho(proj, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 100.0f);
bgfx::setViewTransform(0, view, proj);
// View Transform 1.
camera.mtxLookAt(view);
bx::mtxProj(proj, 45.0f, float(width)/float(height), 0.1f, 100.0f, bgfx::getCaps()->homogeneousDepth);
bgfx::setViewTransform(1, view, proj);
// View rect.
bgfx::setViewRect(0, 0, 0, uint16_t(width), uint16_t(height) );
bgfx::setViewRect(1, 0, 0, uint16_t(width), uint16_t(height) );
// Env rotation.
const float amount = bx::fmin(deltaTimeSec/0.12f, 1.0f);
settings.m_envRotCurr = bx::flerp(settings.m_envRotCurr, settings.m_envRotDest, amount);
// Env mtx.
float mtxEnvView[16];
camera.envViewMtx(mtxEnvView);
float mtxEnvRot[16];
bx::mtxRotateY(mtxEnvRot, settings.m_envRotCurr);
bx::mtxMul(uniforms.m_mtx, mtxEnvView, mtxEnvRot); // Used for Skybox.
// Submit view 0.
bgfx::setTexture(0, s_texCube, lightProbes[currentLightProbe].m_tex);
bgfx::setTexture(1, s_texCubeIrr, lightProbes[currentLightProbe].m_texIrr);
bgfx::setState(BGFX_STATE_RGB_WRITE|BGFX_STATE_ALPHA_WRITE);
screenSpaceQuad( (float)width, (float)height, true);
uniforms.submit();
bgfx::submit(0, programSky);
// Submit view 1.
bx::memCopy(uniforms.m_mtx, mtxEnvRot, 16*sizeof(float)); // Used for IBL.
if (0 == settings.m_meshSelection)
{
// Submit bunny.
float mtx[16];
bx::mtxSRT(mtx, 1.0f, 1.0f, 1.0f, 0.0f, bx::pi, 0.0f, 0.0f, -0.80f, 0.0f);
bgfx::setTexture(0, s_texCube, lightProbes[currentLightProbe].m_tex);
bgfx::setTexture(1, s_texCubeIrr, lightProbes[currentLightProbe].m_texIrr);
uniforms.submit();
meshSubmit(meshBunny, 1, programMesh, mtx);
}
else
{
// Submit orbs.
for (float yy = 0, yend = 5.0f; yy < yend; yy+=1.0f)
{
for (float xx = 0, xend = 5.0f; xx < xend; xx+=1.0f)
{
const float scale = 1.2f;
const float spacing = 2.2f;
const float yAdj = -0.8f;
float mtx[16];
bx::mtxSRT(mtx
, scale/xend
, scale/xend
, scale/xend
, 0.0f
, 0.0f
, 0.0f
, 0.0f + (xx/xend)*spacing - (1.0f + (scale-1.0f)*0.5f - 1.0f/xend)
, yAdj/yend + (yy/yend)*spacing - (1.0f + (scale-1.0f)*0.5f - 1.0f/yend)
, 0.0f
);
uniforms.m_glossiness = xx*(1.0f/xend);
uniforms.m_reflectivity = (yend-yy)*(1.0f/yend);
uniforms.m_metalOrSpec = 0.0f;
uniforms.submit();
bgfx::setTexture(0, s_texCube, lightProbes[currentLightProbe].m_tex);
bgfx::setTexture(1, s_texCubeIrr, lightProbes[currentLightProbe].m_texIrr);
meshSubmit(meshOrb, 1, programMesh, mtx);
}
}
}
// Advance to next frame. Rendering thread will be kicked to
// process submitted rendering primitives.
bgfx::frame();
}
meshUnload(meshBunny);
meshUnload(meshOrb);
// Cleanup.
bgfx::destroyProgram(programMesh);
bgfx::destroyProgram(programSky);
bgfx::destroyUniform(u_camPos);
bgfx::destroyUniform(u_flags);
bgfx::destroyUniform(u_params);
bgfx::destroyUniform(u_mtx);
bgfx::destroyUniform(s_texCube);
bgfx::destroyUniform(s_texCubeIrr);
for (uint8_t ii = 0; ii < LightProbe::Count; ++ii)
{
lightProbes[ii].destroy();
}
uniforms.destroy();
imguiDestroy();
// Shutdown bgfx.
bgfx::shutdown();
return 0;
}
void Sample_TempObstacles::handleSettings()
{
Sample::handleCommonSettings();
if (imguiCheck("Keep Itermediate Results", m_keepInterResults))
m_keepInterResults = !m_keepInterResults;
imguiLabel("Tiling");
imguiSlider("TileSize", &m_tileSize, 16.0f, 128.0f, 8.0f);
int gridSize = 1;
if (m_geom)
{
const float* bmin = m_geom->getNavMeshBoundsMin();
const float* bmax = m_geom->getNavMeshBoundsMax();
char text[64];
int gw = 0, gh = 0;
rcCalcGridSize(bmin, bmax, m_cellSize, &gw, &gh);
const int ts = (int)m_tileSize;
const int tw = (gw + ts-1) / ts;
const int th = (gh + ts-1) / ts;
snprintf(text, 64, "Tiles %d x %d", tw, th);
imguiValue(text);
// Max tiles and max polys affect how the tile IDs are caculated.
// There are 22 bits available for identifying a tile and a polygon.
int tileBits = rcMin((int)dtIlog2(dtNextPow2(tw*th*EXPECTED_LAYERS_PER_TILE)), 14);
if (tileBits > 14) tileBits = 14;
int polyBits = 22 - tileBits;
m_maxTiles = 1 << tileBits;
m_maxPolysPerTile = 1 << polyBits;
snprintf(text, 64, "Max Tiles %d", m_maxTiles);
imguiValue(text);
snprintf(text, 64, "Max Polys %d", m_maxPolysPerTile);
imguiValue(text);
gridSize = tw*th;
}
else
{
m_maxTiles = 0;
m_maxPolysPerTile = 0;
}
imguiSeparator();
imguiLabel("Tile Cache");
char msg[64];
const float compressionRatio = (float)m_cacheCompressedSize / (float)(m_cacheRawSize+1);
snprintf(msg, 64, "Layers %d", m_cacheLayerCount);
imguiValue(msg);
snprintf(msg, 64, "Layers (per tile) %.1f", (float)m_cacheLayerCount/(float)gridSize);
imguiValue(msg);
snprintf(msg, 64, "Memory %.1f kB / %.1f kB (%.1f%%)", m_cacheCompressedSize/1024.0f, m_cacheRawSize/1024.0f, compressionRatio*100.0f);
imguiValue(msg);
snprintf(msg, 64, "Navmesh Build Time %.1f ms", m_cacheBuildTimeMs);
imguiValue(msg);
snprintf(msg, 64, "Build Peak Mem Usage %.1f kB", m_cacheBuildMemUsage/1024.0f);
imguiValue(msg);
imguiSeparator();
imguiIndent();
imguiIndent();
if (imguiButton("Save"))
{
saveAll("all_tiles_tilecache.bin");
}
if (imguiButton("Load"))
{
dtFreeNavMesh(m_navMesh);
dtFreeTileCache(m_tileCache);
loadAll("all_tiles_tilecache.bin");
m_navQuery->init(m_navMesh, 2048);
}
imguiUnindent();
imguiUnindent();
imguiSeparator();
}
void NavMeshTesterTool::handleMenu()
{
if (imguiCheck("Pathfind Follow", m_toolMode == TOOLMODE_PATHFIND_FOLLOW))
{
m_toolMode = TOOLMODE_PATHFIND_FOLLOW;
recalc();
}
if (imguiCheck("Pathfind Straight", m_toolMode == TOOLMODE_PATHFIND_STRAIGHT))
{
m_toolMode = TOOLMODE_PATHFIND_STRAIGHT;
recalc();
}
if (imguiCheck("Pathfind Sliced", m_toolMode == TOOLMODE_PATHFIND_SLICED))
{
m_toolMode = TOOLMODE_PATHFIND_SLICED;
recalc();
}
imguiSeparator();
if (imguiCheck("Distance to Wall", m_toolMode == TOOLMODE_DISTANCE_TO_WALL))
{
m_toolMode = TOOLMODE_DISTANCE_TO_WALL;
recalc();
}
imguiSeparator();
if (imguiCheck("Raycast", m_toolMode == TOOLMODE_RAYCAST))
{
m_toolMode = TOOLMODE_RAYCAST;
recalc();
}
imguiSeparator();
if (imguiCheck("Find Polys in Circle", m_toolMode == TOOLMODE_FIND_POLYS_IN_CIRCLE))
{
m_toolMode = TOOLMODE_FIND_POLYS_IN_CIRCLE;
recalc();
}
if (imguiCheck("Find Polys in Shape", m_toolMode == TOOLMODE_FIND_POLYS_IN_SHAPE))
{
m_toolMode = TOOLMODE_FIND_POLYS_IN_SHAPE;
recalc();
}
imguiSeparator();
if (imguiCheck("Find Local Neighbourhood", m_toolMode == TOOLMODE_FIND_LOCAL_NEIGHBOURHOOD))
{
m_toolMode = TOOLMODE_FIND_LOCAL_NEIGHBOURHOOD;
recalc();
}
imguiSeparator();
imguiLabel("Include Flags");
imguiIndent();
if (imguiCheck("Walk", (m_filter.getIncludeFlags() & SAMPLE_POLYFLAGS_WALK) != 0))
{
m_filter.setIncludeFlags(m_filter.getIncludeFlags() ^ SAMPLE_POLYFLAGS_WALK);
recalc();
}
if (imguiCheck("Swim", (m_filter.getIncludeFlags() & SAMPLE_POLYFLAGS_SWIM) != 0))
{
m_filter.setIncludeFlags(m_filter.getIncludeFlags() ^ SAMPLE_POLYFLAGS_SWIM);
recalc();
}
if (imguiCheck("Door", (m_filter.getIncludeFlags() & SAMPLE_POLYFLAGS_DOOR) != 0))
{
m_filter.setIncludeFlags(m_filter.getIncludeFlags() ^ SAMPLE_POLYFLAGS_DOOR);
recalc();
}
if (imguiCheck("Jump", (m_filter.getIncludeFlags() & SAMPLE_POLYFLAGS_JUMP) != 0))
{
m_filter.setIncludeFlags(m_filter.getIncludeFlags() ^ SAMPLE_POLYFLAGS_JUMP);
recalc();
}
imguiUnindent();
imguiSeparator();
imguiLabel("Exclude Flags");
imguiIndent();
if (imguiCheck("Walk", (m_filter.getExcludeFlags() & SAMPLE_POLYFLAGS_WALK) != 0))
{
m_filter.setExcludeFlags(m_filter.getExcludeFlags() ^ SAMPLE_POLYFLAGS_WALK);
recalc();
}
if (imguiCheck("Swim", (m_filter.getExcludeFlags() & SAMPLE_POLYFLAGS_SWIM) != 0))
{
m_filter.setExcludeFlags(m_filter.getExcludeFlags() ^ SAMPLE_POLYFLAGS_SWIM);
recalc();
}
if (imguiCheck("Door", (m_filter.getExcludeFlags() & SAMPLE_POLYFLAGS_DOOR) != 0))
{
m_filter.setExcludeFlags(m_filter.getExcludeFlags() ^ SAMPLE_POLYFLAGS_DOOR);
recalc();
}
if (imguiCheck("Jump", (m_filter.getExcludeFlags() & SAMPLE_POLYFLAGS_JUMP) != 0))
{
m_filter.setExcludeFlags(m_filter.getExcludeFlags() ^ SAMPLE_POLYFLAGS_JUMP);
recalc();
}
imguiUnindent();
imguiSeparator();
}
void CMaNGOS_Map::handleDebugMode()
{
// Check which modes are valid.
bool valid[MAX_DRAWMODE];
for (int i = 0; i < MAX_DRAWMODE; ++i)
valid[i] = false;
if (!m_MapInfos->IsEmpty())
{
valid[DRAWMODE_NAVMESH] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_TRANS] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_BVTREE] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_NODES] = m_navQuery != 0;
valid[DRAWMODE_NAVMESH_PORTALS] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_INVIS] = m_navMesh != 0;
valid[DRAWMODE_MESH] = true;
}
int unavail = 0;
for (int i = 0; i < MAX_DRAWMODE; ++i)
if (!valid[i]) unavail++;
if (unavail == MAX_DRAWMODE)
return;
imguiLabel("Draw");
if (imguiCheck("Input Mesh", m_drawMode == DRAWMODE_MESH, valid[DRAWMODE_MESH]))
m_drawMode = DRAWMODE_MESH;
if (imguiCheck("Navmesh", m_drawMode == DRAWMODE_NAVMESH, valid[DRAWMODE_NAVMESH]))
m_drawMode = DRAWMODE_NAVMESH;
if (imguiCheck("Navmesh Invis", m_drawMode == DRAWMODE_NAVMESH_INVIS, valid[DRAWMODE_NAVMESH_INVIS]))
m_drawMode = DRAWMODE_NAVMESH_INVIS;
if (imguiCheck("Navmesh Trans", m_drawMode == DRAWMODE_NAVMESH_TRANS, valid[DRAWMODE_NAVMESH_TRANS]))
m_drawMode = DRAWMODE_NAVMESH_TRANS;
if (imguiCheck("Navmesh BVTree", m_drawMode == DRAWMODE_NAVMESH_BVTREE, valid[DRAWMODE_NAVMESH_BVTREE]))
m_drawMode = DRAWMODE_NAVMESH_BVTREE;
if (imguiCheck("Navmesh Nodes", m_drawMode == DRAWMODE_NAVMESH_NODES, valid[DRAWMODE_NAVMESH_NODES]))
m_drawMode = DRAWMODE_NAVMESH_NODES;
if (imguiCheck("Navmesh Portals", m_drawMode == DRAWMODE_NAVMESH_PORTALS, valid[DRAWMODE_NAVMESH_PORTALS]))
m_drawMode = DRAWMODE_NAVMESH_PORTALS;
/*if (imguiCheck("Voxels", m_drawMode == DRAWMODE_VOXELS, valid[DRAWMODE_VOXELS]))
m_drawMode = DRAWMODE_VOXELS;
if (imguiCheck("Walkable Voxels", m_drawMode == DRAWMODE_VOXELS_WALKABLE, valid[DRAWMODE_VOXELS_WALKABLE]))
m_drawMode = DRAWMODE_VOXELS_WALKABLE;
if (imguiCheck("Compact", m_drawMode == DRAWMODE_COMPACT, valid[DRAWMODE_COMPACT]))
m_drawMode = DRAWMODE_COMPACT;
if (imguiCheck("Compact Distance", m_drawMode == DRAWMODE_COMPACT_DISTANCE, valid[DRAWMODE_COMPACT_DISTANCE]))
m_drawMode = DRAWMODE_COMPACT_DISTANCE;
if (imguiCheck("Compact Regions", m_drawMode == DRAWMODE_COMPACT_REGIONS, valid[DRAWMODE_COMPACT_REGIONS]))
m_drawMode = DRAWMODE_COMPACT_REGIONS;
if (imguiCheck("Region Connections", m_drawMode == DRAWMODE_REGION_CONNECTIONS, valid[DRAWMODE_REGION_CONNECTIONS]))
m_drawMode = DRAWMODE_REGION_CONNECTIONS;
if (imguiCheck("Raw Contours", m_drawMode == DRAWMODE_RAW_CONTOURS, valid[DRAWMODE_RAW_CONTOURS]))
m_drawMode = DRAWMODE_RAW_CONTOURS;
if (imguiCheck("Both Contours", m_drawMode == DRAWMODE_BOTH_CONTOURS, valid[DRAWMODE_BOTH_CONTOURS]))
m_drawMode = DRAWMODE_BOTH_CONTOURS;
if (imguiCheck("Contours", m_drawMode == DRAWMODE_CONTOURS, valid[DRAWMODE_CONTOURS]))
m_drawMode = DRAWMODE_CONTOURS;
if (imguiCheck("Poly Mesh", m_drawMode == DRAWMODE_POLYMESH, valid[DRAWMODE_POLYMESH]))
m_drawMode = DRAWMODE_POLYMESH;
if (imguiCheck("Poly Mesh Detail", m_drawMode == DRAWMODE_POLYMESH_DETAIL, valid[DRAWMODE_POLYMESH_DETAIL]))
m_drawMode = DRAWMODE_POLYMESH_DETAIL;*/
}
void CMaNGOS_Map::handleSettings()
{
if (m_MapInfos->IsEmpty())
return;
if (m_SelectedTile)
{
bool tileFound = false;
imguiLabel("Tile commands");
std::string bText;
if (m_MapInfos->GetTileRef(m_SelectedTile->tx, m_SelectedTile->ty))
{
tileFound = true;
bText = "Clear selected tile navmesh";
if (imguiButton(bText.c_str()))
{
setTool(NULL);
m_MapInfos->ClearNavMeshOfTile(m_SelectedTile->tx, m_SelectedTile->ty);
}
}
else
{
bText = "Load selected tile navmesh";
if (imguiButton(bText.c_str()))
{
if (m_MapInfos->LoadNavMeshOfTile(m_SelectedTile->tx, m_SelectedTile->ty))
setTool(new NavMeshTesterTool);
}
bText = "Build navmesh for selected tile";
if (imguiButton(bText.c_str()))
{
rcConfig cfg;
cfg.cs = m_cellSize;
cfg.ch = m_cellHeight;
cfg.walkableSlopeAngle = m_agentMaxSlope;
cfg.walkableHeight = (int)ceilf(m_agentHeight);// (int)ceilf(m_agentHeight / m_cfg.ch);
cfg.walkableClimb = (int)floorf(m_agentMaxClimb);// (int)floorf(m_agentMaxClimb / m_cfg.ch);
cfg.walkableRadius = (int)ceilf(m_agentRadius);// (int)ceilf(m_agentRadius / m_cfg.cs);
cfg.maxEdgeLen = (int)m_edgeMaxLen;// (int)(m_edgeMaxLen / m_cellSize);
cfg.maxSimplificationError = m_edgeMaxError;
cfg.minRegionArea = (int)rcSqr(m_regionMinSize); // Note: area = size*size
cfg.mergeRegionArea = (int)rcSqr(m_regionMergeSize); // Note: area = size*size
cfg.maxVertsPerPoly = (int)m_vertsPerPoly;
cfg.tileSize = (int)m_tileSize;
cfg.borderSize = cfg.walkableRadius + 3; // Reserve enough padding.
cfg.detailSampleDist = m_cellSize * m_detailSampleDist;
cfg.detailSampleMaxError = m_cellHeight * m_detailSampleMaxError;
m_MapInfos->BuildNavMeshOfTile(m_SelectedTile->tx, m_SelectedTile->ty, &cfg, m_partitionType);
setTool(new NavMeshTesterTool);
}
}
if (tileFound)
return;
char tmpStr[50];
imguiLabel("Rasterization");
snprintf(tmpStr, sizeof(tmpStr), "Cell Size = %4.3f", m_cellSize);
imguiValue(tmpStr);
snprintf(tmpStr, sizeof(tmpStr), "Cell Height = %4.3f", m_cellHeight);
imguiValue(tmpStr);
if (!m_MapInfos->GetGeomsMap()->empty())
{
int gw = 0, gh = 0;
rcCalcGridSize(m_MapInfos->BMin(), m_MapInfos->BMax(), m_cellSize, &gw, &gh);
char text[64];
snprintf(text, 64, "Voxels %d x %d", gw, gh);
imguiValue(text);
}
imguiSeparator();
imguiLabel("Agent");
imguiSlider("Height", &m_agentHeight, 0.1f, 5.0f, 0.1f);
imguiSlider("Radius", &m_agentRadius, 0.0f, 5.0f, 0.1f);
imguiSlider("Max Climb", &m_agentMaxClimb, 0.1f, 5.0f, 0.1f);
imguiSlider("Max Slope", &m_agentMaxSlope, 0.0f, 90.0f, 1.0f);
imguiSeparator();
imguiLabel("Region");
imguiSlider("Min Region Size", &m_regionMinSize, 0.0f, 150.0f, 1.0f);
imguiSlider("Merged Region Size", &m_regionMergeSize, 0.0f, 150.0f, 1.0f);
imguiSeparator();
imguiLabel("Partitioning");
if (imguiCheck("Watershed", m_partitionType == SAMPLE_PARTITION_WATERSHED))
m_partitionType = SAMPLE_PARTITION_WATERSHED;
if (imguiCheck("Monotone", m_partitionType == SAMPLE_PARTITION_MONOTONE))
m_partitionType = SAMPLE_PARTITION_MONOTONE;
if (imguiCheck("Layers", m_partitionType == SAMPLE_PARTITION_LAYERS))
m_partitionType = SAMPLE_PARTITION_LAYERS;
imguiSeparator();
imguiLabel("Polygonization");
imguiSlider("Max Edge Length", &m_edgeMaxLen, 0.0f, 100.0f, 1.0f);
imguiSlider("Max Edge Error", &m_edgeMaxError, 0.1f, 3.0f, 0.1f);
imguiSlider("Verts Per Poly", &m_vertsPerPoly, 3.0f, 12.0f, 1.0f);
imguiSeparator();
imguiLabel("Detail Mesh");
imguiSlider("Sample Distance", &m_detailSampleDist, 0.0f, 100.0f, 1.0f);
imguiSlider("Max Sample Error", &m_detailSampleMaxError, 0.0f, 10.0f, 1.0f);
imguiSeparator();
char text[64];
int gw = 0, gh = 0;
rcCalcGridSize(m_MapInfos->BMin(), m_MapInfos->BMax(), m_cellSize, &gw, &gh);
const int ts = (int)m_tileSize;
const int tw = (gw + ts - 1) / ts;
const int th = (gh + ts - 1) / ts;
snprintf(text, 64, "Tiles %d x %d", tw, th);
imguiValue(text);
imguiSeparator();
}
}
void CMaNGOS_Map::handleExtraSettings()
{
imguiLabel("Map Id");
char buff[4];
memset(buff, 0, sizeof(buff));
itoa(m_mapID, buff, 10);
if (imguiButton(buff))
{
if (m_showLevel == SHOW_LEVEL_MAP)
{
m_showLevel = SHOW_LEVEL_NONE;
}
else
{
m_showLevel = SHOW_LEVEL_MAP;
}
}
imguiLabel("Tile");
if (imguiButton(m_TileButtonStr.c_str()))
{
if (m_showLevel == SHOW_LEVEL_TILES || m_showLevel == SHOW_LEVEL_NEIGHBOR_TILES)
{
m_showLevel = SHOW_LEVEL_NONE;
}
else
{
if (m_MapInfos->IsEmpty())
m_showLevel = SHOW_LEVEL_TILES;
else if (!m_NeighborTiles.empty())
m_showLevel = SHOW_LEVEL_NEIGHBOR_TILES;
}
}
if (!m_MapInfos->IsEmpty())
{
imguiSeparatorLine();
MeshObjectsMap::const_iterator itr = m_MapInfos->GetGeomsMap()->begin();
imguiLabel("Loaded tile");
while (itr != m_MapInfos->GetGeomsMap()->end())
{
MeshObjects* mo = (*itr).second;
string map = mo->GetMap() ? "MAP " : "";
string vmap = mo->GetVMap() ? "VMAP " : "";
string mmap = m_MapInfos->GetTileRef(mo->GetTileX(), mo->GetTileY()) ? "MMAP" : "";
char buff[40];
snprintf(buff, sizeof(buff), "%dx%d > Found %s%s%s", mo->GetTileX(), mo->GetTileY(), map.c_str(), vmap.c_str(), mmap.c_str());
if (imguiItem(buff))
{
RemoveTileData(mo->GetTileX(), mo->GetTileY());
unsigned int pxy = VMAP::StaticMapTree::packTileID(mo->GetTileX(), mo->GetTileY());
m_NeighborTiles.insert(pxy);
if (m_MapInfos->IsEmpty())
{
m_TileButtonStr = "Click to choose a tile";
}
break;
}
else
++itr;
}
}
}
int _main_(int _argc, char** _argv)
{
Args args(_argc, _argv);
uint32_t width = 1280;
uint32_t height = 720;
uint32_t debug = BGFX_DEBUG_TEXT;
uint32_t reset = BGFX_RESET_VSYNC;
bgfx::init(args.m_type, args.m_pciId);
bgfx::reset(width, height, reset);
// Enable debug text.
bgfx::setDebug(debug);
// Set views clear state.
bgfx::setViewClear(0
, BGFX_CLEAR_COLOR|BGFX_CLEAR_DEPTH
, 0x303030ff
, 1.0f
, 0
);
// Imgui.
imguiCreate();
// Uniforms.
s_uniforms.init();
// Vertex declarations.
PosColorTexCoord0Vertex::init();
LightProbe lightProbes[LightProbe::Count];
lightProbes[LightProbe::Wells ].load("wells");
lightProbes[LightProbe::Uffizi].load("uffizi");
lightProbes[LightProbe::Pisa ].load("pisa");
lightProbes[LightProbe::Ennis ].load("ennis");
lightProbes[LightProbe::Grace ].load("grace");
LightProbe::Enum currentLightProbe = LightProbe::Wells;
bgfx::UniformHandle u_mtx = bgfx::createUniform("u_mtx", bgfx::UniformType::Mat4);
bgfx::UniformHandle u_params = bgfx::createUniform("u_params", bgfx::UniformType::Vec4);
bgfx::UniformHandle u_flags = bgfx::createUniform("u_flags", bgfx::UniformType::Vec4);
bgfx::UniformHandle u_camPos = bgfx::createUniform("u_camPos", bgfx::UniformType::Vec4);
bgfx::UniformHandle s_texCube = bgfx::createUniform("s_texCube", bgfx::UniformType::Int1);
bgfx::UniformHandle s_texCubeIrr = bgfx::createUniform("s_texCubeIrr", bgfx::UniformType::Int1);
bgfx::ProgramHandle programMesh = loadProgram("vs_ibl_mesh", "fs_ibl_mesh");
bgfx::ProgramHandle programSky = loadProgram("vs_ibl_skybox", "fs_ibl_skybox");
Mesh* meshBunny;
meshBunny = meshLoad("meshes/bunny.bin");
struct Settings
{
float m_speed;
float m_glossiness;
float m_exposure;
float m_diffspec;
float m_rgbDiff[3];
float m_rgbSpec[3];
bool m_diffuse;
bool m_specular;
bool m_diffuseIbl;
bool m_specularIbl;
bool m_showDiffColorWheel;
bool m_showSpecColorWheel;
ImguiCubemap::Enum m_crossCubemapPreview;
};
Settings settings;
settings.m_speed = 0.37f;
settings.m_glossiness = 1.0f;
settings.m_exposure = 0.0f;
settings.m_diffspec = 0.65f;
settings.m_rgbDiff[0] = 0.2f;
settings.m_rgbDiff[1] = 0.2f;
settings.m_rgbDiff[2] = 0.2f;
settings.m_rgbSpec[0] = 1.0f;
settings.m_rgbSpec[1] = 1.0f;
settings.m_rgbSpec[2] = 1.0f;
settings.m_diffuse = true;
settings.m_specular = true;
settings.m_diffuseIbl = true;
settings.m_specularIbl = true;
settings.m_showDiffColorWheel = true;
settings.m_showSpecColorWheel = false;
settings.m_crossCubemapPreview = ImguiCubemap::Cross;
float time = 0.0f;
int32_t leftScrollArea = 0;
entry::MouseState mouseState;
while (!entry::processEvents(width, height, debug, reset, &mouseState) )
{
imguiBeginFrame(mouseState.m_mx
, mouseState.m_my
, (mouseState.m_buttons[entry::MouseButton::Left ] ? IMGUI_MBUT_LEFT : 0)
| (mouseState.m_buttons[entry::MouseButton::Right ] ? IMGUI_MBUT_RIGHT : 0)
| (mouseState.m_buttons[entry::MouseButton::Middle] ? IMGUI_MBUT_MIDDLE : 0)
, mouseState.m_mz
, width
, height
);
static int32_t rightScrollArea = 0;
imguiBeginScrollArea("Settings", width - 256 - 10, 10, 256, 540, &rightScrollArea);
imguiLabel("Shade:");
imguiSeparator();
imguiBool("Diffuse", settings.m_diffuse);
imguiBool("Specular", settings.m_specular);
imguiBool("IBL Diffuse", settings.m_diffuseIbl);
imguiBool("IBL Specular", settings.m_specularIbl);
imguiSeparatorLine();
imguiSlider("Speed", settings.m_speed, 0.0f, 1.0f, 0.01f);
imguiSeparatorLine();
imguiSeparator();
imguiSlider("Exposure", settings.m_exposure, -8.0f, 8.0f, 0.01f);
imguiSeparator();
imguiLabel("Environment:");
currentLightProbe = LightProbe::Enum(imguiChoose(currentLightProbe
, "Wells"
, "Uffizi"
, "Pisa"
, "Ennis"
, "Grace"
) );
static float lod = 0.0f;
if (imguiCube(lightProbes[currentLightProbe].m_tex, lod, settings.m_crossCubemapPreview, true) )
{
settings.m_crossCubemapPreview = ImguiCubemap::Enum( (settings.m_crossCubemapPreview+1) % ImguiCubemap::Count);
}
imguiSlider("Texture LOD", lod, 0.0f, 10.1f, 0.1f);
imguiEndScrollArea();
imguiBeginScrollArea("Settings", 10, 70, 256, 576, &leftScrollArea);
imguiLabel("Material properties:");
imguiSeparator();
imguiSlider("Diffuse - Specular", settings.m_diffspec, 0.0f, 1.0f, 0.01f);
imguiSlider("Glossiness" , settings.m_glossiness, 0.0f, 1.0f, 0.01f);
imguiSeparator();
imguiColorWheel("Diffuse color:", &settings.m_rgbDiff[0], settings.m_showDiffColorWheel);
imguiSeparator();
imguiColorWheel("Specular color:", &settings.m_rgbSpec[0], settings.m_showSpecColorWheel);
imguiSeparator();
imguiLabel("Predefined materials:");
imguiSeparator();
if (imguiButton("Gold") )
{
settings.m_glossiness = 0.8f;
settings.m_diffspec = 1.0f;
settings.m_rgbDiff[0] = 0.0f;
settings.m_rgbDiff[1] = 0.0f;
settings.m_rgbDiff[2] = 0.0f;
settings.m_rgbSpec[0] = 1.0f;
settings.m_rgbSpec[1] = 0.86f;
settings.m_rgbSpec[2] = 0.58f;
}
if (imguiButton("Copper") )
{
settings.m_glossiness = 0.67f;
settings.m_diffspec = 1.0f;
settings.m_rgbDiff[0] = 0.0f;
settings.m_rgbDiff[1] = 0.0f;
settings.m_rgbDiff[2] = 0.0f;
settings.m_rgbSpec[0] = 0.98f;
settings.m_rgbSpec[1] = 0.82f;
settings.m_rgbSpec[2] = 0.76f;
}
if (imguiButton("Titanium") )
{
settings.m_glossiness = 0.57f;
settings.m_diffspec = 1.0f;
settings.m_rgbDiff[0] = 0.0f;
settings.m_rgbDiff[1] = 0.0f;
settings.m_rgbDiff[2] = 0.0f;
settings.m_rgbSpec[0] = 0.76f;
settings.m_rgbSpec[1] = 0.73f;
settings.m_rgbSpec[2] = 0.71f;
}
if (imguiButton("Steel") )
{
settings.m_glossiness = 0.82f;
settings.m_diffspec = 1.0f;
settings.m_rgbDiff[0] = 0.0f;
settings.m_rgbDiff[1] = 0.0f;
settings.m_rgbDiff[2] = 0.0f;
settings.m_rgbSpec[0] = 0.77f;
settings.m_rgbSpec[1] = 0.78f;
settings.m_rgbSpec[2] = 0.77f;
}
imguiEndScrollArea();
imguiEndFrame();
s_uniforms.m_glossiness = settings.m_glossiness;
s_uniforms.m_exposure = settings.m_exposure;
s_uniforms.m_diffspec = settings.m_diffspec;
s_uniforms.m_flags[0] = float(settings.m_diffuse);
s_uniforms.m_flags[1] = float(settings.m_specular);
s_uniforms.m_flags[2] = float(settings.m_diffuseIbl);
s_uniforms.m_flags[3] = float(settings.m_specularIbl);
memcpy(s_uniforms.m_rgbDiff, settings.m_rgbDiff, 3*sizeof(float) );
memcpy(s_uniforms.m_rgbSpec, settings.m_rgbSpec, 3*sizeof(float) );
s_uniforms.submitPerFrameUniforms();
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;
time += (float)(frameTime*settings.m_speed/freq);
s_uniforms.m_camPosTime[3] = time;
// Use debug font to print information about this example.
bgfx::dbgTextClear();
bgfx::dbgTextPrintf(0, 1, 0x4f, "bgfx/examples/18-ibl");
bgfx::dbgTextPrintf(0, 2, 0x6f, "Description: Image based lightning.");
bgfx::dbgTextPrintf(0, 3, 0x0f, "Frame: % 7.3f[ms]", double(frameTime)*toMs);
float at[3] = { 0.0f, 0.0f, 0.0f };
float eye[3] = { 0.0f, 0.0f, -3.0f };
bx::mtxRotateXY(s_uniforms.m_mtx
, 0.0f
, time
);
float view[16];
float proj[16];
bx::mtxIdentity(view);
bx::mtxOrtho(proj, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 100.0f);
bgfx::setViewTransform(0, view, proj);
bx::mtxLookAt(view, eye, at);
memcpy(s_uniforms.m_camPosTime, eye, 3*sizeof(float) );
bx::mtxProj(proj, 60.0f, float(width)/float(height), 0.1f, 100.0f);
bgfx::setViewTransform(1, view, proj);
bgfx::setViewRect(0, 0, 0, width, height);
bgfx::setViewRect(1, 0, 0, width, height);
// View 0.
bgfx::setTexture(0, s_texCube, lightProbes[currentLightProbe].m_tex);
bgfx::setState(BGFX_STATE_RGB_WRITE|BGFX_STATE_ALPHA_WRITE);
screenSpaceQuad( (float)width, (float)height, true);
s_uniforms.submitPerDrawUniforms();
bgfx::submit(0, programSky);
// View 1.
float mtx[16];
bx::mtxSRT(mtx
, 1.0f
, 1.0f
, 1.0f
, 0.0f
, bx::pi+time
, 0.0f
, 0.0f
, -1.0f
, 0.0f
);
bgfx::setTexture(0, s_texCube, lightProbes[currentLightProbe].m_tex);
bgfx::setTexture(1, s_texCubeIrr, lightProbes[currentLightProbe].m_texIrr);
meshSubmit(meshBunny, 1, programMesh, mtx);
// Advance to next frame. Rendering thread will be kicked to
// process submitted rendering primitives.
bgfx::frame();
}
meshUnload(meshBunny);
// Cleanup.
bgfx::destroyProgram(programMesh);
bgfx::destroyProgram(programSky);
bgfx::destroyUniform(u_camPos);
bgfx::destroyUniform(u_flags);
bgfx::destroyUniform(u_params);
bgfx::destroyUniform(u_mtx);
bgfx::destroyUniform(s_texCube);
bgfx::destroyUniform(s_texCubeIrr);
for (uint8_t ii = 0; ii < LightProbe::Count; ++ii)
{
lightProbes[ii].destroy();
}
s_uniforms.destroy();
imguiDestroy();
// Shutdown bgfx.
bgfx::shutdown();
return 0;
}
// This function's code is from the RecastDemo project's main.cpp file by Mikko Mononen
void MyRecastDemo::guiRender()
{
GLdouble proj[16];
GLdouble model[16];
GLint view[4];
glGetDoublev(GL_PROJECTION_MATRIX, proj);
glGetDoublev(GL_MODELVIEW_MATRIX, model);
glGetIntegerv(GL_VIEWPORT, view);
GLdouble x, y, z;
gluUnProject(m_mouseX, m_mouseY, 0.0f, model, proj, view, &x, &y, &z);
m_rays[0] = (float)x; m_rays[1] = (float)y; m_rays[2] = (float)z;
gluUnProject(m_mouseX, m_mouseY, 1.0f, model, proj, view, &x, &y, &z);
m_raye[0] = (float)x; m_raye[1] = (float)y; m_raye[2] = (float)z;
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, m_width, 0, m_height);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor4ub(255,255,255,255);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
m_mouseOverMenu = false;
imguiBeginFrame( m_mouseX,m_mouseY,m_mouseBut,m_mouseScroll );
const char msg[] = "W/S/A/D: move (+ shift) | F1: toggle recast gui | F2: toggle node names | F12: invert mouse";
imguiDrawText(280, m_height-20, IMGUI_ALIGN_LEFT, msg, imguiRGBA(255,255,255,200));
if (m_showMenu)
{
if (m_sample)
{
m_sample->handleRenderOverlay((double*)proj, (double*)model, (int*)view);
}
if (imguiBeginScrollArea("Properties", m_width-250-10, 10, 250, m_height-20, &m_propScroll))
m_mouseOverMenu = true;
if (imguiCheck("Show Log", m_showLog))
m_showLog = !m_showLog;
if (imguiCheck("Show Tools", m_showTools))
m_showTools = !m_showTools;
imguiSeparator();
imguiLabel("Sample");
if (imguiButton(m_sampleName))
{
if (m_showSample)
{
m_showSample = false;
}
else
{
m_showSample = true;
m_showConfig = false;
}
}
imguiSeparator();
imguiLabel("Config File");
if (imguiButton(m_configName))
{
if (m_showConfig)
{
m_showConfig = false;
}
else
{
m_showSample = false;
m_showConfig = true;
scanDirectory("Content", ".xml", m_files);
}
}
if (m_geom)
{
char text[64];
snprintf(text, 64, "Verts: %.1fk Tris: %.1fk",
m_geom->getMesh()->getVertCount()/1000.0f,
m_geom->getMesh()->getTriCount()/1000.0f);
imguiValue(text);
}
imguiSeparator();
if (m_geom && m_sample)
{
imguiSeparatorLine();
m_sample->handleSettings();
if (imguiButton("Build"))
{
m_ctx.resetLog();
if (!m_sample->handleBuild())
{
m_showLog = true;
m_logScroll = 0;
}
m_ctx.dumpLog("Build log %s:", m_configName);
}
imguiSeparator();
}
if (m_sample)
{
imguiSeparatorLine();
m_sample->handleDebugMode();
}
imguiEndScrollArea();
}
// Sample selection dialog.
if (m_showSample)
{
static int levelScroll = 0;
if (imguiBeginScrollArea("Choose Sample", m_width-10-250-10-200, m_height-10-250, 200, 250, &levelScroll))
m_mouseOverMenu = true;
Sample* newSample = 0;
for (int i = 0; i < g_nsamples; ++i)
{
if (imguiItem(g_samples[i].name))
{
newSample = g_samples[i].create();
if (newSample)
strcpy(m_sampleName, g_samples[i].name);
}
}
if (newSample)
{
delete m_geom;
m_geom = 0;
delete m_sample;
m_sample = newSample;
m_sample->setContext(&m_ctx);
if (m_geom && m_sample)
{
m_sample->handleMeshChanged(m_geom);
}
else if(!m_geom)
{
m_geom = new InputGeom();
m_geom->loadMesh( &m_ctx, m_configXmlFile.c_str() );
}
if( m_geom && m_sample )
{
m_sample->handleMeshChanged(m_geom);
m_sample->handleSettings();
}
m_showSample = false;
}
imguiEndScrollArea();
}
// Config selection dialog.
if (m_showConfig)
{
static int levelScroll = 0;
if (imguiBeginScrollArea("Choose Config File", m_width-10-250-10-200, m_height-10-450, 200, 450, &levelScroll))
m_mouseOverMenu = true;
int levelToLoad = -1;
for (int i = 0; i < m_files.size; ++i)
{
if (imguiItem(m_files.files[i]))
levelToLoad = i;
}
if (levelToLoad != -1)
{
strncpy(m_configName, m_files.files[levelToLoad], sizeof(m_configName));
m_configName[sizeof(m_configName)-1] = '\0';
m_showConfig = false;
delete m_geom;
m_geom = 0;
char path[256];
strcpy(path, "Content/");
strcat(path, m_configName);
m_configXmlFile = path;
m_geom = new InputGeom();
if( m_loadedSceneGraphRes )
{
// Remove previously loaded scene .
// Every scene.xml file loaded should group its children in a GroupNode.
int nrFoundNodes = h3dFindNodes( H3DRootNode, "", H3DNodeTypes::Group);
for( int i = 0; i<2; ++i )
{
int node = h3dGetNodeFindResult(i);
const char* name = h3dGetNodeParamStr( node, H3DNodeParams::NameStr);
std::string camName(name);
// Do not delete nodes directly under the root node (e.g. the demo's camera)
if( camName.compare("RootNode") != 0)
{
h3dRemoveNode( h3dGetNodeFindResult(i) );
}
}
int a = h3dRemoveResource( m_loadedSceneGraphRes );
h3dReleaseUnusedResources();
}
if( !loadSceneFileFromConfig( path) )
{
m_showLog = true;
m_logScroll = 0;
m_ctx.log(RC_LOG_ERROR, "Error loading resources from specified scene file.");
}
if (!m_geom || !m_geom->loadMesh(&m_ctx, m_configXmlFile.c_str()) )
{
delete m_geom;
m_geom = 0;
m_showLog = true;
m_logScroll = 0;
m_ctx.log(RC_LOG_ERROR, "Error loading nav mesh geometry from: \"%s\"", m_configName);
m_ctx.dumpLog("Config: Geom load log %s:", m_configName);
}
if (m_sample && m_geom)
{
m_sample->handleMeshChanged(m_geom);
}
}
imguiEndScrollArea();
}
// Log
if (m_showLog && m_showMenu)
{
if (imguiBeginScrollArea("Log", 250+20, 10, m_width - 300 - 250, 200, &m_logScroll))
m_mouseOverMenu = true;
for (int i = 0; i < m_ctx.getLogCount(); ++i)
imguiLabel(m_ctx.getLogText(i));
imguiEndScrollArea();
}
// Tools
if (!m_showTestCases && m_showTools && m_showMenu) // && m_geom && m_sample)
{
if (imguiBeginScrollArea("Tools", 10, 10, 250, m_height-20, &m_toolsScroll))
m_mouseOverMenu = true;
if (m_sample)
m_sample->handleTools();
imguiEndScrollArea();
}
m_wasMouseOverMenu = m_mouseOverMenu;
if(!m_wasMouseOverMenu)
{
// In case we move a GUI slider and leave the menu area
m_mouseBut = 0;
}
m_mouseScroll = 0;
imguiEndFrame();
imguiRenderGLDraw();
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
}
void Sample_TileMesh::handleDebugMode()
{
// Check which modes are valid.
bool valid[MAX_DRAWMODE];
for (int i = 0; i < MAX_DRAWMODE; ++i)
valid[i] = false;
if (m_geom)
{
valid[DRAWMODE_NAVMESH] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_TRANS] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_BVTREE] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_NODES] = m_navQuery != 0;
valid[DRAWMODE_NAVMESH_PORTALS] = m_navMesh != 0;
valid[DRAWMODE_NAVMESH_INVIS] = m_navMesh != 0;
valid[DRAWMODE_MESH] = true;
valid[DRAWMODE_VOXELS] = m_solid != 0;
valid[DRAWMODE_VOXELS_WALKABLE] = m_solid != 0;
valid[DRAWMODE_COMPACT] = m_chf != 0;
valid[DRAWMODE_COMPACT_DISTANCE] = m_chf != 0;
valid[DRAWMODE_COMPACT_REGIONS] = m_chf != 0;
valid[DRAWMODE_REGION_CONNECTIONS] = m_cset != 0;
valid[DRAWMODE_RAW_CONTOURS] = m_cset != 0;
valid[DRAWMODE_BOTH_CONTOURS] = m_cset != 0;
valid[DRAWMODE_CONTOURS] = m_cset != 0;
valid[DRAWMODE_POLYMESH] = m_pmesh != 0;
valid[DRAWMODE_POLYMESH_DETAIL] = m_dmesh != 0;
}
int unavail = 0;
for (int i = 0; i < MAX_DRAWMODE; ++i)
if (!valid[i]) unavail++;
if (unavail == MAX_DRAWMODE)
return;
imguiLabel("Draw");
if (imguiCheck("Input Mesh", m_drawMode == DRAWMODE_MESH, valid[DRAWMODE_MESH]))
m_drawMode = DRAWMODE_MESH;
if (imguiCheck("Navmesh", m_drawMode == DRAWMODE_NAVMESH, valid[DRAWMODE_NAVMESH]))
m_drawMode = DRAWMODE_NAVMESH;
if (imguiCheck("Navmesh Invis", m_drawMode == DRAWMODE_NAVMESH_INVIS, valid[DRAWMODE_NAVMESH_INVIS]))
m_drawMode = DRAWMODE_NAVMESH_INVIS;
if (imguiCheck("Navmesh Trans", m_drawMode == DRAWMODE_NAVMESH_TRANS, valid[DRAWMODE_NAVMESH_TRANS]))
m_drawMode = DRAWMODE_NAVMESH_TRANS;
if (imguiCheck("Navmesh BVTree", m_drawMode == DRAWMODE_NAVMESH_BVTREE, valid[DRAWMODE_NAVMESH_BVTREE]))
m_drawMode = DRAWMODE_NAVMESH_BVTREE;
if (imguiCheck("Navmesh Nodes", m_drawMode == DRAWMODE_NAVMESH_NODES, valid[DRAWMODE_NAVMESH_NODES]))
m_drawMode = DRAWMODE_NAVMESH_NODES;
if (imguiCheck("Navmesh Portals", m_drawMode == DRAWMODE_NAVMESH_PORTALS, valid[DRAWMODE_NAVMESH_PORTALS]))
m_drawMode = DRAWMODE_NAVMESH_PORTALS;
if (imguiCheck("Voxels", m_drawMode == DRAWMODE_VOXELS, valid[DRAWMODE_VOXELS]))
m_drawMode = DRAWMODE_VOXELS;
if (imguiCheck("Walkable Voxels", m_drawMode == DRAWMODE_VOXELS_WALKABLE, valid[DRAWMODE_VOXELS_WALKABLE]))
m_drawMode = DRAWMODE_VOXELS_WALKABLE;
if (imguiCheck("Compact", m_drawMode == DRAWMODE_COMPACT, valid[DRAWMODE_COMPACT]))
m_drawMode = DRAWMODE_COMPACT;
if (imguiCheck("Compact Distance", m_drawMode == DRAWMODE_COMPACT_DISTANCE, valid[DRAWMODE_COMPACT_DISTANCE]))
m_drawMode = DRAWMODE_COMPACT_DISTANCE;
if (imguiCheck("Compact Regions", m_drawMode == DRAWMODE_COMPACT_REGIONS, valid[DRAWMODE_COMPACT_REGIONS]))
m_drawMode = DRAWMODE_COMPACT_REGIONS;
if (imguiCheck("Region Connections", m_drawMode == DRAWMODE_REGION_CONNECTIONS, valid[DRAWMODE_REGION_CONNECTIONS]))
m_drawMode = DRAWMODE_REGION_CONNECTIONS;
if (imguiCheck("Raw Contours", m_drawMode == DRAWMODE_RAW_CONTOURS, valid[DRAWMODE_RAW_CONTOURS]))
m_drawMode = DRAWMODE_RAW_CONTOURS;
if (imguiCheck("Both Contours", m_drawMode == DRAWMODE_BOTH_CONTOURS, valid[DRAWMODE_BOTH_CONTOURS]))
m_drawMode = DRAWMODE_BOTH_CONTOURS;
if (imguiCheck("Contours", m_drawMode == DRAWMODE_CONTOURS, valid[DRAWMODE_CONTOURS]))
m_drawMode = DRAWMODE_CONTOURS;
if (imguiCheck("Poly Mesh", m_drawMode == DRAWMODE_POLYMESH, valid[DRAWMODE_POLYMESH]))
m_drawMode = DRAWMODE_POLYMESH;
if (imguiCheck("Poly Mesh Detail", m_drawMode == DRAWMODE_POLYMESH_DETAIL, valid[DRAWMODE_POLYMESH_DETAIL]))
m_drawMode = DRAWMODE_POLYMESH_DETAIL;
if (unavail)
{
imguiValue("Tick 'Keep Itermediate Results'");
imguiValue("rebuild some tiles to see");
imguiValue("more debug mode options.");
}
}
void sInterface()
{
int menuWidth = 200;
ui.mouseOverMenu = false;
if (ui.showMenu)
{
bool over = imguiBeginScrollArea("Testbed Controls", g_camera.m_width - menuWidth - 10, 10, menuWidth, g_camera.m_height - 20, &ui.scrollarea1);
if (over) ui.mouseOverMenu = true;
imguiSeparatorLine();
imguiLabel("Script");
if (imguiButton(entry->name, true))
{
ui.chooseTest = !ui.chooseTest;
}
imguiSeparatorLine();
imguiSlider("Vel Iters", &settings.velocityIterations, 0, 50, 1, true);
imguiSlider("Pos Iters", &settings.positionIterations, 0, 50, 1, true);
imguiSlider("Hertz", &settings.hz, 5.0f, 120.0f, 5.0f, true);
if (imguiCheck("Sleep", settings.enableSleep, true))
settings.enableSleep = !settings.enableSleep;
if (imguiCheck("Warm Starting", settings.enableWarmStarting, true))
settings.enableWarmStarting = !settings.enableWarmStarting;
if (imguiCheck("Time of Impact", settings.enableContinuous, true))
settings.enableContinuous = !settings.enableContinuous;
if (imguiCheck("Sub-Stepping", settings.enableSubStepping, true))
settings.enableSubStepping = !settings.enableSubStepping;
imguiSeparatorLine();
if (imguiCheck("Shapes", settings.drawShapes, true))
settings.drawShapes = !settings.drawShapes;
if (imguiCheck("Joints", settings.drawJoints, true))
settings.drawJoints = !settings.drawJoints;
if (imguiCheck("AABBs", settings.drawAABBs, true))
settings.drawAABBs = !settings.drawAABBs;
if (imguiCheck("Contact Points", settings.drawContactPoints, true))
settings.drawContactPoints = !settings.drawContactPoints;
if (imguiCheck("Contact Normals", settings.drawContactNormals, true))
settings.drawContactNormals = !settings.drawContactNormals;
if (imguiCheck("Contact Impulses", settings.drawContactImpulse, true))
settings.drawContactImpulse = !settings.drawContactImpulse;
if (imguiCheck("Friction Impulses", settings.drawFrictionImpulse, true))
settings.drawFrictionImpulse = !settings.drawFrictionImpulse;
if (imguiCheck("Center of Masses", settings.drawCOMs, true))
settings.drawCOMs = !settings.drawCOMs;
if (imguiCheck("Statistics", settings.drawStats, true))
settings.drawStats = !settings.drawStats;
if (imguiCheck("Profile", settings.drawProfile, true))
settings.drawProfile = !settings.drawProfile;
if (imguiButton("Pause", true))
settings.pause = !settings.pause;
if (imguiButton("Single Step", true))
settings.singleStep = !settings.singleStep;
if (imguiButton("Restart", true))
sRestart();
if (imguiButton("Quit", true))
glfwSetWindowShouldClose(mainWindow, GL_TRUE);
imguiEndScrollArea();
}
int testMenuWidth = 200;
if (ui.chooseTest)
{
static int testScroll = 0;
bool over = imguiBeginScrollArea("Choose Script", g_camera.m_width - menuWidth - testMenuWidth - 20, 10, testMenuWidth, g_camera.m_height - 20, &testScroll);
if (over) ui.mouseOverMenu = true;
// for (int i = 0; i < testCount; ++i)
size_t i = 0;
for(auto const& s : b2d_scripts)
{
if (imguiItem(s.name.c_str(), true))
{
script_index = i;
delete test;
//entry = g_testEntries + i;
test = entry->createFcn(b2d_scripts[script_index].filepath);
ui.chooseTest = false;
}
++i;
}
imguiEndScrollArea();
}
imguiEndFrame();
}
int main( int argc, char **argv )
{
int width = 1024, height=768;
float widthf = (float) width, heightf = (float) height;
double t;
float fps = 0.f;
// Initialise GLFW
if( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
exit( EXIT_FAILURE );
}
// Force core profile on Mac OSX
#ifdef __APPLE__
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#endif
// Open a window and create its OpenGL context
if( !glfwOpenWindow( width, height, 0,0,0,0, 24, 0, GLFW_WINDOW ) )
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();
exit( EXIT_FAILURE );
}
glfwSetWindowTitle( "002_forward_a" );
// Core profile is flagged as experimental in glew
#ifdef __APPLE__
glewExperimental = GL_TRUE;
#endif
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
exit( EXIT_FAILURE );
}
// Ensure we can capture the escape key being pressed below
glfwEnable( GLFW_STICKY_KEYS );
// Enable vertical sync (on cards that support it)
glfwSwapInterval( 1 );
GLenum glerr = GL_NO_ERROR;
glerr = glGetError();
if (!imguiRenderGLInit(DroidSans_ttf, DroidSans_ttf_len))
{
fprintf(stderr, "Could not init GUI renderer.\n");
exit(EXIT_FAILURE);
}
// Init viewer structures
Camera camera;
camera_defaults(camera);
GUIStates guiStates;
init_gui_states(guiStates);
// GUI
float numLights = 10.f;
// Load images and upload textures
GLuint textures[3];
glGenTextures(3, textures);
int x;
int y;
int comp;
unsigned char * diffuse = stbi_load("textures/spnza_bricks_a_diff.tga", &x, &y, &comp, 3);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, x, y, 0, GL_RGB, GL_UNSIGNED_BYTE, diffuse);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fprintf(stderr, "Diffuse %dx%d:%d\n", x, y, comp);
unsigned char * spec = stbi_load("textures/spnza_bricks_a_spec.tga", &x, &y, &comp, 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, x, y, 0, GL_RED, GL_UNSIGNED_BYTE, spec);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fprintf(stderr, "Spec %dx%d:%d\n", x, y, comp);
// Try to load and compile shader
int status;
ShaderGLSL gbuffer_shader;
const char * shaderFileGBuffer = "002/2_gbuffera.glsl";
//int status = load_shader_from_file(gbuffer_shader, shaderFileGBuffer, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER | ShaderGLSL::GEOMETRY_SHADER);
status = load_shader_from_file(gbuffer_shader, shaderFileGBuffer, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER);
if ( status == -1 )
{
fprintf(stderr, "Error on loading %s\n", shaderFileGBuffer);
exit( EXIT_FAILURE );
}
// Compute locations for gbuffer_shader
GLuint gbuffer_projectionLocation = glGetUniformLocation(gbuffer_shader.program, "Projection");
GLuint gbuffer_viewLocation = glGetUniformLocation(gbuffer_shader.program, "View");
GLuint gbuffer_objectLocation = glGetUniformLocation(gbuffer_shader.program, "Object");
GLuint gbuffer_timeLocation = glGetUniformLocation(gbuffer_shader.program, "Time");
GLuint gbuffer_diffuseLocation = glGetUniformLocation(gbuffer_shader.program, "Diffuse");
GLuint gbuffer_specLocation = glGetUniformLocation(gbuffer_shader.program, "Spec");
// Load Blit shader
ShaderGLSL blit_shader;
const char * shaderFileBlit = "002/2_blita.glsl";
//int status = load_shader_from_file(blit_shader, shaderFileBlit, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER | ShaderGLSL::GEOMETRY_SHADER);
status = load_shader_from_file(blit_shader, shaderFileBlit, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER);
if ( status == -1 )
{
fprintf(stderr, "Error on loading %s\n", shaderFileBlit);
exit( EXIT_FAILURE );
}
// Compute locations for blit_shader
GLuint blit_tex1Location = glGetUniformLocation(blit_shader.program, "Texture1");
// Load light accumulation shader
ShaderGLSL lighting_shader;
const char * shaderFileLighting = "002/2_lighta.glsl";
//int status = load_shader_from_file(lighting_shader, shaderFileLighting, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER | ShaderGLSL::GEOMETRY_SHADER);
status = load_shader_from_file(lighting_shader, shaderFileLighting, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER);
if ( status == -1 )
{
fprintf(stderr, "Error on loading %s\n", shaderFileLighting);
exit( EXIT_FAILURE );
}
// Compute locations for lighting_shader
GLuint lighting_materialLocation = glGetUniformLocation(lighting_shader.program, "Material");
GLuint lighting_normalLocation = glGetUniformLocation(lighting_shader.program, "Normal");
GLuint lighting_depthLocation = glGetUniformLocation(lighting_shader.program, "Depth");
GLuint lighting_inverseViewProjectionLocation = glGetUniformLocation(lighting_shader.program, "InverseViewProjection");
GLuint lighting_cameraPositionLocation = glGetUniformLocation(lighting_shader.program, "CameraPosition");
GLuint lighting_lightPositionLocation = glGetUniformLocation(lighting_shader.program, "LightPosition");
GLuint lighting_lightColorLocation = glGetUniformLocation(lighting_shader.program, "LightColor");
GLuint lighting_lightIntensityLocation = glGetUniformLocation(lighting_shader.program, "LightIntensity");
// Load geometry
int cube_triangleCount = 12;
int cube_triangleList[] = {0, 1, 2, 2, 1, 3, 4, 5, 6, 6, 5, 7, 8, 9, 10, 10, 9, 11, 12, 13, 14, 14, 13, 15, 16, 17, 18, 19, 17, 20, 21, 22, 23, 24, 25, 26, };
float cube_uvs[] = {0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 1.f, 1.f, 0.f, };
float cube_vertices[] = {-0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5 };
float cube_normals[] = {0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, };
int plane_triangleCount = 2;
int plane_triangleList[] = {0, 1, 2, 2, 1, 3};
float plane_uvs[] = {0.f, 0.f, 0.f, 10.f, 10.f, 0.f, 10.f, 10.f};
float plane_vertices[] = {-50.0, -1.0, 50.0, 50.0, -1.0, 50.0, -50.0, -1.0, -50.0, 50.0, -1.0, -50.0};
float plane_normals[] = {0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0};
int quad_triangleCount = 2;
int quad_triangleList[] = {0, 1, 2, 2, 1, 3};
float quad_vertices[] = {-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0};
// Vertex Array Object
GLuint vao[3];
glGenVertexArrays(3, vao);
// Vertex Buffer Objects
GLuint vbo[12];
glGenBuffers(12, vbo);
// Cube
glBindVertexArray(vao[0]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_triangleList), cube_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices), cube_vertices, GL_STATIC_DRAW);
// Bind normals and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[2]);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_normals), cube_normals, GL_STATIC_DRAW);
// Bind uv coords and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[3]);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_uvs), cube_uvs, GL_STATIC_DRAW);
// Plane
glBindVertexArray(vao[1]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[4]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(plane_triangleList), plane_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[5]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_vertices), plane_vertices, GL_STATIC_DRAW);
// Bind normals and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[6]);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_normals), plane_normals, GL_STATIC_DRAW);
// Bind uv coords and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[7]);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_uvs), plane_uvs, GL_STATIC_DRAW);
// Quad
glBindVertexArray(vao[2]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[8]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quad_triangleList), quad_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[9]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_vertices), quad_vertices, GL_STATIC_DRAW);
// Unbind everything. Potentially illegal on some implementations
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Init frame buffers
GLuint gbufferFbo;
GLuint gbufferTextures[3];
GLuint gbufferDrawBuffers[2];
glGenTextures(3, gbufferTextures);
// Create color texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height, 0, GL_RGBA, GL_FLOAT, 0);
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Create normal texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height, 0, GL_RGBA, GL_FLOAT, 0);
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Create depth texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[2]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Create Framebuffer Object
glGenFramebuffers(1, &gbufferFbo);
glBindFramebuffer(GL_FRAMEBUFFER, gbufferFbo);
// Attach textures to framebuffer
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D, gbufferTextures[0], 0);
gbufferDrawBuffers[0] = GL_COLOR_ATTACHMENT0;
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1 , GL_TEXTURE_2D, gbufferTextures[1], 0);
gbufferDrawBuffers[1] = GL_COLOR_ATTACHMENT1;
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, gbufferTextures[2], 0);
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
fprintf(stderr, "Error on building framebuffer\n");
exit( EXIT_FAILURE );
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
do
{
t = glfwGetTime();
// Mouse states
int leftButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_LEFT );
int rightButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_RIGHT );
int middleButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_MIDDLE );
if( leftButton == GLFW_PRESS )
guiStates.turnLock = true;
else
guiStates.turnLock = false;
if( rightButton == GLFW_PRESS )
guiStates.zoomLock = true;
else
guiStates.zoomLock = false;
if( middleButton == GLFW_PRESS )
guiStates.panLock = true;
else
guiStates.panLock = false;
// Camera movements
int altPressed = glfwGetKey(GLFW_KEY_LSHIFT);
if (!altPressed && (leftButton == GLFW_PRESS || rightButton == GLFW_PRESS || middleButton == GLFW_PRESS))
{
int x; int y;
glfwGetMousePos(&x, &y);
guiStates.lockPositionX = x;
guiStates.lockPositionY = y;
}
if (altPressed == GLFW_PRESS)
{
int mousex; int mousey;
glfwGetMousePos(&mousex, &mousey);
int diffLockPositionX = mousex - guiStates.lockPositionX;
int diffLockPositionY = mousey - guiStates.lockPositionY;
if (guiStates.zoomLock)
{
float zoomDir = 0.0;
if (diffLockPositionX > 0)
zoomDir = -1.f;
else if (diffLockPositionX < 0 )
zoomDir = 1.f;
camera_zoom(camera, zoomDir * GUIStates::MOUSE_ZOOM_SPEED);
}
else if (guiStates.turnLock)
{
camera_turn(camera, diffLockPositionY * GUIStates::MOUSE_TURN_SPEED,
diffLockPositionX * GUIStates::MOUSE_TURN_SPEED);
}
else if (guiStates.panLock)
{
camera_pan(camera, diffLockPositionX * GUIStates::MOUSE_PAN_SPEED,
diffLockPositionY * GUIStates::MOUSE_PAN_SPEED);
}
guiStates.lockPositionX = mousex;
guiStates.lockPositionY = mousey;
}
// Get camera matrices
glm::mat4 projection = glm::perspective(45.0f, widthf / heightf, 0.1f, 100.f);
glm::mat4 worldToView = glm::lookAt(camera.eye, camera.o, camera.up);
glm::mat4 objectToWorld;
glm::mat4 worldToScreen = projection * worldToView;
glm::mat4 screenToWorld = glm::transpose(glm::inverse(worldToScreen));
glBindFramebuffer(GL_FRAMEBUFFER, gbufferFbo);
glDrawBuffers(2, gbufferDrawBuffers);
// Viewport
glViewport( 0, 0, width, height );
// Default states
glEnable(GL_DEPTH_TEST);
// Clear the front buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Bind gbuffer shader
glUseProgram(gbuffer_shader.program);
// Upload uniforms
glUniformMatrix4fv(gbuffer_projectionLocation, 1, 0, glm::value_ptr(projection));
glUniformMatrix4fv(gbuffer_viewLocation, 1, 0, glm::value_ptr(worldToView));
glUniformMatrix4fv(gbuffer_objectLocation, 1, 0, glm::value_ptr(objectToWorld));
glUniform1f(gbuffer_timeLocation, t);
glUniform1i(gbuffer_diffuseLocation, 0);
glUniform1i(gbuffer_specLocation, 1);
// Bind textures
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
// Render vaos
glBindVertexArray(vao[0]);
glDrawElementsInstanced(GL_TRIANGLES, cube_triangleCount * 3, GL_UNSIGNED_INT, (void*)0, 4);
glBindVertexArray(vao[1]);
glDrawElements(GL_TRIANGLES, plane_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
// Unbind framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Viewport
glViewport( 0, 0, width, height );
// Clear the front buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Bind lighting shader
glUseProgram(lighting_shader.program);
// Upload uniforms
glUniform1i(lighting_materialLocation, 0);
glUniform1i(lighting_normalLocation, 1);
glUniform1i(lighting_depthLocation, 2);
glUniform3fv(lighting_cameraPositionLocation, 1, glm::value_ptr(camera.eye));
glUniformMatrix4fv(lighting_inverseViewProjectionLocation, 1, 0, glm::value_ptr(screenToWorld));
// Bind color to unit 0
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, gbufferTextures[0]);
// Bind normal to unit 1
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, gbufferTextures[1]);
// Bind depth to unit 2
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, gbufferTextures[2]);
// Blit above the rest
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
for (int i = 0; i < (int) numLights; ++i)
{
float tl = t * i;
//Update light uniforms
float lightPosition[3] = { sinf(tl) * 10.f, -0.5f, cosf(tl) * 10.f};
float lightColor[3] = {sinf(tl) * 1.f, 1.f - cosf(tl), -sinf(tl)};
float lightIntensity = 10.0;
glUniform3fv(lighting_lightPositionLocation, 1, lightPosition);
glUniform3fv(lighting_lightColorLocation, 1, lightColor);
glUniform1f(lighting_lightIntensityLocation, lightIntensity);
// Draw quad
glBindVertexArray(vao[2]);
glDrawElements(GL_TRIANGLES, quad_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
}
glDisable(GL_BLEND);
// Bind blit shader
glUseProgram(blit_shader.program);
// Upload uniforms
glUniform1i(blit_tex1Location, 0);
// use only unit 0
glActiveTexture(GL_TEXTURE0);
// Viewport
glViewport( 0, 0, width/3, height/4 );
// Bind texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[0]);
// Draw quad
glBindVertexArray(vao[2]);
glDrawElements(GL_TRIANGLES, quad_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
// Viewport
glViewport( width/3, 0, width/3, height/4 );
// Bind texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[1]);
// Draw quad
glBindVertexArray(vao[2]);
glDrawElements(GL_TRIANGLES, quad_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
// Viewport
glViewport( width/3 * 2, 0, width/3, height/4 );
// Bind texture
glBindTexture(GL_TEXTURE_2D, gbufferTextures[2]);
// Draw quad
glBindVertexArray(vao[2]);
glDrawElements(GL_TRIANGLES, quad_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
#if 1
// Draw UI
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glViewport(0, 0, width, height);
unsigned char mbut = 0;
int mscroll = 0;
int mousex; int mousey;
glfwGetMousePos(&mousex, &mousey);
mousey = height - mousey;
if( leftButton == GLFW_PRESS )
mbut |= IMGUI_MBUT_LEFT;
imguiBeginFrame(mousex, mousey, mbut, mscroll);
int logScroll = 0;
char lineBuffer[512];
imguiBeginScrollArea("001", width - 210, height - 310, 200, 300, &logScroll);
sprintf(lineBuffer, "FPS %f", fps);
imguiLabel(lineBuffer);
imguiSlider("Lights", &numLights, 0.0, 100.0, 1.0);
imguiEndScrollArea();
imguiEndFrame();
imguiRenderGLDraw(width, height);
glDisable(GL_BLEND);
#endif
// Check for errors
GLenum err = glGetError();
if(err != GL_NO_ERROR)
{
fprintf(stderr, "OpenGL Error : %s\n", gluErrorString(err));
}
// Swap buffers
glfwSwapBuffers();
} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
glfwGetWindowParam( GLFW_OPENED ) );
// Clean UI
imguiRenderGLDestroy();
// Close OpenGL window and terminate GLFW
glfwTerminate();
exit( EXIT_SUCCESS );
}
void Sample_TileMesh::handleSettings()
{
Sample::handleCommonSettings();
if (imguiCheck("Keep Itermediate Results", m_keepInterResults))
m_keepInterResults = !m_keepInterResults;
if (imguiCheck("Build All Tiles", m_buildAll))
m_buildAll = !m_buildAll;
imguiLabel("Tiling");
imguiSlider("TileSize", &m_tileSize, 16.0f, 1024.0f, 16.0f);
if (m_geom)
{
char text[64];
int gw = 0, gh = 0;
const float* bmin = m_geom->getNavMeshBoundsMin();
const float* bmax = m_geom->getNavMeshBoundsMax();
rcCalcGridSize(bmin, bmax, m_cellSize, &gw, &gh);
const int ts = (int)m_tileSize;
const int tw = (gw + ts-1) / ts;
const int th = (gh + ts-1) / ts;
snprintf(text, 64, "Tiles %d x %d", tw, th);
imguiValue(text);
// Max tiles and max polys affect how the tile IDs are caculated.
// There are 22 bits available for identifying a tile and a polygon.
int tileBits = rcMin((int)ilog2(nextPow2(tw*th)), 14);
if (tileBits > 14) tileBits = 14;
int polyBits = 22 - tileBits;
m_maxTiles = 1 << tileBits;
m_maxPolysPerTile = 1 << polyBits;
snprintf(text, 64, "Max Tiles %d", m_maxTiles);
imguiValue(text);
snprintf(text, 64, "Max Polys %d", m_maxPolysPerTile);
imguiValue(text);
}
else
{
m_maxTiles = 0;
m_maxPolysPerTile = 0;
}
imguiSeparator();
imguiIndent();
imguiIndent();
if (imguiButton("Save"))
{
Sample::saveAll("all_tiles_navmesh.bin", m_navMesh);
}
if (imguiButton("Load"))
{
dtFreeNavMesh(m_navMesh);
m_navMesh = Sample::loadAll("all_tiles_navmesh.bin");
m_navQuery->init(m_navMesh, 2048);
}
imguiUnindent();
imguiUnindent();
char msg[64];
snprintf(msg, 64, "Build Time: %.1fms", m_totalBuildTimeMs);
imguiLabel(msg);
imguiSeparator();
imguiSeparator();
}
BX_NO_INLINE bool mainloop()
{
if (!entry::processEvents(width, height, debug, reset, &mouseState) )
{
int64_t now = bx::getHPCounter();
static int64_t last = now;
const int64_t hpFreq = bx::getHPFrequency();
const int64_t frameTime = now - last;
last = now;
const double freq = double(hpFreq);
const double toMs = 1000.0/freq;
deltaTimeNs += frameTime*1000000/hpFreq;
if (deltaTimeNs > 1000000)
{
deltaTimeAvgNs = deltaTimeNs / bx::int64_max(1, numFrames);
if (autoAdjust)
{
if (deltaTimeAvgNs < highwm)
{
dim = bx::uint32_min(dim + 2, 40);
}
else if (deltaTimeAvgNs > lowwm)
{
dim = bx::uint32_max(dim - 1, 2);
}
}
deltaTimeNs = 0;
numFrames = 0;
}
else
{
++numFrames;
}
float time = (float)( (now-timeOffset)/freq);
imguiBeginFrame(mouseState.m_mx
, mouseState.m_my
, (mouseState.m_buttons[entry::MouseButton::Left ] ? IMGUI_MBUT_LEFT : 0)
| (mouseState.m_buttons[entry::MouseButton::Right ] ? IMGUI_MBUT_RIGHT : 0)
, 0
, width
, height
);
imguiBeginScrollArea("Settings", width - width / 4 - 10, 10, width / 4, height / 3, &scrollArea);
imguiSeparatorLine();
transform = imguiChoose(transform
, "Rotate"
, "No fragments"
);
imguiSeparatorLine();
if (imguiCheck("Auto adjust", autoAdjust) )
{
autoAdjust ^= true;
}
imguiSlider("Dim", dim, 5, 40);
imguiLabel("Draw calls: %d", dim*dim*dim);
imguiLabel("Avg Delta Time (1 second) [ms]: %0.4f", deltaTimeAvgNs/1000.0f);
imguiEndScrollArea();
imguiEndFrame();
float at[3] = { 0.0f, 0.0f, 0.0f };
float eye[3] = { 0.0f, 0.0f, -35.0f };
float view[16];
float proj[16];
bx::mtxLookAt(view, eye, at);
bx::mtxProj(proj, 60.0f, float(width)/float(height), 0.1f, 100.0f);
// Set view and projection matrix for view 0.
bgfx::setViewTransform(0, view, proj);
// Set view 0 default viewport.
bgfx::setViewRect(0, 0, 0, width, height);
// 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::submit(0);
// Use debug font to print information about this example.
bgfx::dbgTextClear();
bgfx::dbgTextPrintf(0, 1, 0x4f, "bgfx/examples/17-drawstress");
bgfx::dbgTextPrintf(0, 2, 0x6f, "Description: Draw stress, maximizing number of draw calls.");
bgfx::dbgTextPrintf(0, 3, 0x0f, "Frame: %7.3f[ms]", double(frameTime)*toMs);
float mtxS[16];
const float scale = 0 == transform ? 0.25f : 0.0f;
bx::mtxScale(mtxS, scale, scale, scale);
const float step = 0.6f;
float pos[3];
pos[0] = -step*dim / 2.0f;
pos[1] = -step*dim / 2.0f;
pos[2] = -15.0;
for (uint32_t zz = 0; zz < uint32_t(dim); ++zz)
{
for (uint32_t yy = 0; yy < uint32_t(dim); ++yy)
{
for (uint32_t xx = 0; xx < uint32_t(dim); ++xx)
{
float mtxR[16];
bx::mtxRotateXYZ(mtxR, time + xx*0.21f, time + yy*0.37f, time + yy*0.13f);
float mtx[16];
bx::mtxMul(mtx, mtxS, mtxR);
mtx[12] = pos[0] + float(xx)*step;
mtx[13] = pos[1] + float(yy)*step;
mtx[14] = pos[2] + float(zz)*step;
// Set model matrix for rendering.
bgfx::setTransform(mtx);
// Set vertex and fragment shaders.
bgfx::setProgram(program);
// Set vertex and index buffer.
bgfx::setVertexBuffer(vbh);
bgfx::setIndexBuffer(ibh);
// Set render states.
bgfx::setState(BGFX_STATE_DEFAULT);
// Submit primitive for rendering to view 0.
bgfx::submit(0);
}
}
}
// Advance to next frame. Rendering thread will be kicked to
// process submitted rendering primitives.
bgfx::frame();
return false;
}
return true;
}
int main(int /*argc*/, char** /*argv*/)
{
// Init SDL
if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
{
printf("Could not initialise SDL\n");
return -1;
}
// Center window
char env[] = "SDL_VIDEO_CENTERED=1";
putenv(env);
// Init OpenGL
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
//#ifndef WIN32
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
//#endif
const SDL_VideoInfo* vi = SDL_GetVideoInfo();
bool presentationMode = false;
int width, height;
SDL_Surface* screen = 0;
if (presentationMode)
{
width = 1700;
height = 1000;
screen = SDL_SetVideoMode(width, height, 0, SDL_OPENGL|SDL_FULLSCREEN);
}
else
{
width = 1700;
height = 1000;
screen = SDL_SetVideoMode(width, height, 0, SDL_OPENGL);
}
if (!screen)
{
printf("Could not initialise SDL opengl\n");
return -1;
}
glEnable(GL_MULTISAMPLE);
SDL_WM_SetCaption("Recast Demo", 0);
if (!imguiRenderGLInit("DroidSans.ttf"))
{
printf("Could not init GUI renderer.\n");
SDL_Quit();
return -1;
}
float t = 0.0f;
float timeAcc = 0.0f;
Uint32 lastTime = SDL_GetTicks();
int mx = 0, my = 0;
float rx = 45;
float ry = -45;
float moveW = 0, moveS = 0, moveA = 0, moveD = 0;
float camx = 0, camy = 0, camz = 0, camr = 1000;
float origrx = 0, origry = 0;
int origx = 0, origy = 0;
float scrollZoom = 0;
bool rotate = false;
bool movedDuringRotate = false;
float rays[3], raye[3];
bool mouseOverMenu = false;
bool showMenu = !presentationMode;
bool showLog = false;
bool showTools = true;
bool showLevels = false;
bool showSample = false;
bool showTestCases = false;
int propScroll = 0;
int logScroll = 0;
int toolsScroll = 0;
char sampleName[64] = "Choose Sample...";
FileList files;
char meshName[128] = "Choose Mesh...";
float mpos[3] = {0,0,0};
bool mposSet = false;
SlideShow slideShow;
slideShow.init("slides/");
InputGeom* geom = 0;
Sample* sample = 0;
TestCase* test = 0;
BuildContext ctx;
glEnable(GL_CULL_FACE);
float fogCol[4] = { 0.32f, 0.31f, 0.30f, 1.0f };
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, camr*0.1f);
glFogf(GL_FOG_END, camr*1.25f);
glFogfv(GL_FOG_COLOR, fogCol);
glDepthFunc(GL_LEQUAL);
bool done = false;
while(!done)
{
// Handle input events.
int mscroll = 0;
bool processHitTest = false;
bool processHitTestShift = false;
SDL_Event event;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_KEYDOWN:
// Handle any key presses here.
if (event.key.keysym.sym == SDLK_ESCAPE)
{
done = true;
}
else if (event.key.keysym.sym == SDLK_t)
{
showLevels = false;
showSample = false;
showTestCases = true;
scanDirectory("Tests", ".txt", files);
}
else if (event.key.keysym.sym == SDLK_TAB)
{
showMenu = !showMenu;
}
else if (event.key.keysym.sym == SDLK_SPACE)
{
if (sample)
sample->handleToggle();
}
else if (event.key.keysym.sym == SDLK_1)
{
if (sample)
sample->handleStep();
}
else if (event.key.keysym.sym == SDLK_9)
{
if (geom)
geom->save("geomset.txt");
}
else if (event.key.keysym.sym == SDLK_0)
{
delete geom;
geom = new InputGeom;
if (!geom || !geom->load(&ctx, "geomset.txt"))
{
delete geom;
geom = 0;
showLog = true;
logScroll = 0;
ctx.dumpLog("Geom load log %s:", meshName);
}
if (sample && geom)
{
sample->handleMeshChanged(geom);
}
if (geom || sample)
{
const float* bmin = 0;
const float* bmax = 0;
if (sample)
{
bmin = sample->getBoundsMin();
bmax = sample->getBoundsMax();
}
else if (geom)
{
bmin = geom->getMeshBoundsMin();
bmax = geom->getMeshBoundsMax();
}
// Reset camera and fog to match the mesh bounds.
if (bmin && bmax)
{
camr = sqrtf(rcSqr(bmax[0]-bmin[0]) +
rcSqr(bmax[1]-bmin[1]) +
rcSqr(bmax[2]-bmin[2])) / 2;
camx = (bmax[0] + bmin[0]) / 2 + camr;
camy = (bmax[1] + bmin[1]) / 2 + camr;
camz = (bmax[2] + bmin[2]) / 2 + camr;
camr *= 3;
}
rx = 45;
ry = -45;
glFogf(GL_FOG_START, camr*0.2f);
glFogf(GL_FOG_END, camr*1.25f);
}
}
else if (event.key.keysym.sym == SDLK_RIGHT)
{
slideShow.nextSlide();
}
else if (event.key.keysym.sym == SDLK_LEFT)
{
slideShow.prevSlide();
}
break;
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_RIGHT)
{
if (!mouseOverMenu)
{
// Rotate view
rotate = true;
movedDuringRotate = false;
origx = mx;
origy = my;
origrx = rx;
origry = ry;
}
}
else if (event.button.button == SDL_BUTTON_WHEELUP)
{
if (mouseOverMenu)
mscroll--;
else
scrollZoom -= 1.0f;
}
else if (event.button.button == SDL_BUTTON_WHEELDOWN)
{
if (mouseOverMenu)
mscroll++;
else
scrollZoom += 1.0f;
}
break;
case SDL_MOUSEBUTTONUP:
// Handle mouse clicks here.
if (event.button.button == SDL_BUTTON_RIGHT)
{
rotate = false;
if (!mouseOverMenu)
{
if (!movedDuringRotate)
{
processHitTest = true;
processHitTestShift = true;
}
}
}
else if (event.button.button == SDL_BUTTON_LEFT)
{
if (!mouseOverMenu)
{
processHitTest = true;
processHitTestShift = (SDL_GetModState() & KMOD_SHIFT) ? true : false;
}
}
break;
case SDL_MOUSEMOTION:
mx = event.motion.x;
my = height-1 - event.motion.y;
if (rotate)
{
int dx = mx - origx;
int dy = my - origy;
rx = origrx - dy*0.25f;
ry = origry + dx*0.25f;
if (dx*dx+dy*dy > 3*3)
movedDuringRotate = true;
}
break;
case SDL_QUIT:
done = true;
break;
default:
break;
}
}
unsigned char mbut = 0;
if (SDL_GetMouseState(0,0) & SDL_BUTTON_LMASK)
mbut |= IMGUI_MBUT_LEFT;
if (SDL_GetMouseState(0,0) & SDL_BUTTON_RMASK)
mbut |= IMGUI_MBUT_RIGHT;
Uint32 time = SDL_GetTicks();
float dt = (time - lastTime) / 1000.0f;
lastTime = time;
t += dt;
// Hit test mesh.
if (processHitTest && geom && sample)
{
float hitt;
bool hit = geom->raycastMesh(rays, raye, hitt);
if (hit)
{
if (SDL_GetModState() & KMOD_CTRL)
{
// Marker
mposSet = true;
mpos[0] = rays[0] + (raye[0] - rays[0])*hitt;
mpos[1] = rays[1] + (raye[1] - rays[1])*hitt;
mpos[2] = rays[2] + (raye[2] - rays[2])*hitt;
}
else
{
float pos[3];
pos[0] = rays[0] + (raye[0] - rays[0])*hitt;
pos[1] = rays[1] + (raye[1] - rays[1])*hitt;
pos[2] = rays[2] + (raye[2] - rays[2])*hitt;
sample->handleClick(rays, pos, processHitTestShift);
}
}
else
{
if (SDL_GetModState() & KMOD_CTRL)
{
// Marker
mposSet = false;
}
}
}
// Update sample simulation.
const float SIM_RATE = 20;
const float DELTA_TIME = 1.0f/SIM_RATE;
timeAcc = rcClamp(timeAcc+dt, -1.0f, 1.0f);
int simIter = 0;
while (timeAcc > DELTA_TIME)
{
timeAcc -= DELTA_TIME;
if (simIter < 5)
{
if (sample)
sample->handleUpdate(DELTA_TIME);
}
simIter++;
}
// Clamp the framerate so that we do not hog all the CPU.
const float MIN_FRAME_TIME = 1.0f/40.0f;
if (dt < MIN_FRAME_TIME)
{
int ms = (int)((MIN_FRAME_TIME - dt)*1000.0f);
if (ms > 10) ms = 10;
if (ms >= 0)
SDL_Delay(ms);
}
// Update and render
glViewport(0, 0, width, height);
glClearColor(0.3f, 0.3f, 0.32f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_TEXTURE_2D);
// Render 3d
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0f, (float)width/(float)height, 1.0f, camr);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotatef(rx,1,0,0);
glRotatef(ry,0,1,0);
glTranslatef(-camx, -camy, -camz);
// Get hit ray position and direction.
GLdouble proj[16];
GLdouble model[16];
GLint view[4];
glGetDoublev(GL_PROJECTION_MATRIX, proj);
glGetDoublev(GL_MODELVIEW_MATRIX, model);
glGetIntegerv(GL_VIEWPORT, view);
GLdouble x, y, z;
gluUnProject(mx, my, 0.0f, model, proj, view, &x, &y, &z);
rays[0] = (float)x; rays[1] = (float)y; rays[2] = (float)z;
gluUnProject(mx, my, 1.0f, model, proj, view, &x, &y, &z);
raye[0] = (float)x; raye[1] = (float)y; raye[2] = (float)z;
// Handle keyboard movement.
Uint8* keystate = SDL_GetKeyState(NULL);
moveW = rcClamp(moveW + dt * 4 * (keystate[SDLK_w] ? 1 : -1), 0.0f, 1.0f);
moveS = rcClamp(moveS + dt * 4 * (keystate[SDLK_s] ? 1 : -1), 0.0f, 1.0f);
moveA = rcClamp(moveA + dt * 4 * (keystate[SDLK_a] ? 1 : -1), 0.0f, 1.0f);
moveD = rcClamp(moveD + dt * 4 * (keystate[SDLK_d] ? 1 : -1), 0.0f, 1.0f);
float keybSpeed = 22.0f;
if (SDL_GetModState() & KMOD_SHIFT)
keybSpeed *= 4.0f;
float movex = (moveD - moveA) * keybSpeed * dt;
float movey = (moveS - moveW) * keybSpeed * dt;
movey += scrollZoom * 2.0f;
scrollZoom = 0;
camx += movex * (float)model[0];
camy += movex * (float)model[4];
camz += movex * (float)model[8];
camx += movey * (float)model[2];
camy += movey * (float)model[6];
camz += movey * (float)model[10];
glEnable(GL_FOG);
if (sample)
sample->handleRender();
if (test)
test->handleRender();
glDisable(GL_FOG);
// Render GUI
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, width, 0, height);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
mouseOverMenu = false;
imguiBeginFrame(mx,my,mbut,mscroll);
if (sample)
{
sample->handleRenderOverlay((double*)proj, (double*)model, (int*)view);
}
if (test)
{
if (test->handleRenderOverlay((double*)proj, (double*)model, (int*)view))
mouseOverMenu = true;
}
// Help text.
if (showMenu)
{
const char msg[] = "W/S/A/D: Move RMB: Rotate";
imguiDrawText(280, height-20, IMGUI_ALIGN_LEFT, msg, imguiRGBA(255,255,255,128));
}
if (showMenu)
{
if (imguiBeginScrollArea("Properties", width-250-10, 10, 250, height-20, &propScroll))
mouseOverMenu = true;
if (imguiCheck("Show Log", showLog))
showLog = !showLog;
if (imguiCheck("Show Tools", showTools))
showTools = !showTools;
imguiSeparator();
imguiLabel("Sample");
if (imguiButton(sampleName))
{
if (showSample)
{
showSample = false;
}
else
{
showSample = true;
showLevels = false;
showTestCases = false;
}
}
imguiSeparator();
imguiLabel("Input Mesh");
if (imguiButton(meshName))
{
if (showLevels)
{
showLevels = false;
}
else
{
showSample = false;
showTestCases = false;
showLevels = true;
scanDirectory("Meshes", ".obj", files);
}
}
if (geom)
{
char text[64];
snprintf(text, 64, "Verts: %.1fk Tris: %.1fk",
geom->getMesh()->getVertCount()/1000.0f,
geom->getMesh()->getTriCount()/1000.0f);
imguiValue(text);
}
imguiSeparator();
if (geom && sample)
{
imguiSeparatorLine();
sample->handleSettings();
if (imguiButton("Build"))
{
ctx.resetLog();
if (!sample->handleBuild())
{
showLog = true;
logScroll = 0;
}
ctx.dumpLog("Build log %s:", meshName);
// Clear test.
delete test;
test = 0;
}
imguiSeparator();
}
if (sample)
{
imguiSeparatorLine();
sample->handleDebugMode();
}
imguiEndScrollArea();
}
// Sample selection dialog.
if (showSample)
{
static int levelScroll = 0;
if (imguiBeginScrollArea("Choose Sample", width-10-250-10-200, height-10-250, 200, 250, &levelScroll))
mouseOverMenu = true;
Sample* newSample = 0;
for (int i = 0; i < g_nsamples; ++i)
{
if (imguiItem(g_samples[i].name))
{
newSample = g_samples[i].create();
if (newSample)
strcpy(sampleName, g_samples[i].name);
}
}
if (newSample)
{
delete sample;
sample = newSample;
sample->setContext(&ctx);
if (geom && sample)
{
sample->handleMeshChanged(geom);
}
showSample = false;
}
if (geom || sample)
{
const float* bmin = 0;
const float* bmax = 0;
if (sample)
{
bmin = sample->getBoundsMin();
bmax = sample->getBoundsMax();
}
else if (geom)
{
bmin = geom->getMeshBoundsMin();
bmax = geom->getMeshBoundsMax();
}
// Reset camera and fog to match the mesh bounds.
if (bmin && bmax)
{
camr = sqrtf(rcSqr(bmax[0]-bmin[0]) +
rcSqr(bmax[1]-bmin[1]) +
rcSqr(bmax[2]-bmin[2])) / 2;
camx = (bmax[0] + bmin[0]) / 2 + camr;
camy = (bmax[1] + bmin[1]) / 2 + camr;
camz = (bmax[2] + bmin[2]) / 2 + camr;
camr *= 3;
}
rx = 45;
ry = -45;
glFogf(GL_FOG_START, camr*0.1f);
glFogf(GL_FOG_END, camr*1.25f);
}
imguiEndScrollArea();
}
// Level selection dialog.
if (showLevels)
{
static int levelScroll = 0;
if (imguiBeginScrollArea("Choose Level", width-10-250-10-200, height-10-450, 200, 450, &levelScroll))
mouseOverMenu = true;
int levelToLoad = -1;
for (int i = 0; i < files.size; ++i)
{
if (imguiItem(files.files[i]))
levelToLoad = i;
}
if (levelToLoad != -1)
{
strncpy(meshName, files.files[levelToLoad], sizeof(meshName));
meshName[sizeof(meshName)-1] = '\0';
showLevels = false;
delete geom;
geom = 0;
char path[256];
strcpy(path, "Meshes/");
strcat(path, meshName);
geom = new InputGeom;
if (!geom || !geom->loadMesh(&ctx, path))
{
delete geom;
geom = 0;
showLog = true;
logScroll = 0;
ctx.dumpLog("Geom load log %s:", meshName);
}
if (sample && geom)
{
sample->handleMeshChanged(geom);
}
if (geom || sample)
{
const float* bmin = 0;
const float* bmax = 0;
if (sample)
{
bmin = sample->getBoundsMin();
bmax = sample->getBoundsMax();
}
else if (geom)
{
bmin = geom->getMeshBoundsMin();
bmax = geom->getMeshBoundsMax();
}
// Reset camera and fog to match the mesh bounds.
if (bmin && bmax)
{
camr = sqrtf(rcSqr(bmax[0]-bmin[0]) +
rcSqr(bmax[1]-bmin[1]) +
rcSqr(bmax[2]-bmin[2])) / 2;
camx = (bmax[0] + bmin[0]) / 2 + camr;
camy = (bmax[1] + bmin[1]) / 2 + camr;
camz = (bmax[2] + bmin[2]) / 2 + camr;
camr *= 3;
}
rx = 45;
ry = -45;
glFogf(GL_FOG_START, camr*0.1f);
glFogf(GL_FOG_END, camr*1.25f);
}
}
imguiEndScrollArea();
}
// Test cases
if (showTestCases)
{
static int testScroll = 0;
if (imguiBeginScrollArea("Choose Test To Run", width-10-250-10-200, height-10-450, 200, 450, &testScroll))
mouseOverMenu = true;
int testToLoad = -1;
for (int i = 0; i < files.size; ++i)
{
if (imguiItem(files.files[i]))
testToLoad = i;
}
if (testToLoad != -1)
{
char path[256];
strcpy(path, "Tests/");
strcat(path, files.files[testToLoad]);
test = new TestCase;
if (test)
{
// Load the test.
if (!test->load(path))
{
delete test;
test = 0;
}
// Create sample
Sample* newSample = 0;
for (int i = 0; i < g_nsamples; ++i)
{
if (strcmp(g_samples[i].name, test->getSampleName()) == 0)
{
newSample = g_samples[i].create();
if (newSample) strcpy(sampleName, g_samples[i].name);
}
}
if (newSample)
{
delete sample;
sample = newSample;
sample->setContext(&ctx);
showSample = false;
}
// Load geom.
strcpy(meshName, test->getGeomFileName());
meshName[sizeof(meshName)-1] = '\0';
delete geom;
geom = 0;
strcpy(path, "Meshes/");
strcat(path, meshName);
geom = new InputGeom;
if (!geom || !geom->loadMesh(&ctx, path))
{
delete geom;
geom = 0;
showLog = true;
logScroll = 0;
ctx.dumpLog("Geom load log %s:", meshName);
}
if (sample && geom)
{
sample->handleMeshChanged(geom);
}
// This will ensure that tile & poly bits are updated in tiled sample.
if (sample)
sample->handleSettings();
ctx.resetLog();
if (sample && !sample->handleBuild())
{
ctx.dumpLog("Build log %s:", meshName);
}
if (geom || sample)
{
const float* bmin = 0;
const float* bmax = 0;
if (sample)
{
bmin = sample->getBoundsMin();
bmax = sample->getBoundsMax();
}
else if (geom)
{
bmin = geom->getMeshBoundsMin();
bmax = geom->getMeshBoundsMax();
}
// Reset camera and fog to match the mesh bounds.
if (bmin && bmax)
{
camr = sqrtf(rcSqr(bmax[0]-bmin[0]) +
rcSqr(bmax[1]-bmin[1]) +
rcSqr(bmax[2]-bmin[2])) / 2;
camx = (bmax[0] + bmin[0]) / 2 + camr;
camy = (bmax[1] + bmin[1]) / 2 + camr;
camz = (bmax[2] + bmin[2]) / 2 + camr;
camr *= 3;
}
rx = 45;
ry = -45;
glFogf(GL_FOG_START, camr*0.2f);
glFogf(GL_FOG_END, camr*1.25f);
}
// Do the tests.
if (sample)
test->doTests(sample->getNavMesh(), sample->getNavMeshQuery());
}
}
imguiEndScrollArea();
}
// Log
if (showLog && showMenu)
{
if (imguiBeginScrollArea("Log", 250+20, 10, width - 300 - 250, 200, &logScroll))
mouseOverMenu = true;
for (int i = 0; i < ctx.getLogCount(); ++i)
imguiLabel(ctx.getLogText(i));
imguiEndScrollArea();
}
// Tools
if (!showTestCases && showTools && showMenu) // && geom && sample)
{
if (imguiBeginScrollArea("Tools", 10, 10, 250, height-20, &toolsScroll))
mouseOverMenu = true;
if (sample)
sample->handleTools();
imguiEndScrollArea();
}
slideShow.updateAndDraw(dt, (float)width, (float)height);
// Marker
if (mposSet && gluProject((GLdouble)mpos[0], (GLdouble)mpos[1], (GLdouble)mpos[2],
model, proj, view, &x, &y, &z))
{
// Draw marker circle
glLineWidth(5.0f);
glColor4ub(240,220,0,196);
glBegin(GL_LINE_LOOP);
const float r = 25.0f;
for (int i = 0; i < 20; ++i)
{
const float a = (float)i / 20.0f * RC_PI*2;
const float fx = (float)x + cosf(a)*r;
const float fy = (float)y + sinf(a)*r;
glVertex2f(fx,fy);
}
glEnd();
glLineWidth(1.0f);
}
imguiEndFrame();
imguiRenderGLDraw();
glEnable(GL_DEPTH_TEST);
SDL_GL_SwapBuffers();
}
imguiRenderGLDestroy();
SDL_Quit();
delete sample;
delete geom;
return 0;
}
int main( int argc, char **argv )
{
int width = 800, height= 600;
float widthf = (float) width, heightf = (float) height;
double t;
float fps = 0.f;
// Initialise GLFW
if( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
exit( EXIT_FAILURE );
}
// Force core profile on Mac OSX
#ifdef __APPLE__
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#endif
// Open a window and create its OpenGL context
if( !glfwOpenWindow( width, height, 0,0,0,0, 24, 0, GLFW_WINDOW ) )
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();
exit( EXIT_FAILURE );
}
glfwSetWindowTitle( "001_a" );
// Core profile is flagged as experimental in glew
#ifdef __APPLE__
glewExperimental = GL_TRUE;
#endif
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
exit( EXIT_FAILURE );
}
// Ensure we can capture the escape key being pressed below
glfwEnable( GLFW_STICKY_KEYS );
// Enable vertical sync (on cards that support it)
glfwSwapInterval( 1 );
GLenum glerr = GL_NO_ERROR;
glerr = glGetError();
if (!imguiRenderGLInit(DroidSans_ttf, DroidSans_ttf_len))
{
fprintf(stderr, "Could not init GUI renderer.\n");
exit(EXIT_FAILURE);
}
// Init viewer structures
Camera camera;
camera_defaults(camera);
GUIStates guiStates;
init_gui_states(guiStates);
float dummySlider = 0.f;
// Load images and upload textures
GLuint textures[2];
glGenTextures(2, textures);
int x;
int y;
int comp;
unsigned char * diffuse = stbi_load("textures/spnza_bricks_a_diff.tga", &x, &y, &comp, 3);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, x, y, 0, GL_RGB, GL_UNSIGNED_BYTE, diffuse);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fprintf(stderr, "Diffuse %dx%d:%d\n", x, y, comp);
unsigned char * spec = stbi_load("textures/spnza_bricks_a_spec.tga", &x, &y, &comp, 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, x, y, 0, GL_RED, GL_UNSIGNED_BYTE, spec);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fprintf(stderr, "Spec %dx%d:%d\n", x, y, comp);
glerr = glGetError();
if(glerr != GL_NO_ERROR)
fprintf(stderr, "2nd OpenGL Error : %s\n", gluErrorString(glerr));
// Try to load and compile shader
ShaderGLSL shader;
const char * shaderFile = "001/3a.glsl";
//const char * shaderFile = "001/4a.glsl";
//const char * shaderFile = "001/5a.glsl";
//const char * shaderFile = "001/5ba.glsl";
//const char * shaderFile = "001/6a.glsl";
//const char * shaderFile = "001/7a.glsl";
//const char * shaderFile = "001/8a.glsl";
//int status = load_shader_from_file(shader, shaderFile, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER | ShaderGLSL::GEOMETRY_SHADER);
int status = load_shader_from_file(shader, shaderFile, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER);
if ( status == -1 )
{
fprintf(stderr, "Error on loading %s\n", shaderFile);
exit( EXIT_FAILURE );
}
// Apply shader
GLuint program = shader.program;
glUseProgram(program);
GLuint projectionLocation = glGetUniformLocation(program, "Projection");
GLuint viewLocation = glGetUniformLocation(program, "View");
GLuint objectLocation = glGetUniformLocation(program, "Object");
GLuint timeLocation = glGetUniformLocation(program, "Time");
GLuint diffuseLocation = glGetUniformLocation(program, "Diffuse");
GLuint specLocation = glGetUniformLocation(program, "Spec");
GLuint cameraPositionLocation = glGetUniformLocation(program, "CameraPosition");
glUniform1i(diffuseLocation, 0);
glUniform1i(specLocation, 1);
// Load geometry
int cube_triangleCount = 12;
int cube_triangleList[] = {0, 1, 2, 2, 1, 3, 4, 5, 6, 6, 5, 7, 8, 9, 10, 10, 9, 11, 12, 13, 14, 14, 13, 15, 16, 17, 18, 19, 17, 20, 21, 22, 23, 24, 25, 26, };
float cube_uvs[] = {0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 1.f, 1.f, 0.f, };
float cube_vertices[] = {-0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5 };
float cube_normals[] = {0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, };
int plane_triangleCount = 2;
int plane_triangleList[] = {0, 1, 2, 2, 1, 3};
float plane_uvs[] = {0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f};
float plane_vertices[] = {-5.0, -1.0, 5.0, 5.0, -1.0, 5.0, -5.0, -1.0, -5.0, 5.0, -1.0, -5.0};
float plane_normals[] = {0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0};
// Vertex Array Object
GLuint vao[2];
glGenVertexArrays(2, vao);
// Vertex Buffer Objects
GLuint vbo[8];
glGenBuffers(8, vbo);
// Cube
glBindVertexArray(vao[0]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_triangleList), cube_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices), cube_vertices, GL_STATIC_DRAW);
// Bind normals and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[2]);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_normals), cube_normals, GL_STATIC_DRAW);
// Bind uv coords and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[3]);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_uvs), cube_uvs, GL_STATIC_DRAW);
// Plane
glBindVertexArray(vao[1]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[4]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(plane_triangleList), plane_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[5]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_vertices), plane_vertices, GL_STATIC_DRAW);
// Bind normals and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[6]);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_normals), plane_normals, GL_STATIC_DRAW);
// Bind uv coords and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[7]);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_uvs), plane_uvs, GL_STATIC_DRAW);
// Unbind everything. Potentially illegal on some implementations
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Viewport
glViewport( 0, 0, width, height );
do
{
t = glfwGetTime();
// Mouse states
int leftButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_LEFT );
int rightButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_RIGHT );
int middleButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_MIDDLE );
if( leftButton == GLFW_PRESS )
guiStates.turnLock = true;
else
guiStates.turnLock = false;
if( rightButton == GLFW_PRESS )
guiStates.zoomLock = true;
else
guiStates.zoomLock = false;
if( middleButton == GLFW_PRESS )
guiStates.panLock = true;
else
guiStates.panLock = false;
// Camera movements
int altPressed = glfwGetKey(GLFW_KEY_LSHIFT);
if (!altPressed && (leftButton == GLFW_PRESS || rightButton == GLFW_PRESS || middleButton == GLFW_PRESS))
{
int x; int y;
glfwGetMousePos(&x, &y);
guiStates.lockPositionX = x;
guiStates.lockPositionY = y;
}
if (altPressed == GLFW_PRESS)
{
int mousex; int mousey;
glfwGetMousePos(&mousex, &mousey);
int diffLockPositionX = mousex - guiStates.lockPositionX;
int diffLockPositionY = mousey - guiStates.lockPositionY;
if (guiStates.zoomLock)
{
float zoomDir = 0.0;
if (diffLockPositionX > 0)
zoomDir = -1.f;
else if (diffLockPositionX < 0 )
zoomDir = 1.f;
camera_zoom(camera, zoomDir * GUIStates::MOUSE_ZOOM_SPEED);
}
else if (guiStates.turnLock)
{
camera_turn(camera, diffLockPositionY * GUIStates::MOUSE_TURN_SPEED,
diffLockPositionX * GUIStates::MOUSE_TURN_SPEED);
}
else if (guiStates.panLock)
{
camera_pan(camera, diffLockPositionX * GUIStates::MOUSE_PAN_SPEED,
diffLockPositionY * GUIStates::MOUSE_PAN_SPEED);
}
guiStates.lockPositionX = mousex;
guiStates.lockPositionY = mousey;
}
// Default states
glEnable(GL_DEPTH_TEST);
// Clear the front buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Get camera matrices
glm::mat4 projection = glm::perspective(45.0f, widthf / heightf, 0.1f, 100.f);
glm::mat4 worldToView = glm::lookAt(camera.eye, camera.o, camera.up);
glm::mat4 objectToWorld;
// Select textures
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
// Select shader
glUseProgram(program);
// Upload uniforms
glUniformMatrix4fv(projectionLocation, 1, 0, glm::value_ptr(projection));
glUniformMatrix4fv(viewLocation, 1, 0, glm::value_ptr(worldToView));
glUniformMatrix4fv(objectLocation, 1, 0, glm::value_ptr(objectToWorld));
glUniform1f(timeLocation, t);
glUniform3fv(cameraPositionLocation, 1, glm::value_ptr(camera.eye));
// Render vaos
glBindVertexArray(vao[0]);
glDrawElementsInstanced(GL_TRIANGLES, cube_triangleCount * 3, GL_UNSIGNED_INT, (void*)0, 4);
//glDrawElements(GL_TRIANGLES, cube_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
glBindVertexArray(vao[1]);
glDrawElements(GL_TRIANGLES, plane_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
#if 1
// Draw UI
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glViewport(0, 0, width, height);
unsigned char mbut = 0;
int mscroll = 0;
int mousex; int mousey;
glfwGetMousePos(&mousex, &mousey);
mousey = height - mousey;
if( leftButton == GLFW_PRESS )
mbut |= IMGUI_MBUT_LEFT;
imguiBeginFrame(mousex, mousey, mbut, mscroll);
int logScroll = 0;
char lineBuffer[512];
imguiBeginScrollArea("001", width - 210, height - 310, 200, 300, &logScroll);
sprintf(lineBuffer, "FPS %f", fps);
imguiLabel(lineBuffer);
imguiSlider("Dummy", &dummySlider, 0.0, 3.0, 0.1);
imguiEndScrollArea();
imguiEndFrame();
imguiRenderGLDraw(width, height);
glDisable(GL_BLEND);
#endif
// Check for errors
GLenum err = glGetError();
if(err != GL_NO_ERROR)
{
fprintf(stderr, "OpenGL Error : %s\n", gluErrorString(err));
}
// Swap buffers
glfwSwapBuffers();
double newTime = glfwGetTime();
fps = 1.f/ (newTime - t);
} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
glfwGetWindowParam( GLFW_OPENED ) );
// Close OpenGL window and terminate GLFW
glfwTerminate();
exit( EXIT_SUCCESS );
}
int _main_(int /*_argc*/, char** /*_argv*/)
{
// Create vertex stream declaration.
PosColorVertex::init();
PosColorTexCoord0Vertex::init();
uint32_t width = 1280;
uint32_t height = 720;
uint32_t debug = BGFX_DEBUG_TEXT;
uint32_t reset = BGFX_RESET_VSYNC;
bgfx::init();
bgfx::reset(width, height, reset);
// Enable debug text.
bgfx::setDebug(debug);
// Get renderer capabilities info.
const bgfx::Caps* caps = bgfx::getCaps();
// Setup root path for binary shaders. Shader binaries are different
// for each renderer.
switch (caps->rendererType)
{
default:
break;
case bgfx::RendererType::OpenGL:
case bgfx::RendererType::OpenGLES:
s_flipV = true;
break;
}
// Imgui.
void* data = load("font/droidsans.ttf");
imguiCreate(data);
free(data);
const bgfx::Memory* mem;
// Create static vertex buffer.
mem = bgfx::makeRef(s_cubeVertices, sizeof(s_cubeVertices) );
bgfx::VertexBufferHandle vbh = bgfx::createVertexBuffer(mem, PosColorVertex::ms_decl);
// Create static index buffer.
mem = bgfx::makeRef(s_cubeIndices, sizeof(s_cubeIndices) );
bgfx::IndexBufferHandle ibh = bgfx::createIndexBuffer(mem);
// Create texture sampler uniforms.
bgfx::UniformHandle u_texColor0 = bgfx::createUniform("u_texColor0", bgfx::UniformType::Uniform1iv);
bgfx::UniformHandle u_texColor1 = bgfx::createUniform("u_texColor1", bgfx::UniformType::Uniform1iv);
bgfx::UniformHandle u_color = bgfx::createUniform("u_color", bgfx::UniformType::Uniform4fv);
bgfx::ProgramHandle blend = loadProgram("vs_oit", "fs_oit" );
bgfx::ProgramHandle wbSeparatePass = loadProgram("vs_oit", "fs_oit_wb_separate" );
bgfx::ProgramHandle wbSeparateBlit = loadProgram("vs_oit_blit", "fs_oit_wb_separate_blit" );
bgfx::ProgramHandle wbPass = loadProgram("vs_oit", "fs_oit_wb" );
bgfx::ProgramHandle wbBlit = loadProgram("vs_oit_blit", "fs_oit_wb_blit" );
bgfx::TextureHandle fbtextures[2] = { BGFX_INVALID_HANDLE, BGFX_INVALID_HANDLE };
bgfx::FrameBufferHandle fbh = BGFX_INVALID_HANDLE;
int64_t timeOffset = bx::getHPCounter();
uint32_t mode = 1;
int32_t scrollArea = 0;
bool frontToBack = true;
bool fadeInOut = false;
uint32_t oldWidth = 0;
uint32_t oldHeight = 0;
uint32_t oldReset = reset;
entry::MouseState mouseState;
while (!entry::processEvents(width, height, debug, reset, &mouseState) )
{
if (oldWidth != width
|| oldHeight != height
|| oldReset != reset
|| !bgfx::isValid(fbh) )
{
// Recreate variable size render targets when resolution changes.
oldWidth = width;
oldHeight = height;
oldReset = reset;
if (bgfx::isValid(fbh) )
{
bgfx::destroyFrameBuffer(fbh);
}
fbtextures[0] = bgfx::createTexture2D(width, height, 1, bgfx::TextureFormat::RGBA16F, BGFX_TEXTURE_RT);
fbtextures[1] = bgfx::createTexture2D(width, height, 1, bgfx::TextureFormat::R16F, BGFX_TEXTURE_RT);
fbh = bgfx::createFrameBuffer(BX_COUNTOF(fbtextures), fbtextures, true);
}
imguiBeginFrame(mouseState.m_mx
, mouseState.m_my
, (mouseState.m_buttons[entry::MouseButton::Left ] ? IMGUI_MBUT_LEFT : 0)
| (mouseState.m_buttons[entry::MouseButton::Right ] ? IMGUI_MBUT_RIGHT : 0)
, 0
, width
, height
);
imguiBeginScrollArea("Settings", width - width / 4 - 10, 10, width / 4, height / 3, &scrollArea);
imguiSeparatorLine();
imguiLabel("Blend mode:");
mode = imguiChoose(mode
, "None"
, "Separate"
, "MRT Independent"
);
imguiSeparatorLine();
if (imguiCheck("Front to back", frontToBack) )
{
frontToBack ^= true;
}
if (imguiCheck("Fade in/out", fadeInOut) )
{
fadeInOut ^= true;
}
imguiEndScrollArea();
imguiEndFrame();
// Set view 0 default viewport.
bgfx::setViewRectMask(0x3, 0, 0, width, height);
int64_t now = bx::getHPCounter();
static int64_t last = now;
const int64_t frameTime = now - last;
last = now;
const double freq = double(bx::getHPFrequency() );
const double toMs = 1000.0/freq;
float time = (float)( (now-timeOffset)/freq);
// Use debug font to print information about this example.
bgfx::dbgTextClear();
// Reference:
// Weighted, Blended Order-Independent Transparency
// http://jcgt.org/published/0002/02/09/
// http://casual-effects.blogspot.com/2014/03/weighted-blended-order-independent.html
bgfx::dbgTextPrintf(0, 1, 0x4f, "bgfx/examples/19-oit");
bgfx::dbgTextPrintf(0, 2, 0x6f, "Description: Weighted, Blended Order Independent Transparency.");
bgfx::dbgTextPrintf(0, 3, 0x0f, "Frame: % 7.3f[ms]", double(frameTime)*toMs);
float at[3] = { 0.0f, 0.0f, 0.0f };
float eye[3] = { 0.0f, 0.0f, -7.0f };
float view[16];
float proj[16];
// Set view and projection matrix for view 0.
bx::mtxLookAt(view, eye, at);
bx::mtxProj(proj, 60.0f, float(width)/float(height), 0.1f, 100.0f);
bgfx::setViewTransform(0, view, proj);
bgfx::setViewClearMask(0x3
, BGFX_CLEAR_COLOR_BIT|BGFX_CLEAR_DEPTH_BIT
, 0x00000000
, 1.0f
, 0
);
bgfx::FrameBufferHandle invalid = BGFX_INVALID_HANDLE;
bgfx::setViewFrameBuffer(0, 0 == mode ? invalid : fbh);
// Set view and projection matrix for view 1.
bx::mtxIdentity(view);
bx::mtxOrtho(proj, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 100.0f);
bgfx::setViewTransform(1, view, proj);
for (uint32_t depth = 0; depth < 3; ++depth)
{
uint32_t zz = frontToBack ? 2-depth : depth;
for (uint32_t yy = 0; yy < 3; ++yy)
{
for (uint32_t xx = 0; xx < 3; ++xx)
{
float color[4] = { xx*1.0f/3.0f, zz*1.0f/3.0f, yy*1.0f/3.0f, 0.5f };
if (fadeInOut
&& zz == 1)
{
color[3] = sinf(time*3.0f)*0.49f+0.5f;
}
bgfx::setUniform(u_color, color);
BX_UNUSED(time);
float mtx[16];
bx::mtxRotateXY(mtx, time*0.023f + xx*0.21f, time*0.03f + yy*0.37f);
//mtxIdentity(mtx);
mtx[12] = -2.5f + float(xx)*2.5f;
mtx[13] = -2.5f + float(yy)*2.5f;
mtx[14] = -2.5f + float(zz)*2.5f; //0.0f; // sinf(time + ( (xx+1)*(yy+1)/9.0f)*float(M_PI) )*50.0f+50.0f; //90.0f - (xx+1)*(yy+1)*10.0f;
// Set transform for draw call.
bgfx::setTransform(mtx);
// Set vertex and index buffer.
bgfx::setVertexBuffer(vbh);
bgfx::setIndexBuffer(ibh);
const uint64_t state = 0
| BGFX_STATE_CULL_CW
| BGFX_STATE_RGB_WRITE
| BGFX_STATE_ALPHA_WRITE
| BGFX_STATE_DEPTH_TEST_LESS
| BGFX_STATE_MSAA
;
switch (mode)
{
case 0:
// Set vertex and fragment shaders.
bgfx::setProgram(blend);
// Set render states.
bgfx::setState(state
| BGFX_STATE_BLEND_ALPHA
);
break;
case 1:
// Set vertex and fragment shaders.
bgfx::setProgram(wbSeparatePass);
// Set render states.
bgfx::setState(state
| BGFX_STATE_BLEND_FUNC_SEPARATE(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ZERO, BGFX_STATE_BLEND_INV_SRC_ALPHA)
);
break;
default:
// Set vertex and fragment shaders.
bgfx::setProgram(wbPass);
// Set render states.
bgfx::setState(state
| BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE)
| BGFX_STATE_BLEND_INDEPENDENT
, 0
| BGFX_STATE_BLEND_FUNC_RT_1(BGFX_STATE_BLEND_ZERO, BGFX_STATE_BLEND_SRC_COLOR)
);
break;
}
// Submit primitive for rendering to view 0.
bgfx::submit(0);
}
}
}
if (0 != mode)
{
bgfx::setTexture(0, u_texColor0, fbtextures[0]);
bgfx::setTexture(1, u_texColor1, fbtextures[1]);
bgfx::setProgram(1 == mode ? wbSeparateBlit : wbBlit);
bgfx::setState(0
| BGFX_STATE_RGB_WRITE
| BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_INV_SRC_ALPHA, BGFX_STATE_BLEND_SRC_ALPHA)
);
screenSpaceQuad( (float)width, (float)height, s_flipV);
bgfx::submit(1);
}
// Advance to next frame. Rendering thread will be kicked to
// process submitted rendering primitives.
bgfx::frame();
}
// Cleanup.
imguiDestroy();
bgfx::destroyFrameBuffer(fbh);
bgfx::destroyIndexBuffer(ibh);
bgfx::destroyVertexBuffer(vbh);
bgfx::destroyProgram(blend);
bgfx::destroyProgram(wbSeparatePass);
bgfx::destroyProgram(wbSeparateBlit);
bgfx::destroyProgram(wbPass);
bgfx::destroyProgram(wbBlit);
bgfx::destroyUniform(u_texColor0);
bgfx::destroyUniform(u_texColor1);
bgfx::destroyUniform(u_color);
// Shutdown bgfx.
bgfx::shutdown();
return 0;
}
void NavMeshTesterTool::handleMenu()
{
if (imguiCheck("Pathfind Follow", m_toolMode == TOOLMODE_PATHFIND_FOLLOW))
{
m_toolMode = TOOLMODE_PATHFIND_FOLLOW;
recalc();
}
if (imguiCheck("Pathfind Straight", m_toolMode == TOOLMODE_PATHFIND_STRAIGHT))
{
m_toolMode = TOOLMODE_PATHFIND_STRAIGHT;
recalc();
}
if (m_toolMode == TOOLMODE_PATHFIND_STRAIGHT)
{
imguiIndent();
imguiLabel("Vertices at crossings");
if (imguiCheck("None", m_straightPathOptions == 0))
{
m_straightPathOptions = 0;
recalc();
}
if (imguiCheck("Area", m_straightPathOptions == DT_STRAIGHTPATH_AREA_CROSSINGS))
{
m_straightPathOptions = DT_STRAIGHTPATH_AREA_CROSSINGS;
recalc();
}
if (imguiCheck("All", m_straightPathOptions == DT_STRAIGHTPATH_ALL_CROSSINGS))
{
m_straightPathOptions = DT_STRAIGHTPATH_ALL_CROSSINGS;
recalc();
}
imguiUnindent();
}
if (imguiCheck("Pathfind Sliced", m_toolMode == TOOLMODE_PATHFIND_SLICED))
{
m_toolMode = TOOLMODE_PATHFIND_SLICED;
recalc();
}
imguiSeparator();
if (imguiCheck("Distance to Wall", m_toolMode == TOOLMODE_DISTANCE_TO_WALL))
{
m_toolMode = TOOLMODE_DISTANCE_TO_WALL;
recalc();
}
imguiSeparator();
if (imguiCheck("Raycast", m_toolMode == TOOLMODE_RAYCAST))
{
m_toolMode = TOOLMODE_RAYCAST;
recalc();
}
imguiSeparator();
if (imguiCheck("Find Polys in Circle", m_toolMode == TOOLMODE_FIND_POLYS_IN_CIRCLE))
{
m_toolMode = TOOLMODE_FIND_POLYS_IN_CIRCLE;
recalc();
}
if (imguiCheck("Find Polys in Shape", m_toolMode == TOOLMODE_FIND_POLYS_IN_SHAPE))
{
m_toolMode = TOOLMODE_FIND_POLYS_IN_SHAPE;
recalc();
}
imguiSeparator();
if (imguiCheck("Find Local Neighbourhood", m_toolMode == TOOLMODE_FIND_LOCAL_NEIGHBOURHOOD))
{
m_toolMode = TOOLMODE_FIND_LOCAL_NEIGHBOURHOOD;
recalc();
}
imguiSeparator();
if (imguiButton("Set Random Start"))
{
dtStatus status = m_navQuery->findRandomPoint(&m_filter, frand, &m_startRef, m_spos);
if (dtStatusSucceed(status))
{
m_sposSet = true;
recalc();
}
}
if (imguiButton("Set Random End", m_sposSet))
{
if (m_sposSet)
{
dtStatus status = m_navQuery->findRandomPointAroundCircle(m_startRef, m_spos, m_randomRadius, &m_filter, frand, &m_endRef, m_epos);
if (dtStatusSucceed(status))
{
m_eposSet = true;
recalc();
}
}
}
imguiSeparator();
if (imguiButton("Make Random Points"))
{
m_randPointsInCircle = false;
m_nrandPoints = 0;
for (int i = 0; i < MAX_RAND_POINTS; i++)
{
float pt[3];
dtPolyRef ref;
dtStatus status = m_navQuery->findRandomPoint(&m_filter, frand, &ref, pt);
if (dtStatusSucceed(status))
{
dtVcopy(&m_randPoints[m_nrandPoints*3], pt);
m_nrandPoints++;
}
}
}
if (imguiButton("Make Random Points Around", m_sposSet))
{
if (m_sposSet)
{
m_nrandPoints = 0;
m_randPointsInCircle = true;
for (int i = 0; i < MAX_RAND_POINTS; i++)
{
float pt[3];
dtPolyRef ref;
dtStatus status = m_navQuery->findRandomPointAroundCircle(m_startRef, m_spos, m_randomRadius, &m_filter, frand, &ref, pt);
if (dtStatusSucceed(status))
{
dtVcopy(&m_randPoints[m_nrandPoints*3], pt);
m_nrandPoints++;
}
}
}
}
imguiSeparator();
imguiLabel("Include Flags");
imguiIndent();
if (imguiCheck("Walk", (m_filter.getIncludeFlags() & SAMPLE_POLYFLAGS_WALK) != 0))
{
m_filter.setIncludeFlags(m_filter.getIncludeFlags() ^ SAMPLE_POLYFLAGS_WALK);
recalc();
}
if (imguiCheck("Swim", (m_filter.getIncludeFlags() & SAMPLE_POLYFLAGS_SWIM) != 0))
{
m_filter.setIncludeFlags(m_filter.getIncludeFlags() ^ SAMPLE_POLYFLAGS_SWIM);
recalc();
}
if (imguiCheck("Door", (m_filter.getIncludeFlags() & SAMPLE_POLYFLAGS_DOOR) != 0))
{
m_filter.setIncludeFlags(m_filter.getIncludeFlags() ^ SAMPLE_POLYFLAGS_DOOR);
recalc();
}
if (imguiCheck("Jump", (m_filter.getIncludeFlags() & SAMPLE_POLYFLAGS_JUMP) != 0))
{
m_filter.setIncludeFlags(m_filter.getIncludeFlags() ^ SAMPLE_POLYFLAGS_JUMP);
recalc();
}
imguiUnindent();
imguiSeparator();
imguiLabel("Exclude Flags");
imguiIndent();
if (imguiCheck("Walk", (m_filter.getExcludeFlags() & SAMPLE_POLYFLAGS_WALK) != 0))
{
m_filter.setExcludeFlags(m_filter.getExcludeFlags() ^ SAMPLE_POLYFLAGS_WALK);
recalc();
}
if (imguiCheck("Swim", (m_filter.getExcludeFlags() & SAMPLE_POLYFLAGS_SWIM) != 0))
{
m_filter.setExcludeFlags(m_filter.getExcludeFlags() ^ SAMPLE_POLYFLAGS_SWIM);
recalc();
}
if (imguiCheck("Door", (m_filter.getExcludeFlags() & SAMPLE_POLYFLAGS_DOOR) != 0))
{
m_filter.setExcludeFlags(m_filter.getExcludeFlags() ^ SAMPLE_POLYFLAGS_DOOR);
recalc();
}
if (imguiCheck("Jump", (m_filter.getExcludeFlags() & SAMPLE_POLYFLAGS_JUMP) != 0))
{
m_filter.setExcludeFlags(m_filter.getExcludeFlags() ^ SAMPLE_POLYFLAGS_JUMP);
recalc();
}
imguiUnindent();
imguiSeparator();
}
