bool FXAA::genRenderTexture()
{
int width = getGLContext()->width();
int height = getGLContext()->height();
glGenFramebuffers(1, &m_sourceFrameBuffer);
glBindFramebuffer(GL_FRAMEBUFFER, m_sourceFrameBuffer);
glGenTextures(1, &m_sourceTexture);
glBindTexture(GL_TEXTURE_2D, m_sourceTexture);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_sourceTexture, 0);
glGenRenderbuffers(1, &m_sourceDepthBuffer);
glBindRenderbuffer(GL_RENDERBUFFER, m_sourceDepthBuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width, height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_sourceDepthBuffer);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
// Finalize
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
return false;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return true;
}
void TextureUploadProcessor::runLoop_()
{
_needRedraw = false;
if( GLContext::getCurrent() != getGLContext().get( ))
getGLContext()->makeCurrent();
processorInputPtr_->applyAll( CONNECTION_ID );
_checkThreadOperation();
#ifdef _ITT_DEBUG_
__itt_task_begin ( ittTextureLoadDomain, __itt_null, __itt_null, ittTextureComputationTask );
#endif //_ITT_DEBUG_
const DashRenderStatus& renderStatus = _dashTree->getRenderStatus();
if( renderStatus.getFrameID() != _currentFrameID )
{
_protectUnloading.clear();
CollectVisiblesVisitor collectVisibles( _dashTree,
_protectUnloading );
DFSTraversal traverser;
const RootNode& rootNode =
_dashTree->getDataSource()->getVolumeInformation().rootNode;
traverser.traverse( rootNode, collectVisibles, renderStatus.getFrameID( ));
_textureCache.setProtectList( _protectUnloading );
_currentFrameID = renderStatus.getFrameID();
}
_loadData();
processorOutputPtr_->commit( CONNECTION_ID );
#ifdef _ITT_DEBUG_
__itt_task_end( ittTextureLoadDomain );
#endif //_ITT_DEBUG_
}
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);
}
bool TextureUploadProcessor::initializeThreadRun_()
{
setName( "TexUp" );
_textureCache.setMaximumMemory( _vrParameters->maxGPUCacheMemoryMB * LB_1MB );
LBASSERT( getGLContext( ));
_shareContext->shareContext( getGLContext( ));
return DashProcessor::initializeThreadRun_();
}
void NvAppBase::mainLoop() {
bool hasInitializedGL = false;
while (getPlatformContext()->isAppRunning() && !isExiting()) {
bool needsReshape = false;
getPlatformContext()->pollEvents(this);
NvPlatformContext* ctx = getPlatformContext();
update();
// If the context has been lost and graphics resources are still around,
// signal for them to be deleted
if (ctx->isContextLost()) {
if (hasInitializedGL) {
shutdownRendering();
hasInitializedGL = false;
}
}
// If we're ready to render (i.e. the GL is ready and we're focused), then go ahead
if (ctx->shouldRender()) {
// If we've not (re-)initialized the resources, do it
if (!hasInitializedGL) {
NvImage::setAPIVersion(getGLContext()->getConfiguration().apiVer);
initRendering();
hasInitializedGL = true;
needsReshape = true;
} else if (ctx->hasWindowResized()) {
needsReshape = true;
}
if (needsReshape) {
reshape(getGLContext()->width(), getGLContext()->height());
}
if (!isExiting()) {
draw();
getGLContext()->swap();
}
}
}
if (hasInitializedGL) {
shutdownRendering();
hasInitializedGL = false;
}
}
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();
}
////////////////////////////////////////////////////////////////////////////////
//
// Method: SkinningApp::initUI()
//
// Sets up the user interface
//
////////////////////////////////////////////////////////////////////////////////
void SkinningApp::initUI() {
if (mTweakBar) {
NvTweakVarBase *var;
// expose the rendering modes
NvTweakEnum<uint32_t> renderModes[] = {
{"Color", 0},
{"Normals", 1},
{"Weights", 2}
};
var = mTweakBar->addEnum("Render Mode", m_renderMode, renderModes, TWEAKENUM_ARRAYSIZE(renderModes));
addTweakKeyBind(var, NvKey::K_M);
addTweakButtonBind(var, NvGamepad::BUTTON_Y);
mTweakBar->addPadding();
var = mTweakBar->addValue("Single Bone Skinning", m_singleBoneSkinning);
addTweakKeyBind(var, NvKey::K_B);
addTweakButtonBind(var, NvGamepad::BUTTON_X);
mTweakBar->addPadding();
m_timeScalar = 1.0f;
var = mTweakBar->addValue("Animation Speed", m_timeScalar, 0, 5.0, 0.1f);
addTweakKeyBind(var, NvKey::K_RBRACKET, NvKey::K_LBRACKET);
addTweakButtonBind(var, NvGamepad::BUTTON_RIGHT_SHOULDER, NvGamepad::BUTTON_LEFT_SHOULDER);
}
// Change the filtering for the framerate
mFramerate->setMaxReportRate(.2f);
mFramerate->setReportFrames(20);
// Disable wait for vsync
getGLContext()->setSwapInterval(0);
}
GLvoid FrameBufferObject::attachDepth(GLuint width, GLuint height)
{
std::shared_ptr<Texture> depth = std::make_shared<Texture>(getGLContext(), width, height, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE,
GL_LINEAR, GL_LINEAR,
GL_REPLACE, GL_REPEAT);
attachDepth(depth);
}
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 NormalBlendedDecal::initUI()
{
// sample apps automatically have a tweakbar they can use.
if (mTweakBar) { // create our tweak ui
// Lock options
bool isPSISupported = getGLContext()->isExtensionSupported("GL_NV_fragment_shader_interlock");
if (isPSISupported) {
NvTweakEnum<uint32_t> locks[] =
{
{"No Lock", LOCK_NONE},
{"MemoryBarrier", LOCK_MEMORY_BARRIER},
{"PixelShaderInterlock", LOCK_PIXEL_SHADER_INTERLOCK},
};
mTweakBar->addEnum("Lock Option:", (uint32_t&)mLock, locks, TWEAKENUM_ARRAYSIZE(locks), REACT_LOCK_METHOD);
} else {
NvTweakEnum<uint32_t> locks[] =
{
{"No Lock", LOCK_NONE},
{"MemoryBarrier", LOCK_MEMORY_BARRIER},
};
mTweakBar->addEnum("Lock Option:", (uint32_t&)mLock, locks, TWEAKENUM_ARRAYSIZE(locks));
}
// View options
NvTweakEnum<uint32_t> viewsOptions[] =
{
{"Default", VIEW_DEFAULT},
{"Normals", VIEW_NORMALS},
{"Decal Boxes", VIEW_DECAL_BOXES},
};
mTweakBar->addPadding();
mTweakBar->addEnum("View Option:", (uint32_t&)mViewOption, viewsOptions, TWEAKENUM_ARRAYSIZE(viewsOptions));
mTweakBar->addValue("Model Grid Size", mSqrtNumModels, 0, 10, 1);
#if (0) // Too many options
mTweakBar->addValue("Model Distance", mModelDistance, 0.0f, 4.0f, 0.01f);
mTweakBar->addValue("Number of Decals", mNumDecals, 0, 100, 1);
mTweakBar->addValue("Decal Size", mDecalSize, 0.0f, 4.0f, 0.01f);
#endif
// Decals options
mTweakBar->addPadding();
mTweakBar->addValue("Decal Distance", mDecalDistance, 0.0f, 4.0f, 0.01f);
mTweakBar->addValue("Decal Blend Weight", mBlendWeight, 0.0f, 1.0f, 0.01f);
// Model options
mTweakBar->addPadding();
NvTweakEnum<uint32_t> models[] =
{
{"Bunny", BUNNY_MODEL},
{"Box", BOX_MODEL},
};
mTweakBar->addEnum("Models:", mModelID, models, TWEAKENUM_ARRAYSIZE(models));
}
}
void SDLWindow::swapBuffers() const
{
ScopeTimer timer(SwapBufferProfilingZone);
#ifdef linux
getGLContext()->swapBuffers();
#else
SDL_GL_SwapBuffers();
#endif
GLContext::checkError("swapBuffers()");
}
void OpenGLView::renderView()
{
OpenGLView::m_renderMutex.lock();
getGLContext();
render();
swapBuffers();
OpenGLView::m_renderMutex.unlock();
}
void SoundplaneZoneView::renderOpenGL()
{
if (!mpModel) return;
if(!getGLContext()->isAttached()) return;
{
const Colour c = findColour(MLLookAndFeel::backgroundColor);
OpenGLHelpers::clear (c);
glEnable(GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
renderGrid();
renderZones();
}
}
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 OptimizationApp::draw(void)
{
GLuint prevFBO = 0;
// Enum has MANY names based on extension/version
// but they all map to 0x8CA6
glGetIntegerv(0x8CA6, (GLint*)&prevFBO);
m_sceneRenderer->getSceneFBOParams()->particleDownsample =
m_sceneRenderer->getParticleParams()->renderLowResolution ? 2.0f : 1.0f;
m_sceneRenderer->getSceneFBOParams()->sceneDownsample =
m_sceneRenderer->getSceneParams()->renderLowResolution ? 2.0f : 1.0f;
m_sceneRenderer->updateFrame(getFrameDeltaTime());
// To maintain correct rendering of the blur we have to detect when we've been paused by PerfHUD.
// This logic ensures that the time-dependent blur remains when the frame debugger is activated.
m_pausedByPerfHUD = (getFrameDeltaTime() == 0.0f);
// WARNING!!!!! This is NOT a great idea for perf, but if we cannot disable
// vsync, then the CPU stats will be wrong (because some GL call will block on last
// frame's vsync)
if (!getGLContext()->setSwapInterval(0))
glFlush();
if (!m_pausedByPerfHUD)
updateViewDependentParams();
glViewport(0, 0, m_width, m_height);
glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
m_sceneRenderer->renderFrame();
glBindFramebuffer(GL_FRAMEBUFFER, prevFBO);
glViewport(0, 0, m_sceneRenderer->getScreenWidth(), m_sceneRenderer->getScreenHeight());
char buffer[1024];
if (m_sceneRenderer->stats(buffer, 1024)) {
m_timingStats->SetString(buffer);
}
}
////////////////////////////////////////////////////////////////////////////////
//
// Method: SkinningApp::initRendering()
//
// Sets up initial rendering state and creates the skinned character mesh
//
////////////////////////////////////////////////////////////////////////////////
void SkinningApp::initRendering(void) {
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
NvAssetLoaderAddSearchPath("es2-aurora/SkinningApp");
m_mesh.m_useES2 = getGLContext()->getConfiguration().apiVer == NvGLAPIVersionES2();
// Initialize the mesh
int32_t vertexCount = sizeof(g_characterModelVertices) / (10*sizeof(float)); // 3x pos, 3x norm, (2+2)x bone
int32_t indexCount = sizeof(g_characterModelIndices) / (sizeof(g_characterModelIndices[0]));
// Convert the float data in the vertex array to half data
// On Android, this may have already been converted during a previous run and
// kept in-core. We MUST skip this step in that case.
if (!g_convertedToSkinnedVertex) {
int32_t index = 0;
for(int32_t i=0; i<vertexCount; i++)
{
SkinnedVertex& v = ((SkinnedVertex*)g_characterModelVertices)[i];
v.m_position[0] = half(g_characterModelVertices[index++]);
v.m_position[1] = half(g_characterModelVertices[index++]);
v.m_position[2] = half(g_characterModelVertices[index++]);
v.m_normal[0] = half(g_characterModelVertices[index++]);
v.m_normal[1] = half(g_characterModelVertices[index++]);
v.m_normal[2] = half(g_characterModelVertices[index++]);
v.m_weights[0] = half(g_characterModelVertices[index++]);
v.m_weights[1] = half(g_characterModelVertices[index++]);
v.m_weights[2] = half(g_characterModelVertices[index++]);
v.m_weights[3] = half(g_characterModelVertices[index++]);
}
g_convertedToSkinnedVertex = true;
}
// Stick the half float data into the mesh
m_mesh.update(reinterpret_cast<const SkinnedVertex*>(g_characterModelVertices), vertexCount, g_characterModelIndices, indexCount);
//
// Initialize the shaders
//
m_skinningProgram = NvGLSLProgram::createFromFiles("shaders/skinning.vert", "shaders/simple.frag");
// Get the locations of the uniforms
m_ModelViewProjectionLocation = m_skinningProgram->getUniformLocation("ModelViewProjection");
m_BonesLocation = m_skinningProgram->getUniformLocation("Bones");
m_RenderModeLocation = m_skinningProgram->getUniformLocation("RenderMode");
m_LightDir0Location = m_skinningProgram->getUniformLocation("LightDir0");
m_LightDir1Location = m_skinningProgram->getUniformLocation("LightDir1");
// Get the locations of the attributes
m_iPositionLocation = m_skinningProgram->getAttribLocation("iPosition");
m_iNormalLocation = m_skinningProgram->getAttribLocation("iNormal");
m_iWeightsLocation = m_skinningProgram->getAttribLocation("iWeights");
// Initialize some view parameters
m_transformer->setRotationVec(nv::vec3f(0.0f, NV_PI*0.25f, 0.0f));
m_transformer->setTranslationVec(nv::vec3f(0.0f, 0.0f, -25.0f));
m_transformer->setMaxTranslationVel(50.0f); // seems to work decently.
CHECK_GL_ERROR();
}
int OpenGLView::regenerate() {
int returnCode;
EGLBoolean status;
EGLint interval = 1;
OpenGLView::m_renderMutex.lock();
status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_WIDTH, &m_surface_width);
if (status != EGL_TRUE) {
perror("query surface width");
return EXIT_FAILURE;
}
status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_HEIGHT, &m_surface_height);
if (status != EGL_TRUE) {
perror("query surface height");
return EXIT_FAILURE;
}
/*
rc = screen_get_window_property_iv(m_screen_win, SCREEN_PROPERTY_ROTATION, &rotation);
if (rc) {
perror("screen_set_window_property_iv");
return EXIT_FAILURE;
}
rc = screen_get_window_property_iv(m_screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc) {
perror("screen_set_window_property_iv");
return EXIT_FAILURE;
}
switch (angle - rotation) {
case -270:
case -90:
case 90:
case 270:
temp = size[0];
size[0] = size[1];
size[1] = temp;
skip = 0;
break;
}
*/
status = eglMakeCurrent(m_egl_disp, NULL, NULL, NULL);
if (status != EGL_TRUE) {
OpenGLThread::eglPrintError("eglMakeCurrent");
return EXIT_FAILURE;
}
status = eglDestroySurface(m_egl_disp, m_egl_surf);
if (status != EGL_TRUE) {
OpenGLThread::eglPrintError("eglMakeCurrent");
return EXIT_FAILURE;
}
returnCode = setWindowPosition(m_x, m_y);
if (returnCode) {
perror("window position");
return EXIT_FAILURE;
}
returnCode = setWindowSize(m_width, m_height);
if (returnCode) {
perror("window size");
return EXIT_FAILURE;
}
/*
setWindowAngle(m_angle);
if (returnCode) {
perror("window angle");
return EXIT_FAILURE;
}
*/
returnCode = setWindowSourceSize(m_width, m_height);
if (returnCode) {
perror("unable to set window source size");
return EXIT_FAILURE;
}
returnCode = setWindowBufferSize(m_width, m_height);
if (returnCode) {
perror("buffer size");
return EXIT_FAILURE;
}
m_egl_surf = eglCreateWindowSurface(m_egl_disp, m_egl_conf, m_screen_win, NULL);
if (m_egl_surf == EGL_NO_SURFACE) {
OpenGLThread::eglPrintError("eglCreateWindowSurface");
return EXIT_FAILURE;
}
getGLContext();
status = eglSwapInterval(m_egl_disp, interval);
if (status != EGL_TRUE) {
OpenGLThread::eglPrintError("eglSwapInterval");
return EXIT_FAILURE;
}
OpenGLView::m_renderMutex.unlock();
setAltered(false);
setStale(true);
return EXIT_SUCCESS;
}
int OpenGLView::initGL()
{
int numberDisplays;
int numberModes;
int returnCode;
EGLBoolean status;
int type;
EGLint attributes[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
EGLint attrib_list[]= { EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
EGL_NONE};
// try this first as it will fail if an HDMI display is not attached
if (m_api == GL_ES_2) {
m_egl_ctx = eglCreateContext(m_egl_disp, m_egl_conf, EGL_NO_CONTEXT, attributes);
} else {
m_egl_ctx = eglCreateContext(m_egl_disp, m_egl_conf, EGL_NO_CONTEXT, NULL);
}
if (m_egl_ctx == EGL_NO_CONTEXT) {
perror("eglCreateContext");
return EXIT_FAILURE;
}
screen_get_context_property_iv(m_screen_ctx, SCREEN_PROPERTY_DISPLAY_COUNT, &numberDisplays);
m_screen_dpy = (screen_display_t *)calloc(numberDisplays, sizeof(screen_display_t));
screen_get_context_property_pv(m_screen_ctx, SCREEN_PROPERTY_DISPLAYS, (void **)m_screen_dpy);
for (int index = 0; index < numberDisplays; index++) {
int displayID;
returnCode = screen_get_display_property_iv(m_screen_dpy[index], SCREEN_PROPERTY_ID, (int *)&displayID);
if (returnCode) {
perror("display ID");
return EXIT_FAILURE;
} else {
if (displayID == m_display) {
screen_get_display_property_iv(m_screen_dpy[index], SCREEN_PROPERTY_TYPE, &type);
if (type == SCREEN_DISPLAY_TYPE_HDMI) {
returnCode = screen_create_window(&m_screen_win, m_screen_ctx);
if (returnCode) {
perror("screen_create_window");
return EXIT_FAILURE;
}
} else {
returnCode = screen_create_window_type(&m_screen_win, m_screen_ctx, SCREEN_CHILD_WINDOW);
if (returnCode) {
perror("screen_create_window (child window)");
return EXIT_FAILURE;
}
}
if (type == SCREEN_DISPLAY_TYPE_HDMI) {
returnCode = screen_set_window_property_pv(m_screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&(m_screen_dpy[index]));
if (returnCode) {
perror("window display");
return EXIT_FAILURE;
}
}
}
}
}
qDebug() << "OpenGLView::initialize: "<< m_screen_ctx << ":" << m_egl_disp << ":" << m_egl_conf << ":" << m_egl_ctx << ":" << m_screen_win;
int format = SCREEN_FORMAT_RGBA8888;
returnCode = screen_set_window_property_iv(m_screen_win, SCREEN_PROPERTY_FORMAT, &format);
if (returnCode) {
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
return EXIT_FAILURE;
}
if (m_transparency > 0) {
returnCode = setWindowTransparency(m_transparency);
if (returnCode) {
perror("transparency");
return EXIT_FAILURE;
}
}
returnCode = screen_get_window_property_pv(m_screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&m_screen_disp);
if (returnCode) {
perror("screen_get_window_property_pv");
return EXIT_FAILURE;
}
int angle = atoi(getenv("ORIENTATION"));
screen_get_display_property_iv(m_screen_disp, SCREEN_PROPERTY_MODE_COUNT, &numberModes);
m_screen_modes = (screen_display_mode_t *)calloc(numberModes, sizeof(screen_display_mode_t));
returnCode = screen_get_display_property_pv(m_screen_disp, SCREEN_PROPERTY_MODE, (void**)m_screen_modes);
if (returnCode) {
perror("screen modes");
return EXIT_FAILURE;
}
int dpi = calculateDPI();
if (dpi == EXIT_FAILURE) {
fprintf(stderr, "Unable to calculate dpi\n");
return EXIT_FAILURE;
}
returnCode = setWindowPosition(m_x, m_y);
if (returnCode) {
perror("window position");
return EXIT_FAILURE;
}
returnCode = setWindowSize(m_width, m_height);
if (returnCode) {
perror("window size");
return EXIT_FAILURE;
}
returnCode = setWindowZ(m_z);
if (returnCode) {
perror("z order");
return EXIT_FAILURE;
}
returnCode = setWindowBufferSize(m_width, m_height);
if (returnCode) {
perror("buffer size");
return EXIT_FAILURE;
}
returnCode = setWindowAngle(m_angle);
if (returnCode) {
perror("angle");
return EXIT_FAILURE;
}
returnCode = screen_create_window_buffers(m_screen_win, m_nbuffers);
if (returnCode) {
perror("screen_create_window_buffers");
return EXIT_FAILURE;
}
if (m_api == GL_ES_1) {
m_usage = SCREEN_USAGE_OPENGL_ES1 | SCREEN_USAGE_ROTATION;
} else if (m_api == GL_ES_2) {
attrib_list[9] = EGL_OPENGL_ES2_BIT;
m_usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION;
} else if (m_api == VG) {
attrib_list[9] = EGL_OPENVG_BIT;
m_usage = SCREEN_USAGE_OPENVG | SCREEN_USAGE_ROTATION;
} else {
fprintf(stderr, "invalid api setting\n");
return EXIT_FAILURE;
}
returnCode = setWindowUsage(m_usage);
if (returnCode) {
perror("screen_set_window_property_iv(window usage)");
return EXIT_FAILURE;
}
qDebug() << "OpenGLView::initGL:eglCreateContext "<< m_egl_ctx;
m_egl_surf = eglCreateWindowSurface(m_egl_disp, m_egl_conf, m_screen_win, NULL);
if (m_egl_surf == EGL_NO_SURFACE) {
OpenGLThread::eglPrintError("eglCreateWindowSurface");
return EXIT_FAILURE;
}
getGLContext();
EGLint interval = 1;
status = eglSwapInterval(m_egl_disp, interval);
if (status != EGL_TRUE) {
OpenGLThread::eglPrintError("eglSwapInterval");
return EXIT_FAILURE;
}
status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_WIDTH, &m_surface_width);
if (status != EGL_TRUE) {
perror("query surface width");
return EXIT_FAILURE;
}
status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_HEIGHT, &m_surface_height);
if (status != EGL_TRUE) {
perror("query surface height");
return EXIT_FAILURE;
}
returnCode = joinWindowGroup(m_group);
if (returnCode) {
perror("window group");
return EXIT_FAILURE;
}
returnCode = setScreenWindowID(m_id);
if (returnCode) {
perror("window ID");
return EXIT_FAILURE;
}
qDebug() << "OpenGLView::initGL: "<< angle << ":" << numberModes << ":" << m_screen_modes[0].width << ":" << m_screen_modes[0].height << ":" << m_egl_disp << ":" << dpi;
setInitialized(true);
return EXIT_SUCCESS;
}
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 MotionBlur::initRendering(void) {
// This sample requires at least OpenGL ES 2.0
if (!requireMinAPIVersion(NvGLAPIVersionES2()))
return;
cleanRendering();
NvAssetLoaderAddSearchPath("es2-aurora/MotionBlur");
if (getGLContext()->getConfiguration().apiVer.api == NvGLAPI::GL) {
NvGLSLProgram::setGlobalShaderHeader("#version 130\n");
}
else {
NvGLSLProgram::setGlobalShaderHeader("#version 300 es\n");
}
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 = NvModelGL::CreateFromObj(
(uint8_t *)modelData, -1.0f, true, false);
NvAssetLoaderFree(modelData);
modelData = NvAssetLoaderRead("models/fan.obj", length);
mSailsModel = NvModelGL::CreateFromObj(
(uint8_t *)modelData, -1.0f, true, false);
NvAssetLoaderFree(modelData);
// Load some scene textures
mHouseTexID =
NvImageGL::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 = 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);
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();
NvGLSLProgram::setGlobalShaderHeader(NULL);
}
void GameFrameworkAndroid::surfaceCreated()
{
getGLContext().invalidateAll();
}
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();
}
