void InstancingApp::initUI() {
// sample apps automatically have a tweakbar they can use.
if (mTweakBar) { // create our tweak ui
// render method
NvTweakEnum<uint32_t> renderModes[] =
{
{"None", NO_INSTANCING},
{"Shader", SHADER_INSTANCING},
{"Hardware", HARDWARE_INSTANCING}
};
if (!requireExtension("GL_ARB_instanced_arrays", false) &&
!requireExtension("GL_NV_draw_instanced", false))
mTweakBar->addEnum("Instancing Mode:", m_instancingOptions, renderModes, TWEAKENUM_ARRAYSIZE(renderModes)-1);
else
mTweakBar->addEnum("Instancing Mode:", m_instancingOptions, renderModes, TWEAKENUM_ARRAYSIZE(renderModes));
// scene
mTweakBar->addPadding();
NvTweakEnum<uint32_t> renderScenes[] =
{
{"Boxes", BOXES_SCENE},
{"Grass", GRASS_SCENE},
};
mTweakBar->addEnum("Render Mode:", m_sceneIndex, renderScenes, TWEAKENUM_ARRAYSIZE(renderScenes));
// instance count
mTweakBar->addPadding();
mTweakBar->addValue("Instance Count:", m_instanceCount, MAX_INSTANCES, MAX_OBJECTS, MAX_INSTANCES);
// test a checkbox
//mTweakBar->addPadding();
//mTweakBar->addValue("Test Check:", testbool);
}
}
void DeferredShadingMSAA::initRendering(void)
{
NvAssetLoaderAddSearchPath("gl4-kepler/DeferredShadingMSAA");
NvAssetLoaderAddSearchPath("gl4-kepler/DeferredShadingMSAA/models");
if(!requireMinAPIVersion(NvGLAPIVersionGL4(), true))
return;
// Require at least one of these multisample extensions
if (!requireExtension("GL_NV_framebuffer_multisample", false))
{
if (!requireExtension("GL_ARB_multisample", true))
return;
}
glBindFramebuffer(GL_FRAMEBUFFER, getMainFBO());
BuildShaders();
// As a demo, we'll use both methods of loading meshes, and time each of them,
// to illustrate the differences
NvStopWatch* pStopwatch = createStopWatch();
pStopwatch->start();
m_models[SPONZA_MODEL] = LoadModel("models/sponza.obj");
pStopwatch->stop();
float time = pStopwatch->getTime();
LOGI("Standard Model Loading Complete: %f seconds", time);
pStopwatch->start();
m_modelsExt[SPONZA_MODEL] = LoadModelExt("models/sponza.obj");
pStopwatch->stop();
time = pStopwatch->getTime();
LOGI("Extended Model Loading Complete: %f seconds", time);
m_modelID = SPONZA_MODEL;
glDisable(GL_CULL_FACE);
glGenQueries(1, &m_queryId);
#if ENABLE_GPU_TIMERS
for (uint32_t i = 0; i < TIMER_COUNT; ++i)
{
m_timers[i].init();
}
#endif
}
void TerrainTessellation::initRendering(void) {
if (!requireExtension("GL_ARB_tessellation_shader")) return;
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
NvAssetLoaderAddSearchPath("TerrainTessellation");
loadShaders();
CHECK_GL_ERROR();
//
// Create a single default program pipeline to handle binding and unbinding
// separate shader objects
//
glGenProgramPipelines( 1, &mTerrainPipeline);
glBindProgramPipeline( mTerrainPipeline);
CHECK_GL_ERROR();
//create ubo and initialize it with the structure data
glGenBuffers( 1, &mUBO);
glBindBuffer( GL_UNIFORM_BUFFER, mUBO);
glBufferData( GL_UNIFORM_BUFFER, sizeof(TessellationParams), &mParams, GL_STREAM_DRAW);
CHECK_GL_ERROR();
//create simple single-vertex VBO
float vtx_data[] = { 0.0f, 0.0f, 0.0f, 1.0f};
glGenBuffers( 1, &mVBO);
glBindBuffer( GL_ARRAY_BUFFER, mVBO);
glBufferData( GL_ARRAY_BUFFER, sizeof(vtx_data), vtx_data, GL_STATIC_DRAW);
CHECK_GL_ERROR();
srand(0);
int noiseSize = 256;
int noiseSize3D = 64;
mRandTex = createNoiseTexture2D(noiseSize, noiseSize, GL_R8);
CHECK_GL_ERROR();
mRandTex3D = createNoiseTexture4f3D(noiseSize3D, noiseSize3D, noiseSize3D, GL_RGBA8);
CHECK_GL_ERROR();
mParams.invNoiseSize = 1.0f / noiseSize;
mParams.invNoise3DSize = 1.0f / noiseSize3D;
glGenQueries(1, &mGPUQuery);
CHECK_GL_ERROR();
//initTerrainFbo();
//updateQuality();
//CHECK_GL_ERROR();
}
void CascadedShadowMapping::initRendering(void) {
printGLString("Version", GL_VERSION);
printGLString("Vendor", GL_VENDOR);
printGLString("Renderer", GL_RENDERER);
printGLString("Extensions", GL_EXTENSIONS);
GLint depthBits;
glGetIntegerv(GL_DEPTH_BITS, &depthBits);
LOGI("depth bits = %d\n", depthBits);
if (!requireMinAPIVersion(NvGfxAPIVersionGL4_3()))
return;
if (!requireExtension("GL_NV_viewport_array2"))
return;
if (!requireExtension("GL_NV_geometry_shader_passthrough"))
return;
m_renderer->initRendering();
CHECK_GL_ERROR();
}
void TopazSample::initRendering()
{
if (!GLEW_ARB_bindless_texture)
{
LOGI("This sample requires ARB_bindless_texture");
exit(EXIT_FAILURE);
}
bindlessVboUbo = GLEW_NV_vertex_buffer_unified_memory && requireExtension("GL_NV_uniform_buffer_unified_memory", false);
NvAssetLoaderAddSearchPath("Topaz/Topaz");
if(!requireMinAPIVersion(NvGfxAPIVersionGL4_4(), true))
{
exit(EXIT_FAILURE);
}
compileShaders("draw", "shaders/vertex.glsl", "shaders/fragment.glsl");
/*
If needed geometry shader:
compileShaders("geometry", "shaders/vertex.glsl", "shaders/fragment.glsl", "shaders/geometry.glsl");
*/
compileShaders("weightBlended", "shaders/vertex.glsl", "shaders/fragmentBlendOIT.glsl");
compileShaders("weightBlendedFinal", "shaders/vertexOIT.glsl", "shaders/fragmentFinalOIT.glsl");
// like as glClearBufferfv for nv_command_list
compileShaders("clear", "shaders/vertexOIT.glsl", "shaders/clear.glsl");
loadModel("models/background.obj", shaderPrograms["draw"]->getProgram());
loadModel("models/way3.obj", shaderPrograms["draw"]->getProgram(), true);
loadModel("models/way4.obj", shaderPrograms["draw"]->getProgram(), true);
loadModel("models/way5.obj", shaderPrograms["draw"]->getProgram());
loadModel("models/formular.obj", shaderPrograms["draw"]->getProgram());
textures.skybox = NvImage::UploadTextureFromDDSFile("textures/sky_cube.dds");
cmdlist.state.programIncarnation++;
CHECK_GL_ERROR();
}
void MultiDrawIndirect::initRendering(void)
{
NV_APP_BASE_SHARED_INIT();
bool MultidrawAvailable;
m_GPUTimer.init();
m_CPUTimer.init();
MultidrawAvailable = requireExtension("GL_ARB_multi_draw_indirect", false);
if (MultidrawAvailable == false)
{
errorExit("The current system does not appear to support the extension GL_ARB_multi_draw_indirect, which is required by the sample.\n\nThis is likely because the systems GPU or driver does not support the extension. Please see the samples source code for details");
return;
}
if (isMobilePlatform())
{
m_GridSize = DEFAULT_MOBILE_GRID_SIZE;
m_MaxGridSize = MAX_MOBILE_GRID_SIZE;
m_MaxModelInstances = MAX_MODEL_INSTANCES;
}
else
{
m_GridSize = DEFAULT_GRID_SIZE;
m_MaxGridSize = MAX_GRID_SIZE;
m_MaxModelInstances = MAX_MODEL_INSTANCES;
}
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
NvAssetLoaderAddSearchPath("gl4-kepler/MultiDrawIndirect");
CleanRendering();
Startup();
}
void OptimizationApp::initRendering(void) {
glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
NvAssetLoaderAddSearchPath("es2-aurora/OptimizationApp");
#ifdef GL_OES_texture_3D
if (requireExtension("GL_EXT_framebuffer_blit", false)) {
glBlitFramebufferFunc = (void (KHRONOS_APIENTRY *) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter))
getGLContext()->getGLProcAddress("glBlitFramebufferEXT");
} else if (getGLContext()->getConfiguration().apiVer != NvGfxAPIVersionES2()) {
glBlitFramebufferFunc = (void (KHRONOS_APIENTRY *) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter))
getGLContext()->getGLProcAddress("glBlitFramebuffer");
} else {
glBlitFramebufferFunc = NULL;
}
#else
glBlitFramebufferFunc = glBlitFramebuffer;
#endif
if (getGLContext()->getConfiguration().apiVer == NvGfxAPIVersionES2()) {
gFloatTypeEnum = 0x8D61; // GL_HALF_FLOAT_OES, not declared in GL
gLumaTypeEnum = GL_LUMINANCE;
} else {
gFloatTypeEnum = GL_FLOAT;
gLumaTypeEnum = 0x1903; // GL_RED, not declared in ES
}
m_sceneRenderer = new SceneRenderer(
getGLContext()->getConfiguration().apiVer == NvGfxAPIVersionES2());
CHECK_GL_ERROR();
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glClearColor(0.0, 0.0, 1.0, 1.0);
}
void InstancingApp::initRendering(void) {
m_transformer->setTranslationVec(isMobilePlatform()
? nv::vec3f(0.0f, 0.0f, -40.0f) : nv::vec3f(-20.0f, 0.0f, -100.0f));
if( requireMinAPIVersion(NvGLAPIVersionES3(), false) ) {
m_hwInstancing = true;
glDrawElementsInstancedInternal = (PFNDrawElementsInstanced)getGLContext()->getGLProcAddress("glDrawElementsInstanced");
glVertexAttribDivisorInternal = (PFNVertexAttribDivisor)getGLContext()->getGLProcAddress("glVertexAttribDivisor");
} else {
// We need at least _one_ of these two extensions
if (!requireExtension("GL_ARB_instanced_arrays", false) &&
!requireExtension("GL_NV_draw_instanced", false)) {
m_hwInstancing = false;
m_instancingOptions = SHADER_INSTANCING;
} else {
m_hwInstancing = true;
if (requireExtension("GL_ARB_instanced_arrays", false) ) {
glDrawElementsInstancedInternal = (PFNDrawElementsInstanced)getGLContext()->getGLProcAddress("glDrawElementsInstancedARB");
glVertexAttribDivisorInternal = (PFNVertexAttribDivisor)getGLContext()->getGLProcAddress("glVertexAttribDivisorARB");
}
else
{
glDrawElementsInstancedInternal = (PFNDrawElementsInstanced)getGLContext()->getGLProcAddress("glDrawElementsInstancedNV");
glVertexAttribDivisorInternal = (PFNVertexAttribDivisor)getGLContext()->getGLProcAddress("glVertexAttribDivisorNV");
}
}
}
if( m_hwInstancing == false )
{
m_instancingOptions = SHADER_INSTANCING;
}
NvAssetLoaderAddSearchPath("es2-aurora/InstancingApp");
LOGI("Hardware Instancing %s\n", m_hwInstancing ? "Available" : "Not available" );
if (getGLContext()->getConfiguration().apiVer.api == NvGLAPI::GL) {
NvGLSLProgram::setGlobalShaderHeader("#version 130\n");
}
else {
NvGLSLProgram::setGlobalShaderHeader("#version 300 es\n");
}
//init the shaders
m_shaders[0] = NvGLSLProgram::createFromFiles("shaders/boxes.vert", "shaders/boxes.frag");
m_shaders[1] = NvGLSLProgram::createFromFiles("shaders/grass.vert", "shaders/grass.frag");
m_shaders[2] = NvGLSLProgram::createFromFiles("shaders/boxes_instanced.vert", "shaders/boxes.frag");
m_shaders[3] = NvGLSLProgram::createFromFiles("shaders/grass_instanced.vert", "shaders/grass.frag");
NvGLSLProgram::setGlobalShaderHeader(NULL);
initShaders();
CHECK_GL_ERROR();
//load g_pModel
loadModelFromFile("models/cube.obj", 0);
loadModelFromFile("models/grass.obj", 1);
CHECK_GL_ERROR();
GLuint texID;
NvImage::VerticalFlip(false);
CHECK_GL_ERROR();
texID = NvImageGL::UploadTextureFromDDSFile("images/rock.dds");
if( texID > 0) {
configTexture( texID, 0 );
configTexture( texID, 2 );
}
CHECK_GL_ERROR();
texID = NvImageGL::UploadTextureFromDDSFile( "images/grass.dds" );
if( texID > 0) {
configTexture( texID, 1 );
configTexture( texID, 3 );
}
CHECK_GL_ERROR();
texID = NvImageGL::UploadTextureFromDDSFile( "images/rock.dds" );
if( texID > 0)
configTexture( texID, 2 );
CHECK_GL_ERROR();
texID = NvImageGL::UploadTextureFromDDSFile( "images/grass.dds" );
if( texID > 0)
configTexture( texID, 3 );
CHECK_GL_ERROR();
NvImage::VerticalFlip(false);
glClearColor(0.0, 0.0, 0.0, 1.0);
CHECK_GL_ERROR();
}
void InstancedTessellation::initRendering(void) {
if( requireMinAPIVersion(NvGfxAPIVersionES3(), false) ) {
m_hwInstancing = true;
glDrawElementsInstancedInternal = (PFNDrawElementsInstanced)getGLContext()->getGLProcAddress("glDrawElementsInstanced");
glVertexAttribDivisorInternal = (PFNVertexAttribDivisor)getGLContext()->getGLProcAddress("glVertexAttribDivisor");
}
else {
// We need at least _one_ of these two extensions
if (!requireExtension("GL_ARB_instanced_arrays", false) &&
!requireExtension("GL_NV_draw_instanced", false)) {
m_hwInstancing = false;
}
else {
m_hwInstancing = true;
if (requireExtension("GL_ARB_instanced_arrays", false) ) {
glDrawElementsInstancedInternal = (PFNDrawElementsInstanced)getGLContext()->getGLProcAddress("glDrawElementsInstancedARB");
glVertexAttribDivisorInternal = (PFNVertexAttribDivisor)getGLContext()->getGLProcAddress("glVertexAttribDivisorARB");
}
else {
glDrawElementsInstancedInternal = (PFNDrawElementsInstanced)getGLContext()->getGLProcAddress("glDrawElementsInstancedNV");
glVertexAttribDivisorInternal = (PFNVertexAttribDivisor)getGLContext()->getGLProcAddress("glVertexAttribDivisorNV");
}
}
}
if( m_hwInstancing ) {
m_instancing = true;
}
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
NvAssetLoaderAddSearchPath("es2-aurora/InstancedTessellation");
LOGI("Hardware Instancing %s\n", m_hwInstancing ? "Available" : "Not available" );
int len;
char *pBuff;
initShaders();
for( int i = 0; i < eNumModels; ++i )
{
std::string path = "models/";
path += m_pModelNames[i];
path += ".obj";
pBuff = NvAssetLoaderRead(path.c_str(), len);
loadModelFromData(i,pBuff);
initPerModelTessellationInstancingData(m_pModel[i], i );
delete [] pBuff;
}
initGeneralTessellationInstancingData();
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glClearColor(0.0, 0.0, 0.0, 1.0);
CHECK_GL_ERROR();
}
