void OGLRender::Initialize(void)
{
glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight);
OPENGL_CHECK_ERRORS;
COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
if( pcontext->IsExtensionSupported("GL_IBM_texture_mirrored_repeat") )
{
//OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT_IBM;
}
else if( pcontext->IsExtensionSupported("ARB_texture_mirrored_repeat") )
{
//OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT;
}
else
{
OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT;
}
// if( pcontext->IsExtensionSupported("GL_texture_border_clamp") || pcontext->IsExtensionSupported("GL_EXT_texture_edge_clamp") )
// {
m_bSupportClampToEdge = true;
OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP_TO_EDGE;
// }
// else
// {
// m_bSupportClampToEdge = false;
// OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP_TO_EDGE;
// }
}
bool COGLColorCombinerNvidia::Initialize(void)
{
m_bNVSupported = false;
if( COGLColorCombiner4::Initialize() )
{
m_bSupportMultiTexture = true;
COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
if( pcontext->IsExtensionSupported("GL_NV_texture_env_combine4") || pcontext->IsExtensionSupported("GL_NV_register_combiners") )
{
m_bNVSupported = true;
glEnable(GL_REGISTER_COMBINERS_NV);
return true;
}
else
{
DebugMessage(M64MSG_ERROR, "Your video card does not support Nvidia OpenGL extension combiner");
glDisable(GL_REGISTER_COMBINERS_NV);
return false;
}
}
glDisable(GL_REGISTER_COMBINERS_NV);
return false;
}
bool COGLColorCombiner4::Initialize(void)
{
m_bSupportModAdd_ATI = false;
m_bSupportModSub_ATI = false;
m_maxTexUnits = 1;
#ifndef USE_GLES
if( COGLColorCombiner::Initialize() )
{
COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
glGetIntegerv(GL_MAX_TEXTURE_UNITS,&m_maxTexUnits);
OPENGL_CHECK_ERRORS;
if( m_maxTexUnits > 8 ) m_maxTexUnits = 8;
TRACE0("Starting Ogl 1.4 multitexture combiner" );
TRACE1("m_maxTexUnits = %d", m_maxTexUnits);
if( pcontext->IsExtensionSupported("ATI_texture_env_combine3") )
{
m_bSupportModAdd_ATI = true;
m_bSupportModSub_ATI = true;
}
m_supportedStages = m_maxTexUnits;
return true;
}
return false;
#else
return true;
#endif
}
bool COGL_FragmentProgramCombiner::Initialize(void)
{
if( !COGLColorCombiner4::Initialize() )
return false;
COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
if( pcontext->IsExtensionSupported("GL_ARB_fragment_program") )
{
m_bFragmentProgramIsSupported = true;
}
return true;
}
bool COGLFragmentShaderCombiner::Initialize(void)
{
if( !COGLColorCombiner::Initialize() )
return false;
COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
if( pcontext->IsExtensionSupported("GL_ARB_fragment_shader") )
{
m_bShaderIsSupported = true;
}
return true;
}
void COGLTexture::EndUpdate(DrawInfo *di)
{
COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext); // we need this to check if the GL extension is avaible
glBindTexture(GL_TEXTURE_2D, m_dwTextureName);
OPENGL_CHECK_ERRORS;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
OPENGL_CHECK_ERRORS;
// mipmap support
if(options.mipmapping)
{
int m_maximumAnistropy = pcontext->getMaxAnisotropicFiltering(); //if getMaxAnisotropicFiltering() return more than 0, so aniso is supported and maxAnisotropicFiltering is set
// Set Anisotropic filtering (mipmapping have to be activated, aniso filtering is not effective without)
if( m_maximumAnistropy )
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, m_maximumAnistropy);
OPENGL_CHECK_ERRORS;
}
// Set Mipmap
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
OPENGL_CHECK_ERRORS;
#ifndef USE_GLES
// Tell to hardware to generate mipmap (himself) when glTexImage2D is called
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
#endif
OPENGL_CHECK_ERRORS;
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
OPENGL_CHECK_ERRORS;
}
// Copy the image data from main memory to video card texture memory
#ifndef USE_GLES
glTexImage2D(GL_TEXTURE_2D, 0, m_glFmt, m_dwCreatedTextureWidth, m_dwCreatedTextureHeight, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, m_pTexture);
#else
//GL_BGRA_IMG works on adreno but not inside profiler.
glTexImage2D(GL_TEXTURE_2D, 0, m_glFmt, m_dwCreatedTextureWidth, m_dwCreatedTextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_pTexture);
if(options.mipmapping)
glGenerateMipmap(GL_TEXTURE_2D);
#endif
OPENGL_CHECK_ERRORS;
}
bool COGLColorCombiner::Initialize(void)
{
m_bSupportAdd = false;
m_bSupportSubtract = false;
m_supportedStages = 1;
COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
if( pcontext->IsExtensionSupported(OSAL_GL_ARB_TEXTURE_ENV_ADD) || pcontext->IsExtensionSupported("GL_EXT_texture_env_add") )
{
m_bSupportAdd = true;
}
if( pcontext->IsExtensionSupported("GL_EXT_blend_subtract") )
{
m_bSupportSubtract = true;
}
return true;
}
bool COGLColorCombinerTNT2::Initialize(void)
{
m_bTNT2Supported = false;
if( COGLColorCombiner4::Initialize() )
{
m_bSupportMultiTexture = true;
COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
if( pcontext->IsExtensionSupported("GL_NV_texture_env_combine4") )
{
m_bTNT2Supported = true;
}
else
{
DebugMessage(M64MSG_ERROR, "Your video card does not support OpenGL TNT2 extension combiner, you can only use the OpenGL Ext combiner functions");
}
return true;
}
return false;
}
CColorCombiner * OGLDeviceBuilder::CreateColorCombiner(CRender *pRender)
{
if( m_pColorCombiner == NULL )
{
if( CGraphicsContext::g_pGraphicsContext == NULL && CGraphicsContext::g_pGraphicsContext->Ready() )
{
DebugMessage(M64MSG_ERROR, "Can not create ColorCombiner before creating and initializing GraphicsContext");
}
else
{
m_deviceType = (SupportedDeviceType)options.OpenglRenderSetting;
#if SDL_VIDEO_OPENGL
if (m_deviceType == NVIDIA_OGL_DEVICE && !bNvidiaExtensionsSupported)
{
DebugMessage(M64MSG_WARNING, "Your video card does not support Nvidia OpenGL extensions. Falling back to auto device.");
m_deviceType = OGL_DEVICE;
}
if( m_deviceType == OGL_DEVICE ) // Best fit
{
GLint maxUnit = 2;
COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB,&maxUnit);
OPENGL_CHECK_ERRORS;
#ifndef HAVE_GLES
if( pcontext->IsExtensionSupported("GL_ARB_fragment_program") )
{
m_pColorCombiner = new COGL_FragmentProgramCombiner(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: Fragment Program");
}
else if( pcontext->IsExtensionSupported("GL_NV_texture_env_combine4") ||
pcontext->IsExtensionSupported("GL_NV_register_combiners") )
{
m_pColorCombiner = new COGLColorCombinerNvidia(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: NVidia");
}
else if( pcontext->IsExtensionSupported("GL_NV_texture_env_combine4") )
{
m_pColorCombiner = new COGLColorCombinerTNT2(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: TNT2");
}
else if( pcontext->IsExtensionSupported("GL_EXT_texture_env_combine") ||
pcontext->IsExtensionSupported("GL_ARB_texture_env_combine") )
{
if( pcontext->IsExtensionSupported("GL_ARB_texture_env_crossbar") )
#endif
{
#ifndef HAVE_GLES
if( maxUnit > 2 )
{
m_pColorCombiner = new COGLColorCombiner4v2(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: OGL 1.4 version 2");
}
else
#endif
{
m_pColorCombiner = new COGLColorCombiner4(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: OGL 1.4");
}
}
#ifndef HAVE_GLES
else
{
if( maxUnit > 2 )
{
m_pColorCombiner = new COGLColorCombiner4v2(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: OGL 1.4 version 2 (w/o env crossbar)");
}
else
{
m_pColorCombiner = new COGLColorCombiner2(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: OGL 1.2/1.3");
}
}
}
else
{
m_pColorCombiner = new COGLColorCombiner(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: Basic OGL");
}
#endif
}
else
{
switch(m_deviceType)
{
case OGL_1_1_DEVICE:
m_pColorCombiner = new COGLColorCombiner(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: Basic OGL");
break;
case OGL_1_2_DEVICE:
case OGL_1_3_DEVICE:
m_pColorCombiner = new COGLColorCombiner2(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: OGL 1.2/1.3");
break;
case OGL_1_4_DEVICE:
m_pColorCombiner = new COGLColorCombiner4(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: OGL 1.4");
break;
case OGL_1_4_V2_DEVICE:
m_pColorCombiner = new COGLColorCombiner4v2(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: OGL 1.4 Version 2");
break;
#ifndef HAVE_GLES
case OGL_TNT2_DEVICE:
m_pColorCombiner = new COGLColorCombinerTNT2(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: TNT2");
break;
case NVIDIA_OGL_DEVICE:
m_pColorCombiner = new COGLColorCombinerNvidia(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: Nvidia");
break;
case OGL_FRAGMENT_PROGRAM:
m_pColorCombiner = new COGL_FragmentProgramCombiner(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: Fragment Program");
break;
#endif
default:
break;
}
}
#elif SDL_VIDEO_OPENGL_ES2
m_pColorCombiner = new COGL_FragmentProgramCombiner(pRender);
DebugMessage(M64MSG_VERBOSE, "OpenGL Combiner: Fragment Program");
#endif
}
SAFE_CHECK(m_pColorCombiner);
}
return m_pColorCombiner;
}
void OGLRender::Initialize(void)
{
glMatrixMode(GL_MODELVIEW);
OPENGL_CHECK_ERRORS;
glLoadIdentity();
OPENGL_CHECK_ERRORS;
glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight);
OPENGL_CHECK_ERRORS;
#if SDL_VIDEO_OPENGL
COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
if( pcontext->IsExtensionSupported("GL_IBM_texture_mirrored_repeat") )
{
OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT_IBM;
}
else if( pcontext->IsExtensionSupported("ARB_texture_mirrored_repeat") )
{
OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT_ARB;
}
else
{
OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_REPEAT;
}
if( pcontext->IsExtensionSupported("GL_ARB_texture_border_clamp") || pcontext->IsExtensionSupported("GL_EXT_texture_edge_clamp") )
{
m_bSupportClampToEdge = true;
OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP_TO_EDGE;
}
else
{
m_bSupportClampToEdge = false;
OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP;
}
glVertexPointer( 4, GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][0]) );
OPENGL_CHECK_ERRORS;
glEnableClientState( GL_VERTEX_ARRAY );
OPENGL_CHECK_ERRORS;
if( m_bMultiTexture )
{
pglClientActiveTextureARB( GL_TEXTURE0_ARB );
OPENGL_CHECK_ERRORS;
glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u) );
OPENGL_CHECK_ERRORS;
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
OPENGL_CHECK_ERRORS;
pglClientActiveTextureARB( GL_TEXTURE1_ARB );
OPENGL_CHECK_ERRORS;
glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[1].u) );
OPENGL_CHECK_ERRORS;
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
OPENGL_CHECK_ERRORS;
}
else
{
glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u) );
OPENGL_CHECK_ERRORS;
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
OPENGL_CHECK_ERRORS;
}
if (m_bSupportFogCoordExt)
{
pglFogCoordPointerEXT( GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][4]) );
OPENGL_CHECK_ERRORS;
glEnableClientState( GL_FOG_COORDINATE_ARRAY_EXT );
OPENGL_CHECK_ERRORS;
glFogi( GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT );
OPENGL_CHECK_ERRORS;
glFogi(GL_FOG_MODE, GL_LINEAR); // Fog Mode
OPENGL_CHECK_ERRORS;
glFogf(GL_FOG_DENSITY, 1.0f); // How Dense Will The Fog Be
OPENGL_CHECK_ERRORS;
glHint(GL_FOG_HINT, GL_FASTEST); // Fog Hint Value
OPENGL_CHECK_ERRORS;
glFogi( GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT );
OPENGL_CHECK_ERRORS;
glFogf( GL_FOG_START, 0.0f );
OPENGL_CHECK_ERRORS;
glFogf( GL_FOG_END, 1.0f );
OPENGL_CHECK_ERRORS;
}
//glColorPointer( 1, GL_UNSIGNED_BYTE, sizeof(TLITVERTEX), &g_vtxBuffer[0].r);
glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
OPENGL_CHECK_ERRORS;
glEnableClientState( GL_COLOR_ARRAY );
OPENGL_CHECK_ERRORS;
if( pcontext->IsExtensionSupported("GL_NV_depth_clamp") )
{
glEnable(GL_DEPTH_CLAMP_NV);
OPENGL_CHECK_ERRORS;
}
#elif SDL_VIDEO_OPENGL_ES2
OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT;
m_bSupportClampToEdge = true;
OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP_TO_EDGE;
#endif
#ifdef PAULSCODE
hardwareType = Android_JNI_GetHardwareType();
#endif
}
