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); //} }