//-----------------------------------------------------------------------------
void GLESFrameBufferObject::detachDepthBuffer()
{
glBindFramebufferOES(GL_FRAMEBUFFER_OES, mMultisampleFB ? mMultisampleFB : mFB );
glFramebufferRenderbufferOES( GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, 0 );
glFramebufferRenderbufferOES( GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES,
GL_RENDERBUFFER_OES, 0 );
}
void OpenGLES1RenderManager::_generateOpenglBuffers()
{
#ifdef AURORA_IOS
// Create & bind the color buffer so that the caller can allocate its space.
glGenRenderbuffersOES(1, &m_colorRenderbuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_colorRenderbuffer);
// Create the depth buffer.
glGenRenderbuffersOES(1, &m_depthRenderbuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_depthRenderbuffer);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES,GL_DEPTH_COMPONENT16_OES,_width,_height);
// Create the framebuffer object; attach the depth and color buffers.
glGenFramebuffersOES(1, &m_framebuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, m_framebuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES,
GL_COLOR_ATTACHMENT0_OES,
GL_RENDERBUFFER_OES,
m_colorRenderbuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES,
GL_DEPTH_ATTACHMENT_OES,
GL_RENDERBUFFER_OES,
m_depthRenderbuffer);
// Bind the color buffer for rendering.
glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_colorRenderbuffer);
#endif
}
void Screen::CreateHardwareSurfaces()
{
glGenFramebuffersOES(1, &frameBuffer);
glGenRenderbuffersOES(1, &renderBuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, frameBuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, renderBuffer);
iphPrepareGLContext();
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, renderBuffer);
glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES, GL_RENDERBUFFER_WIDTH_OES, &iWidth);
glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES, GL_RENDERBUFFER_HEIGHT_OES, &iHeight);
#if SEED_ENABLE_DEPTH_TEST
glGenRenderbuffersOES(1, &depthRenderbuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, depthRenderbuffer);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES, iWidth, iHeight);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, depthRenderbuffer);
#endif // SEED_ENABLE_DEPTH_TEST
if (iMode == LANDSCAPE || iMode == LANDSCAPE_GOOFY)
{
this->iModeWidth = this->iHeight;
this->iModeHeight = this->iWidth;
}
else
{
this->iModeWidth = this->iHeight;
this->iModeHeight = this->iWidth;
}
}
/** Try a certain packed depth/stencil format, and return the status.
@returns true if this combo is supported
false if this combo is not supported
*/
bool GLESFBOManager::_tryPackedFormat(GLenum packedFormat)
{
GLuint packedRB;
/// Generate renderbuffer
glGenRenderbuffersOES(1, &packedRB);
/// Bind it to FBO
glBindRenderbufferOES(GL_RENDERBUFFER_OES, packedRB);
/// Allocate storage for buffer
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, packedFormat, PROBE_SIZE, PROBE_SIZE);
/// Attach depth
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES,
GL_RENDERBUFFER_OES, packedRB);
/// Attach stencil
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES,
GL_RENDERBUFFER_OES, packedRB);
GLuint status = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
/// Detach and destroy
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, 0);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES, GL_RENDERBUFFER_OES, 0);
glDeleteRenderbuffersOES(1, &packedRB);
return status == GL_FRAMEBUFFER_COMPLETE_OES;
}
void GLESFrameBufferObject::attachDepthBuffer( DepthBuffer *depthBuffer )
{
GLESDepthBuffer *glDepthBuffer = static_cast<GLESDepthBuffer*>(depthBuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, mMultisampleFB ? mMultisampleFB : mFB );
if( glDepthBuffer )
{
GLESRenderBuffer *depthBuf = glDepthBuffer->getDepthBuffer();
GLESRenderBuffer *stencilBuf = glDepthBuffer->getStencilBuffer();
//Attach depth buffer, if it has one.
if( depthBuf )
depthBuf->bindToFramebuffer( GL_DEPTH_ATTACHMENT_OES, 0 );
//Attach stencil buffer, if it has one.
if( stencilBuf )
stencilBuf->bindToFramebuffer( GL_STENCIL_ATTACHMENT_OES, 0 );
}
else
{
glFramebufferRenderbufferOES( GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES,
GL_RENDERBUFFER_OES, 0);
glFramebufferRenderbufferOES( GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES,
GL_RENDERBUFFER_OES, 0);
}
}
/** Try a certain FBO format, and return the status. Also sets mDepthRB and mStencilRB.
@returns true if this combo is supported
false if this combo is not supported
*/
GLuint GLESFBOManager::_tryFormat(GLenum depthFormat, GLenum stencilFormat)
{
GLuint status, depthRB = 0, stencilRB = 0;
if(depthFormat != GL_NONE)
{
/// Generate depth renderbuffer
glGenRenderbuffersOES(1, &depthRB);
/// Bind it to FBO
glBindRenderbufferOES(GL_RENDERBUFFER_OES, depthRB);
/// Allocate storage for depth buffer
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, depthFormat,
PROBE_SIZE, PROBE_SIZE);
/// Attach depth
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES,
GL_RENDERBUFFER_OES, depthRB);
}
// Stencil buffers aren't available on iPhone
if(stencilFormat != GL_NONE)
{
/// Generate stencil renderbuffer
glGenRenderbuffersOES(1, &stencilRB);
/// Bind it to FBO
glBindRenderbufferOES(GL_RENDERBUFFER_OES, stencilRB);
/// Allocate storage for stencil buffer
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, stencilFormat,
PROBE_SIZE, PROBE_SIZE);
/// Attach stencil
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES,
GL_RENDERBUFFER_OES, stencilRB);
}
status = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
/// If status is negative, clean up
// Detach and destroy
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, 0);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES, GL_RENDERBUFFER_OES, 0);
if (depthRB)
glDeleteRenderbuffersOES(1, &depthRB);
if (stencilRB)
glDeleteRenderbuffersOES(1, &stencilRB);
return status == GL_FRAMEBUFFER_COMPLETE_OES;
}
void CreateSurfaceMultisampleBuffersGLES(EAGLSurfaceDesc* surface)
{
UNITY_DBG_LOG ("CreateSurfaceMultisampleBuffers: samples=%i\n", surface->msaaSamples);
GLES_CHK( glBindRenderbufferOES(GL_RENDERBUFFER_OES, surface->renderbuffer) );
UNITY_DBG_LOG ("glBindFramebufferOES(GL_FRAMEBUFFER_OES, %d) :: AppCtrl\n", surface->framebuffer);
GLES_CHK( glBindFramebufferOES(GL_FRAMEBUFFER_OES, surface->framebuffer) );
gDefaultFBO = surface->framebuffer;
DestroySurfaceMultisampleBuffersGLES(surface);
GLES_CHK( glBindRenderbufferOES(GL_RENDERBUFFER_OES, surface->renderbuffer) );
UNITY_DBG_LOG ("glBindFramebufferOES(GL_FRAMEBUFFER_OES, %d) :: AppCtrl\n", surface->framebuffer);
GLES_CHK( glBindFramebufferOES(GL_FRAMEBUFFER_OES, surface->framebuffer) );
#if GL_APPLE_framebuffer_multisample
if(surface->msaaSamples > 1)
{
GLES_CHK( glGenRenderbuffersOES(1, &surface->msaaRenderbuffer) );
GLES_CHK( glBindRenderbufferOES(GL_RENDERBUFFER_OES, surface->msaaRenderbuffer) );
GLES_CHK( glGenFramebuffersOES(1, &surface->msaaFramebuffer) );
UNITY_DBG_LOG ("glBindFramebufferOES(GL_FRAMEBUFFER_OES, %d) :: AppCtrl\n", surface->msaaFramebuffer);
GLES_CHK( glBindFramebufferOES(GL_FRAMEBUFFER_OES, surface->msaaFramebuffer) );
gDefaultFBO = surface->msaaFramebuffer;
GLES_CHK( glRenderbufferStorageMultisampleAPPLE(GL_RENDERBUFFER_OES, surface->msaaSamples, surface->format, surface->w, surface->h) );
GLES_CHK( glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, surface->msaaRenderbuffer) );
if(surface->depthFormat)
{
GLES_CHK( glGenRenderbuffersOES(1, &surface->msaaDepthbuffer) );
GLES_CHK( glBindRenderbufferOES(GL_RENDERBUFFER_OES, surface->msaaDepthbuffer) );
GLES_CHK( glRenderbufferStorageMultisampleAPPLE(GL_RENDERBUFFER_OES, surface->msaaSamples, GL_DEPTH_COMPONENT16_OES, surface->w, surface->h) );
GLES_CHK( glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, surface->msaaDepthbuffer) );
}
}
else
#endif
{
if(surface->depthFormat)
{
GLES_CHK( glGenRenderbuffersOES(1, &surface->depthbuffer) );
GLES_CHK( glBindRenderbufferOES(GL_RENDERBUFFER_OES, surface->depthbuffer) );
GLES_CHK( glRenderbufferStorageOES(GL_RENDERBUFFER_OES, surface->depthFormat, surface->w, surface->h) );
UNITY_DBG_LOG ("glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, %d) :: AppCtrl\n", surface->depthbuffer);
GLES_CHK( glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, surface->depthbuffer) );
}
}
}
inline void VL_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
if (glFramebufferRenderbufferOES)
glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
else
VL_TRAP();
}
//-----------------------------------------------------------------------------
void GLESRenderBuffer::bindToFramebuffer(GLenum attachment, size_t zoffset)
{
assert(zoffset < mDepth);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, attachment,
GL_RENDERBUFFER_OES, mRenderbufferID);
GL_CHECK_ERROR;
}
void CreateSurfaceGLES(EAGLSurfaceDesc* surface)
{
GLuint oldRenderbuffer;
GLES_CHK( glGetIntegerv(GL_RENDERBUFFER_BINDING_OES, (GLint *) &oldRenderbuffer) );
DestroySurfaceGLES(surface);
InitEAGLLayer(surface->eaglLayer, surface->use32bitColor);
GLES_CHK( glGenRenderbuffersOES(1, &surface->renderbuffer) );
GLES_CHK( glBindRenderbufferOES(GL_RENDERBUFFER_OES, surface->renderbuffer) );
if( !AllocateRenderBufferStorageFromEAGLLayer(surface->eaglLayer) )
{
GLES_CHK( glDeleteRenderbuffersOES(1, &surface->renderbuffer) );
GLES_CHK( glBindRenderbufferOES(GL_RENDERBUFFER_BINDING_OES, oldRenderbuffer) );
printf_console("FAILED allocating render buffer storage from gles context\n");
return;
}
GLES_CHK( glGenFramebuffersOES(1, &surface->framebuffer) );
UNITY_DBG_LOG ("glBindFramebufferOES(GL_FRAMEBUFFER_OES, %d) :: AppCtrl\n", surface->framebuffer);
GLES_CHK( glBindFramebufferOES(GL_FRAMEBUFFER_OES, surface->framebuffer) );
gDefaultFBO = surface->framebuffer;
UNITY_DBG_LOG ("glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, %d) :: AppCtrl\n", surface->renderbuffer);
GLES_CHK( glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, surface->renderbuffer) );
CreateSurfaceMultisampleBuffersGLES(surface);
}
void GLES11RenderEngine::bindImageAsFramebuffer(EGLImageKHR image,
uint32_t* texName, uint32_t* fbName, uint32_t* status,
bool useReadPixels, int reqWidth, int reqHeight) {
GLuint tname, name;
if (!useReadPixels) {
// turn our EGLImage into a texture
glGenTextures(1, &tname);
glBindTexture(GL_TEXTURE_2D, tname);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
// create a Framebuffer Object to render into
glGenFramebuffersOES(1, &name);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, name);
glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES,
GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, tname, 0);
} else {
// since we're going to use glReadPixels() anyways,
// use an intermediate renderbuffer instead
glGenRenderbuffersOES(1, &tname);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, tname);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_RGBA8_OES, reqWidth, reqHeight);
// create a FBO to render into
glGenFramebuffersOES(1, &name);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, name);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, tname);
}
*status = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
*texName = tname;
*fbName = name;
}
void RenderingEngine1::Initialize(int width, int height)
{
// Create the framebuffer object and attach the color buffer.
glGenFramebuffersOES(1, &m_framebuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, m_framebuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES,
GL_COLOR_ATTACHMENT0_OES,
GL_RENDERBUFFER_OES,
m_renderbuffer);
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
// Initialize the projection matrix.
const float maxX = 2;
const float maxY = 3;
glOrthof(-maxX, +maxX, -maxY, +maxY, -1, 1);
glMatrixMode(GL_MODELVIEW);
// Initialize the rotation animation state.
OnRotate(DeviceOrientationPortrait);
m_currentAngle = m_desiredAngle;
}
void RenderES1::setViewPort(int width, int height)
{
glGenRenderbuffersOES(1, &_render_buffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, _render_buffer);
//
glGenFramebuffersOES(1, &_frame_buffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, _frame_buffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, _render_buffer);
glViewport(0, 0, width, height);
}
extern "C" bool UnityResolveMSAA(GLuint destFBO, GLuint colorTex, GLuint colorBuf, GLuint depthTex, GLuint depthBuf)
{
#if GL_APPLE_framebuffer_multisample
if (_surface.msaaSamples > 0 && _supportsMSAA && destFBO!=_surface.msaaFramebuffer && destFBO!=_surface.framebuffer)
{
Profiler_StartMSAAResolve();
GLint oldFBO;
GLES_CHK( glGetIntegerv (GL_FRAMEBUFFER_BINDING_OES, &oldFBO) );
UNITY_DBG_LOG ("UnityResolveMSAA: samples=%i msaaFBO=%i destFBO=%i colorTex=%i colorRB=%i depthTex=%i depthRB=%i\n", _surface.msaaSamples, _surface.msaaFramebuffer, destFBO, colorTex, colorBuf, depthTex, depthBuf);
UNITY_DBG_LOG (" bind dest as DRAW FBO and textures/buffers into it\n");
GLES_CHK( glBindFramebufferOES (GL_DRAW_FRAMEBUFFER_APPLE, destFBO) );
if (colorTex)
GLES_CHK( glFramebufferTexture2DOES( GL_DRAW_FRAMEBUFFER_APPLE, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorTex, 0 ) );
else if (colorBuf)
GLES_CHK( glFramebufferRenderbufferOES (GL_DRAW_FRAMEBUFFER_APPLE, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorBuf) );
if (depthTex)
GLES_CHK( glFramebufferTexture2DOES( GL_DRAW_FRAMEBUFFER_APPLE, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthTex, 0 ) );
else if (depthBuf)
GLES_CHK( glFramebufferRenderbufferOES (GL_DRAW_FRAMEBUFFER_APPLE, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBuf) );
UNITY_DBG_LOG (" bind msaa as READ FBO\n");
GLES_CHK( glBindFramebufferOES(GL_READ_FRAMEBUFFER_APPLE, _surface.msaaFramebuffer) );
UNITY_DBG_LOG (" glResolveMultisampleFramebufferAPPLE ();\n");
GLES_CHK( glResolveMultisampleFramebufferAPPLE() );
GLES_CHK( glBindFramebufferOES (GL_FRAMEBUFFER_OES, oldFBO) );
Profiler_EndMSAAResolve();
return true;
}
#endif
return false;
}
void RenderingEngine1::initialize(int width, int height){
glGenFramebuffersOES(1, &frameBuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, frameBuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES,
GL_COLOR_ATTACHMENT0_OES,
GL_RENDERBUFFER_OES,
renderBuffer);
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
const float maxX = 2;
const float maxY = 3;
glOrthof(-maxX, +maxX, -maxY, +maxY, -1, 1);
glMatrixMode(GL_MODELVIEW);
}
void EJCanvasContext::createStencilBufferOnce()
{
if( stencilBuffer ) { return; }
#ifdef _WINDOWS
glGenRenderbuffersEXT(1, &stencilBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, stencilBuffer);
if( msaaEnabled ) {
glRenderbufferStorageMultisample(GL_RENDERBUFFER_EXT, msaaSamples, GL_DEPTH24_STENCIL8, bufferWidth, bufferHeight);
}
else {
glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8, bufferWidth, bufferHeight);
}
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER_EXT, stencilBuffer);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, stencilBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, msaaEnabled ? msaaRenderBuffer : viewRenderBuffer );
#else
glGenRenderbuffersOES(1, &stencilBuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, stencilBuffer);
if( msaaEnabled ) {
//glRenderbufferStorageMultisampleAPPLE(GL_RENDERBUFFER, msaaSamples, GL_DEPTH24_STENCIL8_OES, bufferWidth, bufferHeight);
}
else {
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH24_STENCIL8_OES, bufferWidth, bufferHeight);
}
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, stencilBuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES, GL_RENDERBUFFER_OES, stencilBuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, msaaEnabled ? msaaRenderBuffer : viewRenderBuffer );
#endif
glClear(GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void sgTexture::makeRendertarget()
{
if(textype != GL_TEXTURE_2D || fbo != -1)
return;
if(sgRenderer::oglversion > 1)
{
#if defined __IOS__
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glBindTexture(textype, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texid, 0);
glClear(GL_COLOR_BUFFER_BIT);
glGenRenderbuffers(1, &fbo_depth);
glBindRenderbuffer(GL_RENDERBUFFER, fbo_depth);
// glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, width, height);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fbo_depth);
#else
glGenFramebuffersEXT(1, &fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);
glBindTexture(textype, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texid, 0);
glClear(GL_COLOR_BUFFER_BIT);
glGenRenderbuffersEXT(1, &fbo_depth);
glBindRenderbufferEXT(GL_RENDERBUFFER, fbo_depth);
// glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, width, height);
glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fbo_depth);
#endif
}else
{
#if defined __IOS__
glGenFramebuffersOES(1, &fbo);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, fbo);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, texid, 0);
glGenRenderbuffersOES(1, &fbo_depth);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, fbo_depth);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES, width, height);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, fbo_depth);
#endif
}
}
void RenderingEngine1::Initialize(int width, int height)
{
glGenFramebuffersOES(1, &_frameBuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, _frameBuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, _renderBuffer);
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
const float maxX = 2;
const float maxY = 3;
glOrthof(-maxX, +maxX, -maxY, +maxY, -1, 1);
glMatrixMode(GL_MODELVIEW);
OnRotate(DeviceOrientationPortrait);
_currentAngle = _desiredAngle;
}
OpenGLRTTexture::OpenGLRTTexture(unsigned int _texture, int width, int height) :
mTextureID(_texture),
mWidth(width),
mHeight(height),
mFBOID(0),
mRBOID(0)
{
int miplevel = 0;
glBindTexture(GL_TEXTURE_2D, mTextureID);
//glGetTexLevelParameteriv(GL_TEXTURE_2D, miplevel, GL_TEXTURE_WIDTH, &mWidth); // Unsupported by OpenGL ES, using param
//glGetTexLevelParameteriv(GL_TEXTURE_2D, miplevel, GL_TEXTURE_HEIGHT, &mHeight); // Unsupported by OpenGL ES, using param
glBindTexture(GL_TEXTURE_2D, 0);
mRenderTargetInfo.maximumDepth = 1.0f;
mRenderTargetInfo.hOffset = 0;
mRenderTargetInfo.vOffset = 0;
mRenderTargetInfo.aspectCoef = float(mHeight) / float(mWidth);
mRenderTargetInfo.pixScaleX = 1.0f / float(mWidth);
mRenderTargetInfo.pixScaleY = 1.0f / float(mHeight);
// create a framebuffer object, you need to delete them when program exits.
glGenFramebuffersOES(1, &mFBOID);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, mFBOID);
// create a renderbuffer object to store depth info
// NOTE: A depth renderable image should be attached the FBO for depth test.
// If we don't attach a depth renderable image to the FBO, then
// the rendering output will be corrupted because of missing depth test.
// If you also need stencil test for your rendering, then you must
// attach additional image to the stencil attachement point, too.
glGenRenderbuffersOES(1, &mRBOID);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, mRBOID);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES, mWidth, mHeight);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, 0);
// attach a texture to FBO color attachement point
glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, mTextureID, 0);
// attach a renderbuffer to depth attachment point
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, mRBOID);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
}
FBO *createFBO(s32 width, s32 height, bool hd) {
// save current FBO
FBO *oldFBO = getFBOUsed();
GLuint framebuffer;
GLuint depthRenderbuffer;
width = width;
height = height;
s32 texturePtrId = createTexture(0, 0);
setTexture(texturePtrId, width, height, 3, NULL);
Texture *tex = getTexture(texturePtrId);
// create depth renderbuffer
glGenRenderbuffersOES(1, &depthRenderbuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, depthRenderbuffer);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES, width, height);
// bind framebuffer & attach texture
glGenFramebuffersOES(1, &framebuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, framebuffer);
glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, tex->mTextureId, 0);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, depthRenderbuffer);
// check binding
if (glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES) != GL_FRAMEBUFFER_COMPLETE_OES) {
logError(TAG, "CRITICAL ERROR: FBO no complete");
return 0;
}
// save info into structure
FBO *fbo = (FBO *)malloc(sizeof(FBO));
fbo->mFBO = framebuffer;
fbo->mWidth = width;
fbo->mHeight = height;
fbo->mTexturePtrId = texturePtrId;
fbo->mDepthRenderBuffer = depthRenderbuffer;
// restore FBO
useFBO(oldFBO);
return fbo;
}
void EJCanvasContext::create()
{
#ifdef _WINDOWS
if( msaaEnabled ) {
glGenFramebuffersEXT(1, &msaaFrameBuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, msaaFrameBuffer);
glGenRenderbuffersEXT(1, &msaaRenderBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, msaaRenderBuffer);
//glRenderbufferStorageMultisampleIMG(GL_RENDERBUFFER, msaaSamples, GL_RGBA8, bufferWidth, bufferHeight);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER_EXT, msaaRenderBuffer);
}
glGenFramebuffersEXT(1, &viewFrameBuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, viewFrameBuffer);
glGenRenderbuffersEXT(1, &viewRenderBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, viewRenderBuffer);
#else
if( msaaEnabled ) {
glGenFramebuffersOES(1, &msaaFrameBuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, msaaFrameBuffer);
glGenRenderbuffersOES(1, &msaaRenderBuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, msaaRenderBuffer);
//glRenderbufferStorageMultisampleIMG(GL_RENDERBUFFER_OES, msaaSamples, GL_RGBA8_OES, bufferWidth, bufferHeight);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, msaaRenderBuffer);
}
glGenFramebuffersOES(1, &viewFrameBuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, viewFrameBuffer);
glGenRenderbuffersOES(1, &viewRenderBuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, viewRenderBuffer);
#endif
}
virtual GLenum createFBO(GLuint& framebuffer, GLuint& depthbuffer, GLuint& img, int width, int height)
{
// get currently bound fbo to reset to it later
GLint current_fbo;
glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, ¤t_fbo);
// generate depth buffer
glGenRenderbuffersOES(1, &depthbuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, depthbuffer);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES, width, height);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, 0);
// generate texture save target
glGenTextures(1, &img);
glBindTexture(GL_TEXTURE_2D, img);
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_RGBA8_OES, width, height,
0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
// create framebuffer
glGenFramebuffersOES(1, &framebuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, framebuffer);
glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES,
GL_TEXTURE_2D, img, 0);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES,
GL_RENDERBUFFER_OES, depthbuffer);
GLenum status = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
// unbind framebuffer
glBindFramebufferOES(GL_FRAMEBUFFER_OES, (GLuint)current_fbo);
return status;
}
void RenderingEngine::Initialize(const vector<ISurface*>& surfaces)
{
vector<ISurface*>::const_iterator surface;
for (surface = surfaces.begin(); surface != surfaces.end(); ++surface) {
// Create the VBO for the vertices.
vector<float> vertices;
unsigned char vertexFlags = VertexFlagsNormals | VertexFlagsTexCoords;
(*surface)->GenerateVertices(vertices, vertexFlags);
GLuint vertexBuffer;
glGenBuffers(1, &vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER,
vertices.size() * sizeof(vertices[0]),
&vertices[0],
GL_STATIC_DRAW);
// Create a new VBO for the indices if needed.
int indexCount = (*surface)->GetTriangleIndexCount();
GLuint indexBuffer;
if (!m_drawables.empty() && indexCount == m_drawables[0].IndexCount) {
indexBuffer = m_drawables[0].IndexBuffer;
} else {
vector<GLushort> indices(indexCount);
(*surface)->GenerateTriangleIndices(indices);
glGenBuffers(1, &indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
indexCount * sizeof(GLushort),
&indices[0],
GL_STATIC_DRAW);
}
Drawable drawable = { vertexBuffer, indexBuffer, indexCount};
m_drawables.push_back(drawable);
}
// Extract width and height from the color buffer.
int width, height;
glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,
GL_RENDERBUFFER_WIDTH_OES, &width);
glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,
GL_RENDERBUFFER_HEIGHT_OES, &height);
// Create a depth buffer that has the same size as the color buffer.
glGenRenderbuffersOES(1, &m_depthRenderbuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_depthRenderbuffer);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES,
width, height);
// Create the framebuffer object.
GLuint framebuffer;
glGenFramebuffersOES(1, &framebuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, framebuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES,
GL_RENDERBUFFER_OES, m_colorRenderbuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES,
GL_RENDERBUFFER_OES, m_depthRenderbuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_colorRenderbuffer);
void* pixels;
ivec2 size;
// Load the background texture.
glGenTextures(1, &m_backgroundTexture);
glBindTexture(GL_TEXTURE_2D, m_backgroundTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
m_resourceManager->LoadPngImage("Background");
pixels = m_resourceManager->GetImageData();
size = m_resourceManager->GetImageSize();
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.x, size.y, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels);
m_resourceManager->UnloadImage();
// Load the checkboard texture.
glGenTextures(1, &m_gridTexture);
glBindTexture(GL_TEXTURE_2D, m_gridTexture);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
m_resourceManager->LoadPngImage("Checkerboard");
pixels = m_resourceManager->GetImageData();
size = m_resourceManager->GetImageSize();
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, size.x, size.y, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixels);
m_resourceManager->UnloadImage();
// Set up various GL state.
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
// Set up the material properties.
vec4 specular(0.5f, 0.5f, 0.5f, 1);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular.Pointer());
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50.0f);
m_translation = mat4::Translate(0, 0, -7);
}
void RenderingEngine::Initialize(const vector<ISurface*>& surfaces)
{
vector<ISurface*>::const_iterator surface;
for (surface = surfaces.begin(); surface != surfaces.end(); ++surface) {
// Create the VBO for the vertices.
vector<float> vertices;
(*surface)->GenerateVertices(vertices, VertexFlagsNormals);
GLuint vertexBuffer;
glGenBuffers(1, &vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER,
vertices.size() * sizeof(vertices[0]),
&vertices[0],
GL_STATIC_DRAW);
// Create a new VBO for the indices if needed.
int indexCount = (*surface)->GetTriangleIndexCount();
GLuint indexBuffer;
if (!m_drawables.empty() && indexCount == m_drawables[0].IndexCount) {
indexBuffer = m_drawables[0].IndexBuffer;
} else {
vector<GLushort> indices(indexCount);
(*surface)->GenerateTriangleIndices(indices);
glGenBuffers(1, &indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
indexCount * sizeof(GLushort),
&indices[0],
GL_STATIC_DRAW);
}
Drawable drawable = { vertexBuffer, indexBuffer, indexCount};
m_drawables.push_back(drawable);
}
// Extract width and height from the color buffer.
int width, height;
glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,
GL_RENDERBUFFER_WIDTH_OES, &width);
glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,
GL_RENDERBUFFER_HEIGHT_OES, &height);
// Create a depth buffer that has the same size as the color buffer.
glGenRenderbuffersOES(1, &m_depthRenderbuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_depthRenderbuffer);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES,
width, height);
// Create the framebuffer object.
GLuint framebuffer;
glGenFramebuffersOES(1, &framebuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, framebuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES,
GL_RENDERBUFFER_OES, m_colorRenderbuffer);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES,
GL_RENDERBUFFER_OES, m_depthRenderbuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_colorRenderbuffer);
// Set up various GL state.
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
// Set up the material properties.
vec4 specular(0.5f, 0.5f, 0.5f, 1);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular.Pointer());
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50.0f);
m_translation = mat4::Translate(0, 0, -7);
}
void GLESFrameBufferObject::initialise()
{
// Release depth and stencil, if they were bound
mManager->releaseRenderBuffer(mDepth);
mManager->releaseRenderBuffer(mStencil);
mManager->releaseRenderBuffer(mMultisampleColourBuffer);
/// First buffer must be bound
if(!mColour[0].buffer)
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"Attachment 0 must have surface attached",
"GLESFrameBufferObject::initialise");
}
// If we're doing multisampling, then we need another FBO which contains a
// renderbuffer which is set up to multisample, and we'll blit it to the final
// FBO afterwards to perform the multisample resolve. In that case, the
// mMultisampleFB is bound during rendering and is the one with a depth/stencil
/// Store basic stats
size_t width = mColour[0].buffer->getWidth();
size_t height = mColour[0].buffer->getHeight();
GLuint format = mColour[0].buffer->getGLFormat();
// Bind simple buffer to add colour attachments
glBindFramebufferOES(GL_FRAMEBUFFER_OES, mFB);
GL_CHECK_ERROR;
/// Bind all attachment points to frame buffer
for(size_t x=0; x<OGRE_MAX_MULTIPLE_RENDER_TARGETS; ++x)
{
if(mColour[x].buffer)
{
if(mColour[x].buffer->getWidth() != width || mColour[x].buffer->getHeight() != height)
{
StringStream ss;
ss << "Attachment " << x << " has incompatible size ";
ss << mColour[x].buffer->getWidth() << "x" << mColour[x].buffer->getHeight();
ss << ". It must be of the same as the size of surface 0, ";
ss << width << "x" << height;
ss << ".";
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, ss.str(), "GLESFrameBufferObject::initialise");
}
if(mColour[x].buffer->getGLFormat() != format)
{
StringStream ss;
ss << "Attachment " << x << " has incompatible format.";
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, ss.str(), "GLESFrameBufferObject::initialise");
}
mColour[x].buffer->bindToFramebuffer(GL_COLOR_ATTACHMENT0_OES+x, mColour[x].zoffset);
}
else
{
// Detach
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES+x,
GL_RENDERBUFFER_OES, 0);
GL_CHECK_ERROR;
}
}
// Now deal with depth / stencil
if (mMultisampleFB)
{
// Bind multisample buffer
glBindFramebufferOES(GL_FRAMEBUFFER_OES, mMultisampleFB);
GL_CHECK_ERROR;
// Create AA render buffer (colour)
// note, this can be shared too because we blit it to the final FBO
// right after the render is finished
mMultisampleColourBuffer = mManager->requestRenderBuffer(format, width, height, mNumSamples);
// Attach it, because we won't be attaching below and non-multisample has
// actually been attached to other FBO
mMultisampleColourBuffer.buffer->bindToFramebuffer(GL_COLOR_ATTACHMENT0_OES,
mMultisampleColourBuffer.zoffset);
// depth & stencil will be dealt with below
}
/// Depth buffer is not handled here anymore.
/// See GLESFrameBufferObject::attachDepthBuffer() & RenderSystem::setDepthBufferFor()
/// Do glDrawBuffer calls
GLenum bufs[OGRE_MAX_MULTIPLE_RENDER_TARGETS];
for(size_t x=0; x<OGRE_MAX_MULTIPLE_RENDER_TARGETS; ++x)
{
// Fill attached colour buffers
if(mColour[x].buffer)
{
bufs[x] = GL_COLOR_ATTACHMENT0_OES + x;
}
else
{
bufs[x] = GL_NONE;
}
}
/// Check status
GLuint status;
status = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
GL_CHECK_ERROR;
/// Bind main buffer
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
// The screen buffer is 1 on iOS
glBindFramebufferOES(GL_FRAMEBUFFER_OES, 1);
#else
glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
#endif
GL_CHECK_ERROR;
switch(status)
{
case GL_FRAMEBUFFER_COMPLETE_OES:
// All is good
break;
case GL_FRAMEBUFFER_UNSUPPORTED_OES:
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"All framebuffer formats with this texture internal format unsupported",
"GLESFrameBufferObject::initialise");
default:
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"Framebuffer incomplete or other FBO status error",
"GLESFrameBufferObject::initialise");
}
}
void GL11Renderer::Initialize( int width, int height )
{
//
// Buffer Setup...
//
// Create the depth buffer.
glGenRenderbuffersOES( 1, &m_depthRenderbuffer );
glBindRenderbufferOES( GL_RENDERBUFFER_OES, m_depthRenderbuffer );
glRenderbufferStorageOES( GL_RENDERBUFFER_OES,
GL_DEPTH_COMPONENT16_OES,
width,
height );
// Create the framebuffer object; attach the depth and color buffers.
glGenFramebuffersOES( 1, &m_framebuffer );
glBindFramebufferOES( GL_FRAMEBUFFER_OES, m_framebuffer );
glFramebufferRenderbufferOES( GL_FRAMEBUFFER_OES,
GL_COLOR_ATTACHMENT0_OES,
GL_RENDERBUFFER_OES,
m_colorRenderbuffer );
glFramebufferRenderbufferOES( GL_FRAMEBUFFER_OES,
GL_DEPTH_ATTACHMENT_OES,
GL_RENDERBUFFER_OES,
m_depthRenderbuffer );
// Bind the color buffer for rendering.
glBindRenderbufferOES( GL_RENDERBUFFER_OES, m_colorRenderbuffer );
//
// General Setup...
//
glEnable( GL_TEXTURE_2D );
glDisable( GL_LIGHTING );
//
// Point Sprites...
//
glEnable( GL_POINT_SPRITE_OES );
glTexEnvi( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE );
glTexEnvi( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_FALSE );
//glPointSize( 10.0f );
// This helps as a work around for order-dependency artifacts that can occur when sprites overlap.
glBlendFunc( GL_SRC_ALPHA, GL_ONE );
//
// Texture Setup...
//
glGenTextures( 1, &m_snowTextureId );
glBindTexture( GL_TEXTURE_2D, m_snowTextureId );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
TextureDescription desc = m_resourceLoader->LoadPngImage( "snow.png" );
GLvoid* pixels = m_resourceLoader->GetImageData();
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, desc.Width, desc.Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels );
m_resourceLoader->UnloadImage();
//
// VBO Setup for Snow Flakes...
//
for( int i = 0; i < MaxSnowFlakes; ++i )
{
m_pos[i][0] = RandomFloat( -ViewMaxX, ViewMaxX );
m_pos[i][1] = RandomFloat( -ViewMaxY, ViewMaxY );
m_vel[i][0] = RandomFloat( -0.004f, 0.004f ); // Flakes move side to side
m_vel[i][1] = RandomFloat( -0.01f, -0.008f ); // Flakes fall down
m_col[i][0] = 1.0f;
m_col[i][1] = 1.0f;
m_col[i][2] = 1.0f;
m_col[i][3] = 1.0f; //RandomFloat( 0.6f, 1.0f ); // It seems that Doodle Jump snow does not use alpha.
m_size[i] = RandomFloat( 3.0, 6.0f );
// It looks strange if the flakes all turn at the same time, so
// lets vary their turn times with a random negative value.
m_timeSinceLastTurn[i] = RandomFloat( -5.0, 0.0f );
}
// VBO for vertex positions.
glGenBuffers( 1, &m_vertexBufferId );
glBindBuffer( GL_ARRAY_BUFFER, m_vertexBufferId );
glBufferData( GL_ARRAY_BUFFER, sizeof(m_pos), m_pos, GL_DYNAMIC_DRAW );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
// TODO: Due to the possibility of cache misses, it might be a little faster to
// combine the colors and point sizes into an interleaved array, but it
// seems that this optimization makes less sense on newer CPUs.
// VBO for vertex colors.
glGenBuffers( 1, &m_colorBufferId );
glBindBuffer( GL_ARRAY_BUFFER, m_colorBufferId );
glBufferData( GL_ARRAY_BUFFER, sizeof(m_col), m_col, GL_STATIC_DRAW );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
// VBO for point sizes of point sprites.
glGenBuffers( 1, &m_pointSizeBufferId );
glBindBuffer( GL_ARRAY_BUFFER, m_pointSizeBufferId );
glBufferData( GL_ARRAY_BUFFER, sizeof(m_size), m_size, GL_STATIC_DRAW );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
//
// View Settings...
//
glViewport( 0, 0, width, height );
// Initialize the projection matrix to orthogrpahic and create
// a flat 2D game space that is 2 units wide and 3 units high.
glMatrixMode( GL_PROJECTION );
glOrthof( -ViewMaxX, +ViewMaxX, -ViewMaxY, +ViewMaxY, -1, 1 );
}
void RenderingEngine::Initialize()
{
// Create vertices for full-screen quad.
m_backgroundVertices.resize(4);
m_backgroundVertices[0].Position = vec3(-1, -1.5, 0);
m_backgroundVertices[0].TexCoord = vec2(0, 0);
m_backgroundVertices[1].Position = vec3(-1, 1.5, 0);
m_backgroundVertices[1].TexCoord = vec2(0, 1);
m_backgroundVertices[2].Position = vec3(1, -1.5, 0);
m_backgroundVertices[2].TexCoord = vec2(1, 0);
m_backgroundVertices[3].Position = vec3(1, 1.5, 0);
m_backgroundVertices[3].TexCoord = vec2(1, 1);
if (false) {
m_backgroundVertices[0].TexCoord *= 0.3;
m_backgroundVertices[1].TexCoord *= 0.3;
m_backgroundVertices[2].TexCoord *= 0.3;
m_backgroundVertices[3].TexCoord *= 0.3;
}
// Create the line-based stick figure.
size_t indexCount = sizeof(StickFigureIndices) / sizeof(GLushort);
size_t lineCount = indexCount / 2;
m_stickFigure.Indices = IndexList(StickFigureIndices, StickFigureIndices + indexCount);
glGenBuffers(1, &m_stickFigure.IndexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_stickFigure.IndexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
m_stickFigure.Indices.size() * sizeof(GLushort),
&m_stickFigure.Indices[0],
GL_STATIC_DRAW);
m_stickFigure.Vertices.resize(JointCount);
// Create the triangle-based stick figure.
GenerateTriangleIndices(lineCount, m_aaStickFigure.Indices);
glGenBuffers(1, &m_aaStickFigure.IndexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_aaStickFigure.IndexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
m_aaStickFigure.Indices.size() * sizeof(GLushort),
&m_aaStickFigure.Indices[0],
GL_STATIC_DRAW);
m_aaStickFigure.Vertices.resize(lineCount * 8);
GenerateTriangleTexCoords(m_aaStickFigure);
// Initialize the demo state.
m_demoState = DemoStateAaLines;
// Load up some textures.
m_textures.Tile = CreateTexture(Tile);
m_textures.Circle = CreateTexture(Circle);
m_textures.BlurryCircle = CreateTexture(BlurryCircle);
// Extract width and height from the color buffer.
ivec2 screenSize;
glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,
GL_RENDERBUFFER_WIDTH_OES, &screenSize.x);
glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,
GL_RENDERBUFFER_HEIGHT_OES, &screenSize.y);
// Create the on-screen FBO.
glGenFramebuffersOES(1, &m_framebuffers.Screen);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, m_framebuffers.Screen);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES,
GL_RENDERBUFFER_OES, m_renderbuffers.Screen);
// Set up various GL state.
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_TEXTURE_2D);
glViewport(0, 0, screenSize.x, screenSize.y);
glAlphaFunc(GL_LESS, 0.5);
// Set up the transforms.
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
const float NearPlane = 5, FarPlane = 100;
const float Scale = 0.0005;
glFrustumf(-Scale * screenSize.x / 2, Scale * screenSize.x / 2,
-Scale * screenSize.y / 2, Scale * screenSize.y / 2,
NearPlane, FarPlane);
glMatrixMode(GL_MODELVIEW);
}
status_t SurfaceFlinger::captureScreenImplLocked(DisplayID dpy,
sp<IMemoryHeap>* heap,
uint32_t* w, uint32_t* h, PixelFormat* f,
uint32_t sw, uint32_t sh)
{
LOGI("captureScreenImplLocked");
status_t result = PERMISSION_DENIED;
// only one display supported for now
if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT))
return BAD_VALUE;
if (!GLExtensions::getInstance().haveFramebufferObject())
return INVALID_OPERATION;
// get screen geometry
const DisplayHardware& hw(graphicPlane(dpy).displayHardware());
const uint32_t hw_w = hw.getWidth();
const uint32_t hw_h = hw.getHeight();
if ((sw > hw_w) || (sh > hw_h))
return BAD_VALUE;
sw = (!sw) ? hw_w : sw;
sh = (!sh) ? hw_h : sh;
const size_t size = sw * sh * 4;
// make sure to clear all GL error flags
while ( glGetError() != GL_NO_ERROR ) ;
// create a FBO
GLuint name, tname;
glGenRenderbuffersOES(1, &tname);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, tname);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_RGBA8_OES, sw, sh);
glGenFramebuffersOES(1, &name);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, name);
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES,
GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, tname);
GLenum status = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
if (status == GL_FRAMEBUFFER_COMPLETE_OES) {
// invert everything, b/c glReadPixel() below will invert the FB
glViewport(0, 0, sw, sh);
glScissor(0, 0, sw, sh);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrthof(0, hw_w, 0, hw_h, 0, 1);
glMatrixMode(GL_MODELVIEW);
// redraw the screen entirely...
glClearColor(0,0,0,1);
glClear(GL_COLOR_BUFFER_BIT);
const Vector< sp<LayerBase> >& layers(mVisibleLayersSortedByZ);
const size_t count = layers.size();
for (size_t i=0 ; i<count ; ++i) {
const sp<LayerBase>& layer(layers[i]);
layer->drawForSreenShot();
}
// XXX: this is needed on tegra
glScissor(0, 0, sw, sh);
// check for errors and return screen capture
if (glGetError() != GL_NO_ERROR) {
// error while rendering
result = INVALID_OPERATION;
} else {
// allocate shared memory large enough to hold the
// screen capture
sp<MemoryHeapBase> base(
new MemoryHeapBase(size, 0, "screen-capture") );
void* const ptr = base->getBase();
if (ptr) {
// capture the screen with glReadPixels()
glReadPixels(0, 0, sw, sh, GL_RGBA, GL_UNSIGNED_BYTE, ptr);
if (glGetError() == GL_NO_ERROR) {
*heap = base;
*w = sw;
*h = sh;
*f = PIXEL_FORMAT_RGBA_8888;
result = NO_ERROR;
}
} else {
result = NO_MEMORY;
}
}
glEnable(GL_SCISSOR_TEST);
glViewport(0, 0, hw_w, hw_h);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
} else {
result = BAD_VALUE;
}
// release FBO resources
glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
glDeleteRenderbuffersOES(1, &tname);
glDeleteFramebuffersOES(1, &name);
hw.compositionComplete();
return result;
}
//-----------------------------------------------------------------------------
// Very fast texture-to-texture blitter and hardware bi/trilinear scaling implementation using FBO
// Destination texture must be 2D
// Source texture must be 2D
// Supports compressed formats as both source and destination format, it will use the hardware DXT compressor
// if available.
// @author W.J. van der Laan
void GLESTextureBuffer::blitFromTexture(GLESTextureBuffer *src, const Image::Box &srcBox, const Image::Box &dstBox)
{
if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_FBO) == false)
{
// the following code depends on FBO support, it crashes if FBO is not supported.
// TODO - write PBUFFER version of this function or a version that doesn't require FBO
return; // for now - do nothing.
}
// std::cerr << "GLESTextureBuffer::blitFromTexture " <<
// src->mTextureID << ":" << srcBox.left << "," << srcBox.top << "," << srcBox.right << "," << srcBox.bottom << " " <<
// mTextureID << ":" << dstBox.left << "," << dstBox.top << "," << dstBox.right << "," << dstBox.bottom << std::endl;
// Store reference to FBO manager
GLESFBOManager *fboMan = static_cast<GLESFBOManager *>(GLESRTTManager::getSingletonPtr());
// Save and clear GL state for rendering
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
RenderSystem* rsys = Root::getSingleton().getRenderSystem();
rsys->_disableTextureUnitsFrom(0);
// Disable alpha, depth and scissor testing, disable blending,
// disable culling, disble lighting, disable fog and reset foreground
// colour.
glDisable(GL_ALPHA_TEST);
glDisable(GL_DEPTH_TEST);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
glDisable(GL_CULL_FACE);
glDisable(GL_LIGHTING);
glDisable(GL_FOG);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
GL_CHECK_ERROR;
// Save and reset matrices
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadIdentity();
GL_CHECK_ERROR;
// Set up source texture
glBindTexture(src->mTarget, src->mTextureID);
GL_CHECK_ERROR;
// Set filtering modes depending on the dimensions and source
if(srcBox.getWidth()==dstBox.getWidth() &&
srcBox.getHeight()==dstBox.getHeight() &&
srcBox.getDepth()==dstBox.getDepth())
{
// Dimensions match -- use nearest filtering (fastest and pixel correct)
glTexParameteri(src->mTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
GL_CHECK_ERROR;
glTexParameteri(src->mTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
GL_CHECK_ERROR;
}
else
{
// Dimensions don't match -- use bi or trilinear filtering depending on the
// source texture.
if(src->mUsage & TU_AUTOMIPMAP)
{
// Automatic mipmaps, we can safely use trilinear filter which
// brings greatly imporoved quality for minimisation.
glTexParameteri(src->mTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
GL_CHECK_ERROR;
glTexParameteri(src->mTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
GL_CHECK_ERROR;
}
else
{
// Manual mipmaps, stay safe with bilinear filtering so that no
// intermipmap leakage occurs.
glTexParameteri(src->mTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
GL_CHECK_ERROR;
glTexParameteri(src->mTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
GL_CHECK_ERROR;
}
}
// Clamp to edge (fastest)
glTexParameteri(src->mTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
GL_CHECK_ERROR;
glTexParameteri(src->mTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
GL_CHECK_ERROR;
// Store old binding so it can be restored later
GLint oldfb;
glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, &oldfb);
GL_CHECK_ERROR;
// Set up temporary FBO
glBindFramebufferOES(GL_FRAMEBUFFER_OES, fboMan->getTemporaryFBO());
GL_CHECK_ERROR;
GLuint tempTex = 0;
if(!fboMan->checkFormat(mFormat))
{
// If target format not directly supported, create intermediate texture
GLenum tempFormat = GLESPixelUtil::getClosestGLInternalFormat(fboMan->getSupportedAlternative(mFormat));
glGenTextures(1, &tempTex);
GL_CHECK_ERROR;
glBindTexture(GL_TEXTURE_2D, tempTex);
GL_CHECK_ERROR;
// Allocate temporary texture of the size of the destination area
glTexImage2D(GL_TEXTURE_2D, 0, tempFormat,
GLESPixelUtil::optionalPO2(dstBox.getWidth()), GLESPixelUtil::optionalPO2(dstBox.getHeight()),
0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
GL_CHECK_ERROR;
glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES,
GL_TEXTURE_2D, tempTex, 0);
GL_CHECK_ERROR;
// Set viewport to size of destination slice
glViewport(0, 0, dstBox.getWidth(), dstBox.getHeight());
GL_CHECK_ERROR;
}
else
{
// We are going to bind directly, so set viewport to size and position of destination slice
glViewport(dstBox.left, dstBox.top, dstBox.getWidth(), dstBox.getHeight());
GL_CHECK_ERROR;
}
// Process each destination slice
for(size_t slice=dstBox.front; slice<dstBox.back; ++slice)
{
if(!tempTex)
{
/// Bind directly
bindToFramebuffer(GL_COLOR_ATTACHMENT0_OES, slice);
}
if(tempTex)
{
// Copy temporary texture
glBindTexture(mTarget, mTextureID);
GL_CHECK_ERROR;
switch(mTarget)
{
case GL_TEXTURE_2D:
#if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
case GL_TEXTURE_CUBE_MAP_OES:
#endif
glCopyTexSubImage2D(mFaceTarget, mLevel,
dstBox.left, dstBox.top,
0, 0, dstBox.getWidth(), dstBox.getHeight());
GL_CHECK_ERROR;
break;
}
}
}
// Finish up
if(!tempTex)
{
// Generate mipmaps
if(mUsage & TU_AUTOMIPMAP)
{
glBindTexture(mTarget, mTextureID);
GL_CHECK_ERROR;
glGenerateMipmapOES(mTarget);
GL_CHECK_ERROR;
}
}
// Reset source texture to sane state
glBindTexture(src->mTarget, src->mTextureID);
GL_CHECK_ERROR;
// Detach texture from temporary framebuffer
glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES,
GL_RENDERBUFFER_OES, 0);
GL_CHECK_ERROR;
// Restore old framebuffer
glBindFramebufferOES(GL_FRAMEBUFFER_OES, oldfb);
GL_CHECK_ERROR;
// Restore matrix stacks and render state
glMatrixMode(GL_TEXTURE);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
GL_CHECK_ERROR;
glDeleteTextures(1, &tempTex);
GL_CHECK_ERROR;
}
void glFramebufferRenderbufferOESLogged(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
printf("glFramebufferRenderbufferOES(%s, %s, %s, %u)\n", GLEnumName(target), GLEnumName(attachment), GLEnumName(renderbuffertarget), renderbuffer);
glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
}
