void end_frame()
{
#ifdef GRAPHICS
draw_ui_scale();
//renderGraph(vg, 5, 5, &fps_graph);
//renderGraph(vg, 5 + 200 + 5, 5, &cpu_graph);
if (gpu_timer.supported)
renderGraph(vg, 5 + 200 + 5 + 200 + 5, 5, &gpu_graph);
draw_world_scale();
nvgEndFrame(vg);
cpu_time = glfwGetTime() - render_start_time;
updateGraph(&fps_graph, delta_time);
updateGraph(&cpu_graph, cpu_time);
float gpu_times[3];
int n = stopGPUTimer(&gpu_timer, gpu_times, 3);
for (int i = 0; i < n; i++)
updateGraph(&gpu_graph, gpu_times[i]);
glfwSwapBuffers(window);
glfwPollEvents();
#endif
}
void CorrespondenceEvaluate::generateInbetween(double t)
{
auto scheduler = QSharedPointer<Scheduler>(new Scheduler);
auto blender = QSharedPointer<TopoBlender>(new TopoBlender(GraphCorr, scheduler.data()));
auto synthManager = QSharedPointer<SynthesisManager>(new SynthesisManager(GraphCorr, scheduler.data(), blender.data(), 1000));
synthManager->genSynData();
scheduler->timeStep = 1.0 / 100.0;
scheduler->defaultSchedule();
scheduler->executeAll();
auto blendedModel = scheduler->allGraphs[t * (scheduler->allGraphs.size() - 1)];
synthManager->renderGraph(*blendedModel, "test", false, 5);
}
void
StateGraphViewerPanel::show(std::shared_ptr<StateAccessToken> Access,
seec::cm::ProcessState const &Process,
seec::cm::ThreadState const &Thread)
{
CurrentAccess = std::move(Access);
CurrentProcess = &Process;
MouseOver.reset();
WebView->RunScript(wxString("InvalidateState();"));
if (!WebView || PathToDot.empty())
return;
renderGraph();
// Add special highlighting for values associated with the active Stmt.
//
if (!Thread.getCallStack().empty()) {
seec::cm::FunctionState const &Fn = Thread.getCallStack().back();
if (auto const Stmt = Fn.getActiveStmt()) {
if (auto const Value = Fn.getStmtValue(Stmt)) {
wxString Script("MarkActiveStmtValue(");
Script << reinterpret_cast<uintptr_t>(Value.get()) << ");";
if (auto const Ptr = llvm::dyn_cast<seec::cm::ValueOfPointer>
(Value.get()))
{
if (Ptr->getDereferenceIndexLimit()) {
if (auto const Pointee = Ptr->getDereferenced(0)) {
Script << "MarkActiveStmtValue("
<< reinterpret_cast<uintptr_t>(Pointee.get()) << ");";
}
}
}
WebView->RunScript(Script);
}
}
}
}
void AutoBlend::doBlend()
{
auto selected = gallery->getSelected();
if (selected.size() < 2) return;
for(auto t : results->items) t->deleteLater();
results->items.clear();
((GraphicsScene*)scene())->showPopup("Please wait..");
for(int shapeI = 0; shapeI < selected.size(); shapeI++)
{
for(int shapeJ = shapeI + 1; shapeJ < selected.size(); shapeJ++)
{
//auto sourceName = selected.front()->data["targetName"].toString();
//auto targetName = selected.back()->data["targetName"].toString();
auto sourceName = selected[shapeI]->data.value("targetName").toString();
auto targetName = selected[shapeJ]->data.value("targetName").toString();
auto cacheSource = document->cacheModel(sourceName);
auto cacheTarget = document->cacheModel(targetName);
if(cacheSource == nullptr || cacheTarget == nullptr) continue;
auto source = QSharedPointer<Structure::Graph>(cacheSource->cloneAsShapeGraph());
auto target = QSharedPointer<Structure::Graph>(cacheTarget->cloneAsShapeGraph());
auto gcorr = QSharedPointer<GraphCorresponder>(new GraphCorresponder(source.data(), target.data()));
// Apply computed correspondence
//if (false) // enable/disable auto correspondence
{
QVector<QPair<QString, QString> > all_pairs;
for(auto n : source->nodes)
{
if (!document->datasetCorr[sourceName][n->id][targetName].empty())
{
for(auto nj : document->datasetCorr[sourceName][n->id][targetName])
{
all_pairs << qMakePair(n->id, nj);
}
}
}
ResolveCorrespondence(source.data(), target.data(), all_pairs, gcorr.data());
}
gcorr->computeCorrespondences();
// Schedule blending sequence
auto scheduler = QSharedPointer<Scheduler>(new Scheduler);
auto blender = QSharedPointer<TopoBlender>(new TopoBlender(gcorr.data(), scheduler.data()));
// Sample geometries
int numSamples = 100;
int reconLevel = 4;
int LOD = widget->levelDetails->currentIndex();
switch (LOD){
case 0: numSamples = 100; reconLevel = 4; break;
case 1: numSamples = 1000; reconLevel = 5; break;
case 2: numSamples = 10000; reconLevel = 7; break;
}
/// Visualize schedule:
if (false)
{
blender->parentWidget = new QMainWindow();
blender->parentWidget->show();
blender->setupUI();
QStringList corr;
for(auto n : scheduler->activeGraph->nodes){
corr << QString("%1-%2").arg(n->id, n->property["correspond"].toString());
}
QMessageBox::information(blender->parentWidget, "Correspondence", corr.join("\n"));
}
auto synthManager = QSharedPointer<SynthesisManager>(new SynthesisManager(gcorr.data(), scheduler.data(), blender.data(), numSamples));
synthManager->genSynData();
// Compute blending
scheduler->timeStep = 1.0 / 100.0;
scheduler->defaultSchedule();
scheduler->executeAll();
int numResults = widget->count->value();
for (int i = 0; i < numResults; i++)
{
double a = ((double(i) / (numResults - 1)) * 0.9) + 0.05;
auto blendedModel = scheduler->allGraphs[a * (scheduler->allGraphs.size() - 1)];
synthManager->renderGraph(*blendedModel, "", false, reconLevel );
auto t = results->addTextItem("");
t->setCamera(cameraPos, cameraMatrix);
QVariantMap data;
data["name"] = QString("%1_%2").arg(sourceName).arg(targetName);
t->setData(data);
// Add parts of target shape
for (auto n : blendedModel->nodes){
t->addAuxMesh(toBasicMesh(blendedModel->getMesh(n->id), n->vis_property["color"].value<QColor>()));
}
}
}
}
((GraphicsScene*)scene())->hidePopup();
}
int main()
{
GLFWwindow* window;
struct DemoData data;
struct NVGcontext* vg = NULL;
struct PerfGraph fps;
double prevt = 0;
if (!glfwInit()) {
printf("Failed to init GLFW.");
return -1;
}
initGraph(&fps, GRAPH_RENDER_FPS, "Frame Time");
glfwSetErrorCallback(errorcb);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
#ifdef DEMO_MSAA
glfwWindowHint(GLFW_SAMPLES, 4);
#endif
window = glfwCreateWindow(1000, 600, "NanoVG", NULL, NULL);
// window = glfwCreateWindow(1000, 600, "NanoVG", glfwGetPrimaryMonitor(), NULL);
if (!window) {
glfwTerminate();
return -1;
}
glfwSetKeyCallback(window, key);
glfwMakeContextCurrent(window);
#ifdef NANOVG_GLEW
if(glewInit() != GLEW_OK) {
printf("Could not init glew.\n");
return -1;
}
#endif
#ifdef DEMO_MSAA
vg = nvgCreateGL2(512, 512, 0);
#else
vg = nvgCreateGL2(512, 512, NVG_ANTIALIAS);
#endif
if (vg == NULL) {
printf("Could not init nanovg.\n");
return -1;
}
if (loadDemoData(vg, &data) == -1)
return -1;
glfwSwapInterval(0);
glfwSetTime(0);
prevt = glfwGetTime();
while (!glfwWindowShouldClose(window))
{
double mx, my, t, dt;
int winWidth, winHeight;
int fbWidth, fbHeight;
float pxRatio;
t = glfwGetTime();
dt = t - prevt;
prevt = t;
updateGraph(&fps, dt);
glfwGetCursorPos(window, &mx, &my);
glfwGetWindowSize(window, &winWidth, &winHeight);
glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
// Calculate pixel ration for hi-dpi devices.
pxRatio = (float)fbWidth / (float)winWidth;
// Update and render
glViewport(0, 0, fbWidth, fbHeight);
if (premult)
glClearColor(0,0,0,0);
else
glClearColor(0.3f, 0.3f, 0.32f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
nvgBeginFrame(vg, winWidth, winHeight, pxRatio, premult ? NVG_PREMULTIPLIED_ALPHA : NVG_STRAIGHT_ALPHA);
renderDemo(vg, mx,my, winWidth,winHeight, t, blowup, &data);
renderGraph(vg, 5,5, &fps);
nvgEndFrame(vg);
if (screenshot) {
screenshot = 0;
saveScreenShot(fbWidth, fbHeight, premult, "dump.png");
}
glfwSwapBuffers(window);
glfwPollEvents();
}
freeDemoData(vg, &data);
nvgDeleteGL2(vg);
glfwTerminate();
return 0;
}
int main()
{
GLFWwindow* window;
struct DemoData data;
struct NVGcontext* vg = NULL;
struct GPUtimer gpuTimer;
struct PerfGraph fps, cpuGraph, gpuGraph;
double prevt = 0, cpuTime = 0;
if (!glfwInit()) {
printf("Failed to init GLFW.");
return -1;
}
initGraph(&fps, GRAPH_RENDER_FPS, "Frame Time");
initGraph(&cpuGraph, GRAPH_RENDER_MS, "CPU Time");
initGraph(&gpuGraph, GRAPH_RENDER_MS, "GPU Time");
glfwSetErrorCallback(errorcb);
#ifndef _WIN32 // don't require this on win32, and works with more cards
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#endif
#ifdef DEMO_MSAA
glfwWindowHint(GLFW_SAMPLES, 4);
#endif
window = glfwCreateWindow(1000, 600, "NanoVG", NULL, NULL);
// window = glfwCreateWindow(1000, 600, "NanoVG", glfwGetPrimaryMonitor(), NULL);
if (!window) {
glfwTerminate();
return -1;
}
glfwSetKeyCallback(window, key);
glfwMakeContextCurrent(window);
#ifdef NANOVG_GLEW
glewExperimental = GL_TRUE;
if(glewInit() != GLEW_OK) {
printf("Could not init glew.\n");
return -1;
}
#endif
#ifdef DEMO_MSAA
vg = nvgCreateGL3(512, 512, 0);
#else
vg = nvgCreateGL3(512, 512, NVG_ANTIALIAS);
#endif
if (vg == NULL) {
printf("Could not init nanovg.\n");
return -1;
}
if (loadDemoData(vg, &data) == -1)
return -1;
glfwSwapInterval(0);
initGPUTimer(&gpuTimer);
glfwSetTime(0);
prevt = glfwGetTime();
while (!glfwWindowShouldClose(window))
{
double mx, my, t, dt;
int winWidth, winHeight;
int fbWidth, fbHeight;
float pxRatio;
float gpuTimes[3];
int i, n;
t = glfwGetTime();
dt = t - prevt;
prevt = t;
startGPUTimer(&gpuTimer);
glfwGetCursorPos(window, &mx, &my);
glfwGetWindowSize(window, &winWidth, &winHeight);
glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
// Calculate pixel ration for hi-dpi devices.
pxRatio = (float)fbWidth / (float)winWidth;
// Update and render
glViewport(0, 0, fbWidth, fbHeight);
if (premult)
glClearColor(0,0,0,0);
else
glClearColor(0.3f, 0.3f, 0.32f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
nvgBeginFrame(vg, winWidth, winHeight, pxRatio, premult ? NVG_PREMULTIPLIED_ALPHA : NVG_STRAIGHT_ALPHA);
renderDemo(vg, mx,my, winWidth,winHeight, t, blowup, &data);
renderGraph(vg, 5,5, &fps);
renderGraph(vg, 5+200+5,5, &cpuGraph);
if (gpuTimer.supported)
renderGraph(vg, 5+200+5+200+5,5, &gpuGraph);
nvgEndFrame(vg);
glEnable(GL_DEPTH_TEST);
// Measure the CPU time taken excluding swap buffers (as the swap may wait for GPU)
cpuTime = glfwGetTime() - t;
updateGraph(&fps, dt);
updateGraph(&cpuGraph, cpuTime);
// We may get multiple results.
n = stopGPUTimer(&gpuTimer, gpuTimes, 3);
for (i = 0; i < n; i++)
updateGraph(&gpuGraph, gpuTimes[i]);
if (screenshot) {
screenshot = 0;
saveScreenShot(fbWidth, fbHeight, premult, "dump.png");
}
glfwSwapBuffers(window);
glfwPollEvents();
}
freeDemoData(vg, &data);
nvgDeleteGL3(vg);
printf("Average Frame Time: %.2f ms\n", getGraphAverage(&fps) * 1000.0f);
printf(" CPU Time: %.2f ms\n", getGraphAverage(&cpuGraph) * 1000.0f);
printf(" GPU Time: %.2f ms\n", getGraphAverage(&gpuGraph) * 1000.0f);
glfwTerminate();
return 0;
}
int main()
{
GLFWwindow* window;
DemoData data;
NVGcontext* vg = NULL;
PerfGraph fps;
double prevt = 0;
if (!glfwInit()) {
printf("Failed to init GLFW.");
return -1;
}
initGraph(&fps, GRAPH_RENDER_FPS, "Frame Time");
glfwSetErrorCallback(errorcb);
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
window = glfwCreateWindow(1000, 600, "NanoVG", NULL, NULL);
// window = glfwCreateWindow(1000, 600, "NanoVG", glfwGetPrimaryMonitor(), NULL);
if (!window) {
glfwTerminate();
return -1;
}
glfwSetKeyCallback(window, key);
glfwMakeContextCurrent(window);
vg = nvgCreateGLES2(NVG_ANTIALIAS | NVG_STENCIL_STROKES | NVG_DEBUG);
if (vg == NULL) {
printf("Could not init nanovg.\n");
return -1;
}
if (loadDemoData(vg, &data) == -1)
return -1;
glfwSwapInterval(0);
glfwSetTime(0);
prevt = glfwGetTime();
while (!glfwWindowShouldClose(window))
{
double mx, my, t, dt;
int winWidth, winHeight;
int fbWidth, fbHeight;
float pxRatio;
t = glfwGetTime();
dt = t - prevt;
prevt = t;
updateGraph(&fps, dt);
glfwGetCursorPos(window, &mx, &my);
glfwGetWindowSize(window, &winWidth, &winHeight);
glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
// Calculate pixel ration for hi-dpi devices.
pxRatio = (float)fbWidth / (float)winWidth;
// Update and render
glViewport(0, 0, fbWidth, fbHeight);
if (premult)
glClearColor(0,0,0,0);
else
glClearColor(0.3f, 0.3f, 0.32f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
nvgBeginFrame(vg, winWidth, winHeight, pxRatio);
renderDemo(vg, mx,my, winWidth,winHeight, t, blowup, &data);
renderGraph(vg, 5,5, &fps);
nvgEndFrame(vg);
if (screenshot) {
screenshot = 0;
saveScreenShot(fbWidth, fbHeight, premult, "dump.png");
}
glEnable(GL_DEPTH_TEST);
glfwSwapBuffers(window);
glfwPollEvents();
}
freeDemoData(vg, &data);
nvgDeleteGLES2(vg);
glfwTerminate();
return 0;
}
void Camera::operator ()()
{
if (!pContext->getContext()->isValid())
return;
pContext->makeCurrent();
CHECK_GL();
if (ptex)
{
if (pContext->getTextureID(ptex) != fbo->getColorTexture())
fbo->setColorTarget(GL_TEXTURE_2D, pContext->getTextureID(ptex), ptex->getTextureWidth(), ptex->getTextureHeight());
}
fbo->bind();
CHECK_GL();
glClearColor(0,0,0,0);
CHECK_GL();
glClear(GL_COLOR_BUFFER_BIT);
CHECK_GL();
if (background) // background image
{
glClear(GL_DEPTH_BUFFER_BIT);
CHECK_GL();
glMatrixMode(GL_PROJECTION);
CHECK_GL();
glLoadIdentity();
CHECK_GL();
gluOrtho2D(0.0, 1.0, 1.0, 0.0);
CHECK_GL();
glMatrixMode(GL_MODELVIEW);
CHECK_GL();
glLoadIdentity();
CHECK_GL();
const GLuint pid = pContext->getProgramID(background_program);
glUseProgram(pid);
glUniform1i(glGetUniformLocation(pid, "tex"), 0);
const osg::Matrixf mat(viewMatrix);
glUniformMatrix4fv(glGetUniformLocation(pid, "viewMatrix"), 1, GL_FALSE, mat.ptr());
glUniform1f(glGetUniformLocation(pid, "fov"), fov * M_PI / 180.0);
glUniform1f(glGetUniformLocation(pid, "aspectRatio"), aspectRatio);
glActiveTexture(GL_TEXTURE0);
CHECK_GL();
glDisable(GL_TEXTURE_CUBE_MAP);
CHECK_GL();
glEnable(GL_TEXTURE_2D);
CHECK_GL();
glBindTexture(GL_TEXTURE_2D, pContext->getTextureID(background));
CHECK_GL();
glDisable(GL_CULL_FACE);
CHECK_GL();
glBegin(GL_QUADS);
glVertex2f(0.f,0.f);
glVertex2f(1.f,0.f);
glVertex2f(1.f,1.f);
glVertex2f(0.f,1.f);
glEnd();
glUseProgram(0);
}
else if (starmap) // background star map
{
glClear(GL_DEPTH_BUFFER_BIT);
CHECK_GL();
glMatrixMode(GL_PROJECTION);
CHECK_GL();
projectionMatrix = Matrixd::perspective(fov, aspectRatio, 0.5f, 2.f);
glLoadMatrixd(projectionMatrix.ptr());
CHECK_GL();
glMatrixMode(GL_MODELVIEW);
CHECK_GL();
glLoadMatrixd(viewMatrix.ptr());
CHECK_GL();
const GLuint pid = pContext->getProgramID(background_program);
glUseProgram(pid);
CHECK_GL();
glActiveTexture(GL_TEXTURE0);
CHECK_GL();
glDisable(GL_TEXTURE_CUBE_MAP);
CHECK_GL();
glDisable(GL_TEXTURE_2D);
CHECK_GL();
glDisable(GL_CULL_FACE);
CHECK_GL();
glEnableClientState(GL_VERTEX_ARRAY);
CHECK_GL();
glEnableClientState(GL_COLOR_ARRAY);
CHECK_GL();
glDisableClientState(GL_NORMAL_ARRAY);
CHECK_GL();
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
CHECK_GL();
if (pContext->hasVBOSupport())
{
glBindBuffer(GL_ARRAY_BUFFER, pContext->getDataVBOID(starmap->getDataPointer(), starmap->getTotalDataSize()));
CHECK_GL();
glVertexPointer(3,GL_FLOAT,12,0);
CHECK_GL();
glColorPointer(3,GL_FLOAT,12,(const GLvoid*)12);
CHECK_GL();
}
else
{
glVertexPointer(3,GL_FLOAT,12,starmap->getDataPointer());
CHECK_GL();
glColorPointer(3,GL_FLOAT,12,(const char*)(starmap->getDataPointer()) + 12);
CHECK_GL();
}
glEnable(GL_COLOR_MATERIAL);
CHECK_GL();
glEnable(GL_POINT_SPRITE);
CHECK_GL();
glPointSize(4.0f);
CHECK_GL();
glDrawArrays(GL_POINTS, 0, starmap->size() / 2);
CHECK_GL();
glDisableClientState(GL_COLOR_ARRAY);
CHECK_GL();
glPointSize(1.0f);
CHECK_GL();
glDisable(GL_POINT_SPRITE);
CHECK_GL();
glDisable(GL_COLOR_MATERIAL);
CHECK_GL();
if (pContext->hasVBOSupport())
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
CHECK_GL();
}
glUseProgram(0);
}
std::vector<std::pair<double, double> > depthRange;
qMatrix.clear();
qMatrix.push_back(viewMatrix);
computeDepthRanges(scene, depthRange);
computeMinimumRanges(depthRange);
for(std::vector<std::pair<double, double> >::const_iterator range = depthRange.begin()
; range != depthRange.end()
; ++range)
{
glClear(GL_DEPTH_BUFFER_BIT);
CHECK_GL();
glMatrixMode(GL_PROJECTION);
CHECK_GL();
projectionMatrix = Matrixd::perspective(fov, aspectRatio, range->first, range->second);
glLoadMatrixd(projectionMatrix.ptr());
CHECK_GL();
znear = range->first;
zfar = range->second;
glMatrixMode(GL_MODELVIEW);
CHECK_GL();
clearMatrixStack();
CHECK_GL();
glDisable(GL_TEXTURE_2D);
CHECK_GL();
glDisable(GL_TEXTURE_CUBE_MAP);
CHECK_GL();
glDisable(GL_COLOR_MATERIAL);
CHECK_GL();
glColor4ub(0xFF, 0xFF, 0xFF, 0xFF);
CHECK_GL();
glDisable(GL_BLEND);
CHECK_GL();
glDisable(GL_LIGHTING);
CHECK_GL();
glDisable(GL_CULL_FACE);
CHECK_GL();
glShadeModel(GL_SMOOTH);
CHECK_GL();
glEnable(GL_DEPTH_TEST);
CHECK_GL();
glDepthFunc(GL_LESS);
CHECK_GL();
qStateSet.clear();
qStateSet.push_back(StateSet());
/** Cubemaps cannot be used to override the background texture
* which is a GL_TEXTURE_2D so we just render to a GL_TEXTURE_2D,
* use it as background texture and copy it to the cubemap
*/
if (ptexcube)
qStateSet.back().setTexture(7, GL_TEXTURE_2D, fbo->getColorTexture(), osg::StateAttribute::OVERRIDE);
renderGraph(scene);
}
glDisableClientState(GL_COLOR_ARRAY);
CHECK_GL();
if (ptexcube)
{
glBindTexture(GL_TEXTURE_CUBE_MAP, pContext->getTextureID(ptexcube));
CHECK_GL();
glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + cube_face_id, 0, 0, 0, 0, 0, fbo->getWidth(), fbo->getHeight());
CHECK_GL();
}
fbo->release();
glUseProgram(0);
CHECK_GL();
for(int i = 15 ; i >= 0 ; --i)
{
glActiveTexture(GL_TEXTURE0 + i);
CHECK_GL();
glDisable(GL_TEXTURE_2D);
CHECK_GL();
glDisable(GL_TEXTURE_CUBE_MAP);
CHECK_GL();
}
}
void Camera::renderGraph(const Node *graph)
{
if (!graph || dynamic_cast<const osg::Camera*>(graph))
return;
const osg::BoundingSphered &bound = computeBoundsOf(graph);
const double r = bound.radius();
const Vec3d view_center = bound.center() * qMatrix.back();
if (-view_center.z() + r < znear || -view_center.z() - r > zfar)
return;
bool bPopMatrix = false;
const osg::StateSet *stateset = graph->getStateSet();
if (stateset)
{
qStateSet.push_back(qStateSet.back());
processStateSet(stateset, qStateSet.back());
}
const PositionAttitudeTransform *ptrans = dynamic_cast<const PositionAttitudeTransform*>(graph);
if (ptrans)
{
const Matrixd mat = Matrixd::translate(-ptrans->getPivotPoint())
* Matrixd::rotate(ptrans->getAttitude())
* Matrixd::scale(ptrans->getScale())
* Matrixd::translate(ptrans->getPosition());
pushMatrix(mat);
bPopMatrix = true;
}
const MatrixTransform *mtrans = dynamic_cast<const MatrixTransform*>(graph);
if (mtrans)
{
pushMatrix(mtrans->getMatrix());
bPopMatrix = true;
}
const Switch* sgroup = dynamic_cast<const Switch*>(graph);
if (sgroup)
{
for(unsigned int i = 0, nb = sgroup->getNumChildren() ; i < nb ; ++i)
if (sgroup->getValue(i))
renderGraph(sgroup->getChild(i));
}
else
{
const Group* group = dynamic_cast<const Group*>(graph);
if (group)
{
for(unsigned int i = 0, nb = group->getNumChildren() ; i < nb ; ++i)
renderGraph(group->getChild(i));
}
}
const Geode *geode = dynamic_cast<const Geode*>(graph);
if (geode)
{
glEnableClientState(GL_VERTEX_ARRAY);
CHECK_GL();
bool bParentStateApplied = false;
for(unsigned int i = 0, nb = geode->getNumDrawables() ; i < nb ; ++i)
{
const Geometry * const geom = geode->getDrawable(i)->asGeometry();
if (!geom)
{
LOG_ERROR() << "[Camera] unsupported drawable : " << geode->getDrawable(i)->className() << std::endl;
continue;
}
const Array * const vtx = geom->getVertexArray();
const Array * const normals = geom->getNormalArray();
const Array * const tcoord = geom->getTexCoordArray(0);
if (!vtx)
{
LOG_ERROR() << "[Camera] no vertex array in Geometry object" << std::endl;
continue;
}
StateSet *local_state = NULL;
char tmp[sizeof(StateSet)]; //! Avoid dynamic allocation
const osg::StateSet *geom_state = geom->getStateSet();
if (geom_state)
{
local_state = new(tmp) StateSet(qStateSet.back());
processStateSet(geom_state, *local_state);
}
if (local_state)
{
local_state->apply();
bParentStateApplied = false;
}
else if (!bParentStateApplied)
{
bParentStateApplied = true;
qStateSet.back().apply();
}
if (bDoublePrecisionMode)
{
if (processed_vertex_array.size() < vtx->getNumElements())
processed_vertex_array.resize(vtx->getNumElements());
const void * const ptr = vtx->getDataPointer();
const osg::Matrixd &mat = qMatrix.back() * projectionMatrix;
switch(vtx->getDataType())
{
case GL_FLOAT:
if (vtx->getDataSize() == 4)
{
const size_t nb = vtx->getNumElements();
for(size_t i = 0 ; i < nb ; ++i)
{
const Vec4d &p = Vec4d(((const Vec4f*)ptr)[i]) * mat;
processed_vertex_array[i] = p / p.w();
}
}
else if (vtx->getDataSize() == 3)
{
const size_t nb = vtx->getNumElements();
for(size_t i = 0 ; i < nb ; ++i)
{
const Vec4d &p = Vec4d(((const Vec3f*)ptr)[i], 1.0) * mat;
processed_vertex_array[i] = p / p.w();
}
}
break;
}
glEnableClientState(GL_COLOR_ARRAY);
CHECK_GL();
if (pContext->hasVBOSupport())
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
CHECK_GL();
}
glColorPointer(4, GL_FLOAT, 0, &(processed_vertex_array.front()));
CHECK_GL();
}
if (pContext->hasVBOSupport())
{
glBindBuffer(GL_ARRAY_BUFFER, pContext->getDataVBOID(vtx->getDataPointer(), vtx->getTotalDataSize()));
CHECK_GL();
glVertexPointer(vtx->getDataSize(), vtx->getDataType(), 0, 0);
CHECK_GL();
if (normals)
{
glEnableClientState(GL_NORMAL_ARRAY);
CHECK_GL();
glBindBuffer(GL_ARRAY_BUFFER, pContext->getDataVBOID(normals->getDataPointer(), normals->getTotalDataSize()));
CHECK_GL();
glNormalPointer(normals->getDataType(), 0, 0);
CHECK_GL();
}
else
{
glDisableClientState(GL_NORMAL_ARRAY);
CHECK_GL();
}
if (tcoord)
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
CHECK_GL();
glBindBuffer(GL_ARRAY_BUFFER, pContext->getDataVBOID(tcoord->getDataPointer(), tcoord->getTotalDataSize()));
CHECK_GL();
glTexCoordPointer(tcoord->getDataSize(), tcoord->getDataType(), 0, 0);
CHECK_GL();
}
else
{
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
CHECK_GL();
}
const size_t nb_prim_set = geom->getNumPrimitiveSets();
for(size_t j = 0 ; j < nb_prim_set ; ++j)
{
const PrimitiveSet * const pset = geom->getPrimitiveSet(j);
const DrawElements * const elts = pset->getDrawElements();
switch(pset->getType())
{
case DrawElements::PrimitiveType:
break;
case DrawElements::DrawArraysPrimitiveType:
glDrawArrays(pset->getMode(), pset->index(0), pset->getNumIndices());
CHECK_GL();
break;
case DrawElements::DrawArrayLengthsPrimitiveType: break;
case DrawElements::DrawElementsUBytePrimitiveType:
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pContext->getIndexVBOID(elts->getDataPointer(), elts->getTotalDataSize()));
CHECK_GL();
glDrawRangeElements(elts->getMode(), 0, vtx->getNumElements() - 1, elts->getNumIndices(), GL_UNSIGNED_BYTE, 0);
CHECK_GL();
break;
case DrawElements::DrawElementsUShortPrimitiveType:
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pContext->getIndexVBOID(elts->getDataPointer(), elts->getTotalDataSize()));
CHECK_GL();
glDrawRangeElements(elts->getMode(), 0, vtx->getNumElements() - 1, elts->getNumIndices(), GL_UNSIGNED_SHORT, 0);
CHECK_GL();
break;
case DrawElements::DrawElementsUIntPrimitiveType:
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pContext->getIndexVBOID(elts->getDataPointer(), elts->getTotalDataSize()));
CHECK_GL();
glDrawRangeElements(elts->getMode(), 0, vtx->getNumElements() - 1, elts->getNumIndices(), GL_UNSIGNED_INT, 0);
CHECK_GL();
break;
}
}
}
else
{
glVertexPointer(vtx->getDataSize(), vtx->getDataType(), 0, vtx->getDataPointer());
CHECK_GL();
if (normals)
{
glEnableClientState(GL_NORMAL_ARRAY);
CHECK_GL();
glNormalPointer(normals->getDataType(), 0, normals->getDataPointer());
CHECK_GL();
}
else
{
glDisableClientState(GL_NORMAL_ARRAY);
CHECK_GL();
}
if (tcoord)
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
CHECK_GL();
glTexCoordPointer(tcoord->getDataSize(), tcoord->getDataType(), 0, tcoord->getDataPointer());
CHECK_GL();
}
else
{
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
CHECK_GL();
}
const size_t nb_prim_set = geom->getNumPrimitiveSets();
for(size_t j = 0 ; j < nb_prim_set ; ++j)
{
const PrimitiveSet * const pset = geom->getPrimitiveSet(j);
const DrawElements * const elts = pset->getDrawElements();
switch(pset->getType())
{
case DrawElements::PrimitiveType:
break;
case DrawElements::DrawArraysPrimitiveType:
glDrawArrays(pset->getMode(), pset->index(0), pset->getNumIndices());
CHECK_GL();
break;
case DrawElements::DrawArrayLengthsPrimitiveType: break;
case DrawElements::DrawElementsUBytePrimitiveType:
glDrawRangeElements(elts->getMode(), 0, vtx->getNumElements() - 1, elts->getNumIndices(), GL_UNSIGNED_BYTE, elts->getDataPointer());
CHECK_GL();
break;
case DrawElements::DrawElementsUShortPrimitiveType:
glDrawRangeElements(elts->getMode(), 0, vtx->getNumElements() - 1, elts->getNumIndices(), GL_UNSIGNED_SHORT, elts->getDataPointer());
CHECK_GL();
break;
case DrawElements::DrawElementsUIntPrimitiveType:
glDrawRangeElements(elts->getMode(), 0, vtx->getNumElements() - 1, elts->getNumIndices(), GL_UNSIGNED_INT, elts->getDataPointer());
CHECK_GL();
break;
}
}
}
if (local_state)
local_state->~StateSet();
}
}
if (bPopMatrix)
popMatrix();
if (stateset)
qStateSet.pop_back();
}
int main()
{
GLFWwindow* window;
NVGcontext* vg = NULL;
GPUtimer gpuTimer;
PerfGraph fps, cpuGraph, gpuGraph;
double prevt = 0, cpuTime = 0;
NVGLUframebuffer* fb = NULL;
int winWidth, winHeight;
int fbWidth, fbHeight;
float pxRatio;
if (!glfwInit()) {
printf("Failed to init GLFW.");
return -1;
}
initGraph(&fps, GRAPH_RENDER_FPS, "Frame Time");
initGraph(&cpuGraph, GRAPH_RENDER_MS, "CPU Time");
initGraph(&gpuGraph, GRAPH_RENDER_MS, "GPU Time");
glfwSetErrorCallback(errorcb);
#ifndef _WIN32 // don't require this on win32, and works with more cards
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#endif
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, 1);
#ifdef DEMO_MSAA
glfwWindowHint(GLFW_SAMPLES, 4);
#endif
window = glfwCreateWindow(1000, 600, "NanoVG", NULL, NULL);
// window = glfwCreateWindow(1000, 600, "NanoVG", glfwGetPrimaryMonitor(), NULL);
if (!window) {
glfwTerminate();
return -1;
}
glfwSetKeyCallback(window, key);
glfwMakeContextCurrent(window);
#ifdef NANOVG_GLEW
glewExperimental = GL_TRUE;
if(glewInit() != GLEW_OK) {
printf("Could not init glew.\n");
return -1;
}
// GLEW generates GL error because it calls glGetString(GL_EXTENSIONS), we'll consume it here.
glGetError();
#endif
#ifdef DEMO_MSAA
vg = nvgCreateGL3(NVG_STENCIL_STROKES | NVG_DEBUG);
#else
vg = nvgCreateGL3(NVG_ANTIALIAS | NVG_STENCIL_STROKES | NVG_DEBUG);
#endif
if (vg == NULL) {
printf("Could not init nanovg.\n");
return -1;
}
// Create hi-dpi FBO for hi-dpi screens.
glfwGetWindowSize(window, &winWidth, &winHeight);
glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
// Calculate pixel ration for hi-dpi devices.
pxRatio = (float)fbWidth / (float)winWidth;
// The image pattern is tiled, set repeat on x and y.
fb = nvgluCreateFramebuffer(vg, (int)(100*pxRatio), (int)(100*pxRatio), NVG_IMAGE_REPEATX | NVG_IMAGE_REPEATY);
if (fb == NULL) {
printf("Could not create FBO.\n");
return -1;
}
if (loadFonts(vg) == -1) {
printf("Could not load fonts\n");
return -1;
}
glfwSwapInterval(0);
initGPUTimer(&gpuTimer);
glfwSetTime(0);
prevt = glfwGetTime();
while (!glfwWindowShouldClose(window))
{
double mx, my, t, dt;
float gpuTimes[3];
int i, n;
t = glfwGetTime();
dt = t - prevt;
prevt = t;
startGPUTimer(&gpuTimer);
glfwGetCursorPos(window, &mx, &my);
glfwGetWindowSize(window, &winWidth, &winHeight);
glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
// Calculate pixel ration for hi-dpi devices.
pxRatio = (float)fbWidth / (float)winWidth;
renderPattern(vg, fb, t, pxRatio);
// Update and render
glViewport(0, 0, fbWidth, fbHeight);
glClearColor(0.3f, 0.3f, 0.32f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
nvgBeginFrame(vg, winWidth, winHeight, pxRatio);
// Use the FBO as image pattern.
if (fb != NULL) {
NVGpaint img = nvgImagePattern(vg, 0, 0, 100, 100, 0, fb->image, 1.0f);
nvgSave(vg);
for (i = 0; i < 20; i++) {
nvgBeginPath(vg);
nvgRect(vg, 10 + i*30,10, 10, winHeight-20);
nvgFillColor(vg, nvgHSLA(i/19.0f, 0.5f, 0.5f, 255));
nvgFill(vg);
}
nvgBeginPath(vg);
nvgRoundedRect(vg, 140 + sinf(t*1.3f)*100, 140 + cosf(t*1.71244f)*100, 250, 250, 20);
nvgFillPaint(vg, img);
nvgFill(vg);
nvgStrokeColor(vg, nvgRGBA(220,160,0,255));
nvgStrokeWidth(vg, 3.0f);
nvgStroke(vg);
nvgRestore(vg);
}
renderGraph(vg, 5,5, &fps);
renderGraph(vg, 5+200+5,5, &cpuGraph);
if (gpuTimer.supported)
renderGraph(vg, 5+200+5+200+5,5, &gpuGraph);
nvgEndFrame(vg);
// Measure the CPU time taken excluding swap buffers (as the swap may wait for GPU)
cpuTime = glfwGetTime() - t;
updateGraph(&fps, dt);
updateGraph(&cpuGraph, cpuTime);
// We may get multiple results.
n = stopGPUTimer(&gpuTimer, gpuTimes, 3);
for (i = 0; i < n; i++)
updateGraph(&gpuGraph, gpuTimes[i]);
glfwSwapBuffers(window);
glfwPollEvents();
}
nvgluDeleteFramebuffer(fb);
nvgDeleteGL3(vg);
printf("Average Frame Time: %.2f ms\n", getGraphAverage(&fps) * 1000.0f);
printf(" CPU Time: %.2f ms\n", getGraphAverage(&cpuGraph) * 1000.0f);
printf(" GPU Time: %.2f ms\n", getGraphAverage(&gpuGraph) * 1000.0f);
glfwTerminate();
return 0;
}
