void NormalBlendedDecal::initRendering(void)
{
if (!requireMinAPIVersion(NvGfxAPIVersionGL4_3()))
return;
//if (!requireExtension("GL_NV_fragment_shader_interlock"))
// return;
bool isPSISupported = getGLContext()->isExtensionSupported("GL_NV_fragment_shader_interlock");
if (isPSISupported) {
mLock = LOCK_PIXEL_SHADER_INTERLOCK;
} else {
mLock = LOCK_MEMORY_BARRIER;
}
NvAssetLoaderAddSearchPath("gl4-maxwell/NormalBlendedDecal");
if (!buildShaders()) {
LOGI("Shader build error");
return;
}
mCube = loadModel("models/cube.obj");
mModels[BUNNY_MODEL] = loadModel("models/bunny2.obj");
mModels[BOX_MODEL] = loadModel("models/cube.obj");
mModelID = BUNNY_MODEL;
mDecalNormals[0] = NvImage::UploadTextureFromDDSFile("textures/rock_normal.dds");
mDecalNormals[1] = NvImage::UploadTextureFromDDSFile("textures/brick_normal.dds");
// Disable wait for vsync
getGLContext()->setSwapInterval(0);
}
void ComputeBasicGLSL::initRendering(void)
{
NV_APP_BASE_SHARED_INIT();
NvAssetLoaderAddSearchPath("es3aep-kepler/ComputeBasicGLSL");
if (!requireMinAPIVersion(NvGLAPIVersionES3_1()))
return;
{
NvScopedShaderPrefix switched(
(getGLContext()->getConfiguration().apiVer.api == NvGLAPI::GL)
? "#version 430\n" : "#version 310 es\n");
//init shaders
m_blitProg = NvGLSLProgram::createFromFiles("shaders/plain.vert", "shaders/plain.frag");
m_computeProg = new NvGLSLProgram;
int32_t len;
NvGLSLProgram::ShaderSourceItem sources[1];
sources[0].type = GL_COMPUTE_SHADER;
sources[0].src = NvAssetLoaderRead("shaders/invert.glsl", len);
m_computeProg->setSourceFromStrings(sources, 1);
NvAssetLoaderFree((char*)sources[0].src);
}
//load input texture - this is a normal, "mutable" texture
m_sourceImage = NvImage::CreateFromDDSFile("textures/flower1024.dds");
GLint w = m_sourceImage->getWidth();
GLint h = m_sourceImage->getHeight();
GLint intFormat = m_sourceImage->getInternalFormat();
GLint format = m_sourceImage->getFormat();
GLint type = m_sourceImage->getType();
// Image must be immutable in order to be used with glBindImageTexture
// So we copy the mutable texture to an immutable texture
glGenTextures(1, &m_sourceTexture );
glBindTexture(GL_TEXTURE_2D, m_sourceTexture);
glTexStorage2D(GL_TEXTURE_2D, 1, intFormat, w, h );
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, format, type, m_sourceImage->getLevel(0));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
//create output texture with same size and format as input
// Image must be immutable in order to be used with glBindImageTexture
glGenTextures(1, &m_resultTexture );
glBindTexture(GL_TEXTURE_2D, m_resultTexture);
glTexStorage2D(GL_TEXTURE_2D, 1, intFormat, w, h );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
CHECK_GL_ERROR();
glBindTexture(GL_TEXTURE_2D, 0);
}
void ParticleUpsampling::initRendering(void)
{
//glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
NvAssetLoaderAddSearchPath("es2-aurora/ParticleUpsampling");
m_sceneRenderer = new SceneRenderer(requireMinAPIVersion(NvGfxAPIVersionGL4(), false));
CHECK_GL_ERROR();
}
void FXAA::initRendering(void) {
m_aspectRatio = 1.0;
NvAssetLoaderAddSearchPath("es3-kepler/FXAA");
if(!requireMinAPIVersion(NvGLAPIVersionES3()))
return;
m_transformer->setTranslationVec(nv::vec3f(0.0f, 0.0f, -3.0f));
m_transformer->setRotationVec(nv::vec3f(NV_PI*0.15f, 0.0f, 0.0f));
float* buf = genLineSphere(40, &m_sphereBufferSize, 1);
glGenBuffers(1, &m_sphereVBO);
glBindBuffer(GL_ARRAY_BUFFER, m_sphereVBO);
glBufferData(GL_ARRAY_BUFFER, m_sphereBufferSize, buf, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
delete[] buf;
int i;
void* pData=0;
for (i=0; i<2; i++) {
m_objectFileSize[i] = LoadMdlDataFromFile(model_files[i], &pData);
glGenBuffers(1, &m_object[i]);
glBindBuffer(GL_ARRAY_BUFFER, m_object[i]);
glBufferData(GL_ARRAY_BUFFER, m_objectFileSize[i], pData, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
free(pData);
}
//init shaders
m_FXAAProg[0] = NvGLSLProgram::createFromFiles("shaders/Blit.vert", "shaders/Blit.frag");
for (i=1; i<5; i++) {
m_FXAAProg[i] = NvGLSLProgram::createFromFiles("shaders/FXAA.vert",
(getGLContext()->getConfiguration().apiVer.api == NvGLAPI::GL)
? fxaa_quality_frg[i-1] : fxaa_quality_frg_es[i-1]);
}
m_LineProg = NvGLSLProgram::createFromFiles("shaders/DrawLine.vert", "shaders/DrawLine.frag");
m_ObjectProg = NvGLSLProgram::createFromFiles("shaders/Object.vert", "shaders/Object.frag");
//init textures
genRenderTexture();
glBindTexture(GL_TEXTURE_2D, m_sourceTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
nv::perspective(m_projection_matrix, FOV * 0.5f, getGLContext()->width()/(float)getGLContext()->height(), Z_NEAR, Z_FAR);
CHECK_GL_ERROR();
}
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 ComputeBasicGLSL::initRendering(void)
{
NvAssetLoaderAddSearchPath("ComputeBasicGLSL");
if (!requireMinAPIVersion(NvGfxAPIVersionGL4()))
return;
//init shaders
m_blitProg = NvGLSLProgram::createFromFiles("shaders/plain.vert", "shaders/plain.frag");
m_computeProg = new NvGLSLProgram;
int32_t len;
NvGLSLProgram::ShaderSourceItem sources[1];
sources[0].type = GL_COMPUTE_SHADER;
sources[0].src = NvAssetLoaderRead("shaders/invert.glsl", len);
m_computeProg->setSourceFromStrings(sources, 1);
NvAssetLoaderFree((char*)sources[0].src);
//load input texture
m_sourceImage = NvImage::CreateFromDDSFile("textures/flower1024.dds");
m_sourceTexture = NvImage::UploadTexture(m_sourceImage);
glBindTexture(GL_TEXTURE_2D, m_sourceTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
//create output texture with same size and format as input
GLint w = m_sourceImage->getWidth();
GLint h = m_sourceImage->getHeight();
GLint intFormat = m_sourceImage->getInternalFormat();
GLint format = m_sourceImage->getFormat();
GLint type = m_sourceImage->getType();
glGenTextures(1, &m_resultTexture );
glBindTexture(GL_TEXTURE_2D, m_resultTexture);
glTexImage2D(GL_TEXTURE_2D, 0, intFormat, w, h, 0, format, type, 0 );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
CHECK_GL_ERROR();
glBindTexture(GL_TEXTURE_2D, 0);
}
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 ParticleUpsampling::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);
//glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
NvAssetLoaderAddSearchPath("ParticleUpsampling");
m_sceneRenderer = new SceneRenderer(requireMinAPIVersion(NvGfxAPIVersionGL4(), false));
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 MotionBlur::initRendering(void) {
// This sample requires at least OpenGL ES 2.0
if (!requireMinAPIVersion(NvGfxAPIVersionES2()))
return;
cleanRendering();
NvAssetLoaderAddSearchPath("es2-aurora/MotionBlur");
mSceneColorShader = new SceneColorShader;
mSkyboxColorShader = new SkyboxColorShader;
mMotionBlurShader = new MotionBlurShader;
// Load model data for scene geometry
int32_t length;
char *modelData = NvAssetLoaderRead("models/house.obj", length);
mHouseModel = new NvGLModel();
mHouseModel->loadModelFromObjData(modelData);
mHouseModel->initBuffers();
NvAssetLoaderFree(modelData);
modelData = NvAssetLoaderRead("models/fan.obj", length);
mSailsModel = new NvGLModel();
mSailsModel->loadModelFromObjData(modelData);
mSailsModel->initBuffers();
NvAssetLoaderFree(modelData);
// Load some scene textures
mHouseTexID =
NvImage::UploadTextureFromDDSFile("textures/windmill_diffuse.dds");
glBindTexture(GL_TEXTURE_2D, mHouseTexID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
CHECK_GL_ERROR();
mSkyBoxTexID = NvImage::UploadTextureFromDDSFile("textures/sky_cube.dds");
glBindTexture(GL_TEXTURE_CUBE_MAP, mSkyBoxTexID);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
CHECK_GL_ERROR();
// Assign some uniform values that never change.
nv::vec4f lightPositionEye(1.0f, 1.0f, 1.0f, 0.0f);
mSceneColorShader->enable();
glUniform4fv(mSceneColorShader->lightPositionUHandle, 1,
lightPositionEye._array);
glUniform1f(mSceneColorShader->lightAmbientUHandle, 0.1f);
glUniform1f(mSceneColorShader->lightDiffuseUHandle, 0.7f);
glUniform1f(mSceneColorShader->lightSpecularUHandle, 1.0f);
glUniform1f(mSceneColorShader->lightShininessUHandle, 64.0f);
CHECK_GL_ERROR();
mSceneColorShader->disable();
// Set some pipeline state settings that do not change
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
CHECK_GL_ERROR();
}
void Mercury::initRendering(void) {
// OpenGL 4.3 is the minimum for compute shaders
if (!requireMinAPIVersion(NvGLAPIVersionES3_1()))
return;
// Set Clear Color
glClearColor(0.25f, 0.25f, 0.25f, 1.0f);
CHECK_GL_ERROR();
NvAssetLoaderAddSearchPath("es3aep-kepler/Mercury");
const char* shaderPrefix =
(getGLContext()->getConfiguration().apiVer.api == NvGLAPI::GL)
? "#version 430\n" : "#version 310 es\n";
CHECK_GL_ERROR();
{
int32_t len;
// Initialize Particles Render Program
NvScopedShaderPrefix switched(shaderPrefix);
std::string renderPartVS = loadShaderSourceWithUniformTag("shaders/uniforms.h", "shaders/renderPartVS.glsl");
std::string renderPartGS = loadShaderSourceWithUniformTag("shaders/uniforms.h", "shaders/renderPartGS.glsl");
mParticlesRenderProg = new NvGLSLProgram;
NvGLSLProgram::ShaderSourceItem sourcesP[2];
sourcesP[0].type = GL_VERTEX_SHADER;
sourcesP[0].src = renderPartVS.c_str();
sourcesP[1].type = GL_FRAGMENT_SHADER;
sourcesP[1].src = NvAssetLoaderRead("shaders/renderPartFS.glsl", len);
mParticlesRenderProg->setSourceFromStrings(sourcesP, 2);
NvAssetLoaderFree((char*)sourcesP[1].src);
// Initialize Surface Render Program
std::string renderSurfVS = loadShaderSourceWithUniformTag("shaders/uniforms.h", "shaders/renderSurfVS.glsl");
std::string renderSurfGS = loadShaderSourceWithUniformTag("shaders/uniforms.h", "shaders/renderSurfGS.glsl");
std::string renderSurfFS = loadShaderSourceWithUniformTag("shaders/uniforms.h", "shaders/renderSurfFS.glsl");
mSurfaceRenderProg = new NvGLSLProgram;
NvGLSLProgram::ShaderSourceItem sourcesS[3];
sourcesS[0].type = GL_VERTEX_SHADER;
sourcesS[0].src = renderSurfVS.c_str();
sourcesS[1].type = GL_GEOMETRY_SHADER_EXT;
sourcesS[1].src = renderSurfGS.c_str();
sourcesS[2].type = GL_FRAGMENT_SHADER;
sourcesS[2].src = renderSurfFS.c_str();
mSurfaceRenderProg->setSourceFromStrings(sourcesS, 3);
std::string quadVS = loadShaderSourceWithUniformTag("shaders/uniforms.h", "shaders/renderQuadVS.glsl");
std::string quadFS = loadShaderSourceWithUniformTag("shaders/uniforms.h", "shaders/renderQuadFS.glsl");
mQuadProg = new NvGLSLProgram;
NvGLSLProgram::ShaderSourceItem sourcesQ[2];
sourcesQ[0].type = GL_VERTEX_SHADER;
sourcesQ[0].src = quadVS.c_str();
sourcesQ[1].type = GL_FRAGMENT_SHADER;
sourcesQ[1].src = quadFS.c_str();
mQuadProg->setSourceFromStrings(sourcesQ, 2);
std::string blurVS = loadShaderSourceWithUniformTag("shaders/uniforms.h", "shaders/blurVS.glsl");
std::string blurFS = loadShaderSourceWithUniformTag("shaders/uniforms.h", "shaders/blurFS.glsl");
mBlurProg = new NvGLSLProgram;
NvGLSLProgram::ShaderSourceItem sourcesB[2];
sourcesB[0].type = GL_VERTEX_SHADER;
sourcesB[0].src = blurVS.c_str();
sourcesB[1].type = GL_FRAGMENT_SHADER;
sourcesB[1].src = blurFS.c_str();
mBlurProg->setSourceFromStrings(sourcesB, 2);
}
CHECK_GL_ERROR();
// Set up cubemap for skybox
mSkyBoxTexID = NvImageGL::UploadTextureFromDDSFile("textures/sky_cube.dds");
glBindTexture(GL_TEXTURE_CUBE_MAP, mSkyBoxTexID);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
CHECK_GL_ERROR();
// Initialize skybox for screen quad
mScreenQuadPos = new ShaderBuffer<nv::vec4f>(4);
vec4f* pos = mScreenQuadPos->map();
pos[0] = vec4f(-1.0f, -1.0f, -1.0f, 1.0f);
pos[1] = vec4f( 1.0f, -1.0f, -1.0f, 1.0f);
pos[2] = vec4f(-1.0f, 1.0f, -1.0f, 1.0f);
pos[3] = vec4f( 1.0f, 1.0f, -1.0f, 1.0f);
mScreenQuadPos->unmap();
//create ubo and initialize it with the structure data
glGenBuffers( 1, &mUBO);
glBindBuffer( GL_UNIFORM_BUFFER, mUBO);
glBufferData( GL_UNIFORM_BUFFER, sizeof(ShaderParams), &mShaderParams, 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();
// For now, scale back the particle count on mobile.
//int32_t particleCount = isMobilePlatform() ? (mNumParticles >> 2) : mNumParticles;
int32_t particleCount = mNumParticles;
mParticles = new ParticleSystem(particleCount, shaderPrefix);
CHECK_GL_ERROR();
int cx, cy, cz;
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_COUNT, 0, &cx );
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_COUNT, 1, &cy );
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_COUNT, 2, &cz );
LOGI("Max compute work group count = %d, %d, %d\n", cx, cy, cz );
int sx, sy, sz;
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_SIZE, 0, &sx );
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_SIZE, 1, &sy );
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_SIZE, 2, &sz );
LOGI("Max compute work group size = %d, %d, %d\n", sx, sy, sz );
CHECK_GL_ERROR();
//Set clockwise winding
glFrontFace(GL_CW);
// Texture
const int screen_width = getAppContext()->width();
const int screen_height = getAppContext()->height();
// Frame buffer for final scene
glGenTextures(gbuffer_size, gbuffer_tex);
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
for (int i = 0; i < gbuffer_size; i++) {
glActiveTexture(GL_TEXTURE0 + 3 + i);
glBindTexture(GL_TEXTURE_2D, gbuffer_tex[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, screen_width, screen_height, 0, GL_RGBA, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTextureEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, gbuffer_tex[i], 0);
}
// Depth buffer
glGenRenderbuffers(1, &rbo_depth);
glBindRenderbuffer(GL_RENDERBUFFER, rbo_depth);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, screen_width, screen_height);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rbo_depth);
GLuint attachments[gbuffer_size];
for (int i = 0; i < gbuffer_size; i++) {
attachments[i] = GL_COLOR_ATTACHMENT0 + i;
}
glDrawBuffers(gbuffer_size, attachments);
GLenum status;
if ((status = glCheckFramebufferStatus(GL_FRAMEBUFFER)) != GL_FRAMEBUFFER_COMPLETE) {
LOGE("glCheckFramebufferStatus: error %p", status);
exit(0);
}
glBindFramebuffer(GL_FRAMEBUFFER, 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();
}
void ComputeWaterSimulation::initRendering(void) {
// OpenGL 4.3 is the minimum for compute shaders
if (!requireMinAPIVersion(NvGfxAPIVersionGL4_3()))
return;
// check if we need glMemoryBarrier hack (on non-NV, we are
// seeing corruption caused by glMemoryBarrier not actually
// synchronizing)
const char* vendorName = (const char*)glGetString(GL_VENDOR);
if (!strstr(vendorName, "NVIDIA"))
{
LOGI("glMemoryBarrier() hack enabled. Vendor = %s\n", vendorName);
m_hackMemoryBarrier = true;
}
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
NvAssetLoaderAddSearchPath("es3aep-kepler/ComputeWaterSimulation");
int cx, cy, cz;
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_COUNT, 0, &cx );
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_COUNT, 1, &cy );
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_COUNT, 2, &cz );
LOGI("Max compute work group count = %d, %d, %d\n", cx, cy, cz );
int sx, sy, sz;
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_SIZE, 0, &sx );
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_SIZE, 1, &sy );
glGetIntegeri_v( GL_MAX_COMPUTE_WORK_GROUP_SIZE, 2, &sz );
LOGI("Max compute work group size = %d, %d, %d\n", sx, sy, sz );
CHECK_GL_ERROR();
// load shaders
mWaterShader[WATER_SHADER_DEFAULT] = NvGLSLProgram::createFromFiles("shaders/water.vert", "shaders/water.frag");
mWaterShader[WATER_SHADER_NORMALS] = NvGLSLProgram::createFromFiles("shaders/water.vert", "shaders/waterNormals.frag");
mWaterShader[WATER_SHADER_FRESNEL] = NvGLSLProgram::createFromFiles("shaders/water.vert", "shaders/waterFresnel.frag");
// load compute shaders
std::string src;
src = loadShaderSourceWithUniformTag("shaders/uniforms.h", "shaders/WaterTransformPass.glsl");
createShaderPipelineProgram(GL_COMPUTE_SHADER, src.c_str(), mTransformPipeline, mTransformProgram);
src = loadShaderSourceWithUniformTag("shaders/uniforms.h", "shaders/WaterGradientsPass.glsl");
createShaderPipelineProgram(GL_COMPUTE_SHADER, src.c_str(), mGradientsPipeline, mGradientsProgram);
mSkyTexture = NvImage::UploadTextureFromDDSFile("sky/day.dds");
// init GPU buffers
uint32_t maxGridSize = MAX_GRID_SIZE + 2;
GLuint size = sizeof(GLfloat) * maxGridSize * maxGridSize;
for(int i = 0; i < 4; i++)
{
glGenBuffers(1, &mHeightBuffer[i]);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, mHeightBuffer[i]);
glBufferData(GL_SHADER_STORAGE_BUFFER, size, NULL, GL_DYNAMIC_DRAW);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
glGenBuffers(1, &mVelocityBuffer[i]);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, mVelocityBuffer[i]);
glBufferData(GL_SHADER_STORAGE_BUFFER, size, NULL, GL_DYNAMIC_DRAW);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
}
initWaves(mNumWaves);
//for(int i = 0; i < 4; i++)
//{
// glGenBuffers(1, &mHeightBuffer[i]);
// glBindBuffer(GL_SHADER_STORAGE_BUFFER, mHeightBuffer[i]);
// glBufferData(GL_SHADER_STORAGE_BUFFER, size, mWaves[0]->getSimulation().getHeightField(), GL_STATIC_DRAW);
// glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
// glGenBuffers(1, &mVelocityBuffer[i]);
// glBindBuffer(GL_SHADER_STORAGE_BUFFER, mVelocityBuffer[i]);
// glBufferData(GL_SHADER_STORAGE_BUFFER, size, mWaves[0]->getSimulation().getHeightField(), GL_STATIC_DRAW);
// glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
//}
}
