bool COGLGraphicsContext::Initialize(uint32_t dwWidth, uint32_t dwHeight)
{
DebugMessage(M64MSG_INFO, "Initializing OpenGL Device Context.");
CGraphicsContext::Initialize(dwWidth, dwHeight);
int depthBufferDepth = options.OpenglDepthBufferSetting;
int colorBufferDepth = 32;
int bVerticalSync = windowSetting.bVerticalSync;
if (options.colorQuality == TEXTURE_FMT_A4R4G4B4)
colorBufferDepth = 16;
InitState();
InitOGLExtension();
sprintf(m_strDeviceStats, "%.60s - %.128s : %.60s", m_pVendorStr, m_pRenderStr, m_pVersionStr);
TRACE0(m_strDeviceStats);
DebugMessage(M64MSG_INFO, "Using OpenGL: %s", m_strDeviceStats);
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER, 0xFF000000, 1.0f); // Clear buffers
UpdateFrame(false);
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER, 0xFF000000, 1.0f);
UpdateFrame(false);
return true;
}
bool COGLGraphicsContext::Initialize(uint32 dwWidth, uint32 dwHeight, bool bWindowed)
{
DebugMessage(M64MSG_INFO, "Initializing OpenGL Device Context.");
CGraphicsContext::Get()->m_supportTextureMirror = false;
CGraphicsContext::Initialize(dwWidth, dwHeight, bWindowed);
if (bWindowed)
{
windowSetting.statusBarHeightToUse = windowSetting.statusBarHeight;
windowSetting.toolbarHeightToUse = windowSetting.toolbarHeight;
}
else
{
windowSetting.statusBarHeightToUse = 0;
windowSetting.toolbarHeightToUse = 0;
}
int depthBufferDepth = options.OpenglDepthBufferSetting;
int colorBufferDepth = 32;
int bVerticalSync = windowSetting.bVerticalSync;
if (options.colorQuality == TEXTURE_FMT_A4R4G4B4)
colorBufferDepth = 16;
InitState();
InitOGLExtension();
sprintf(m_strDeviceStats, "%.60s - %.128s : %.60s", m_pVendorStr, m_pRenderStr, m_pVersionStr);
TRACE0(m_strDeviceStats);
DebugMessage(M64MSG_INFO, "Using OpenGL: %s", m_strDeviceStats);
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER, 0xFF000000, 1.0f); // Clear buffers
UpdateFrame(false);
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER, 0xFF000000, 1.0f);
UpdateFrame(false);
m_bReady = true;
status.isVertexShaderEnabled = false;
return true;
}
bool COGLGraphicsContext::Initialize(HWND hWnd, HWND hWndStatus, uint32 dwWidth, uint32 dwHeight, BOOL bWindowed )
{
printf("Initializing OpenGL Device Context\n");
Lock();
CGraphicsContext::Get()->m_supportTextureMirror = false;
CGraphicsContext::Initialize(hWnd, hWndStatus, dwWidth, dwHeight, bWindowed );
if( bWindowed )
{
windowSetting.statusBarHeightToUse = windowSetting.statusBarHeight;
windowSetting.toolbarHeightToUse = windowSetting.toolbarHeight;
}
else
{
windowSetting.statusBarHeightToUse = 0;
windowSetting.toolbarHeightToUse = 0;
}
int depthBufferDepth = options.OpenglDepthBufferSetting;
int colorBufferDepth = 32;
if( options.colorQuality == TEXTURE_FMT_A4R4G4B4 ) colorBufferDepth = 16;
// init sdl & gl
const SDL_VideoInfo *videoInfo;
Uint32 videoFlags = 0;
/* Initialize SDL */
printf("(II) Initializing SDL video subsystem...\n");
if(SDL_InitSubSystem(SDL_INIT_VIDEO) == -1)
{
printf("(EE) Error initializing SDL video subsystem: %s\n", SDL_GetError());
return false;
}
/* Video Info */
printf("(II) Getting video info...\n");
if(!(videoInfo = SDL_GetVideoInfo()))
{
printf("(EE) Video query failed: %s\n", SDL_GetError());
SDL_QuitSubSystem(SDL_INIT_VIDEO);
return false;
}
/* Setting the video mode */
videoFlags |= SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE;
if(videoInfo->hw_available)
videoFlags |= SDL_HWSURFACE;
else
videoFlags |= SDL_SWSURFACE;
if(videoInfo->blit_hw)
videoFlags |= SDL_HWACCEL;
if(!bWindowed)
videoFlags |= SDL_FULLSCREEN;
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, colorBufferDepth);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, depthBufferDepth);
printf("(II) Setting video mode %dx%d...\n", (int)windowSetting.uDisplayWidth, (int)windowSetting.uDisplayHeight);
if(!(m_pScreen = SDL_SetVideoMode(windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, colorBufferDepth, videoFlags)))
{
printf("(EE) Error setting video mode %dx%d: %s\n", (int)windowSetting.uDisplayWidth, (int)windowSetting.uDisplayHeight, SDL_GetError());
SDL_QuitSubSystem(SDL_INIT_VIDEO);
return false;
}
char caption[500];
sprintf(caption, "RiceVideoLinux N64 Plugin %s", MUPEN_VERSION);
SDL_WM_SetCaption(caption, caption);
SetWindowMode();
InitState();
InitOGLExtension();
sprintf(m_strDeviceStats, "%s - %s : %s", m_pVendorStr, m_pRenderStr, m_pVersionStr);
TRACE0(m_strDeviceStats);
printf("%s\n", m_strDeviceStats);
Unlock();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER); // Clear buffers
UpdateFrame();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER);
UpdateFrame();
m_bReady = true;
status.isVertexShaderEnabled = false;
return true;
}
bool COGLGraphicsContext::Initialize(uint32 dwWidth, uint32 dwHeight, BOOL bWindowed )
{
DebugMessage(M64MSG_INFO, "Initializing OpenGL Device Context.");
Lock();
CGraphicsContext::Initialize(dwWidth, dwHeight, bWindowed );
if( bWindowed )
{
windowSetting.statusBarHeightToUse = windowSetting.statusBarHeight;
windowSetting.toolbarHeightToUse = windowSetting.toolbarHeight;
}
else
{
windowSetting.statusBarHeightToUse = 0;
windowSetting.toolbarHeightToUse = 0;
}
int depthBufferDepth = options.OpenglDepthBufferSetting;
int colorBufferDepth = 32;
int bVerticalSync = windowSetting.bVerticalSync;
if( options.colorQuality == TEXTURE_FMT_A4R4G4B4 ) colorBufferDepth = 16;
// init sdl & gl
DebugMessage(M64MSG_VERBOSE, "Initializing video subsystem...");
if (CoreVideo_Init() != M64ERR_SUCCESS)
return false;
/* hard-coded attribute values */
const int iDOUBLEBUFFER = 1;
// OpenEmu
#if 0
/* set opengl attributes */
CoreVideo_GL_SetAttribute(M64P_GL_DOUBLEBUFFER, iDOUBLEBUFFER);
CoreVideo_GL_SetAttribute(M64P_GL_SWAP_CONTROL, bVerticalSync);
CoreVideo_GL_SetAttribute(M64P_GL_BUFFER_SIZE, colorBufferDepth);
CoreVideo_GL_SetAttribute(M64P_GL_DEPTH_SIZE, depthBufferDepth);
#endif
/* set multisampling */
if (options.multiSampling > 0)
{
CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLEBUFFERS, 1);
if (options.multiSampling <= 2)
CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 2);
else if (options.multiSampling <= 4)
CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 4);
else if (options.multiSampling <= 8)
CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 8);
else
CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 16);
}
/* Set the video mode */
m64p_video_mode ScreenMode = bWindowed ? M64VIDEO_WINDOWED : M64VIDEO_FULLSCREEN;
m64p_video_flags flags = M64VIDEOFLAG_SUPPORT_RESIZING;
if (CoreVideo_SetVideoMode(windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, colorBufferDepth, ScreenMode, flags) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "Failed to set %i-bit video mode: %ix%i", colorBufferDepth, (int)windowSetting.uDisplayWidth, (int)windowSetting.uDisplayHeight);
CoreVideo_Quit();
return false;
}
// OpenEmu
#if 0
/* check that our opengl attributes were properly set */
int iActual;
if (CoreVideo_GL_GetAttribute(M64P_GL_DOUBLEBUFFER, &iActual) == M64ERR_SUCCESS)
if (iActual != iDOUBLEBUFFER)
DebugMessage(M64MSG_WARNING, "Failed to set GL_DOUBLEBUFFER to %i. (it's %i)", iDOUBLEBUFFER, iActual);
if (CoreVideo_GL_GetAttribute(M64P_GL_SWAP_CONTROL, &iActual) == M64ERR_SUCCESS)
if (iActual != bVerticalSync)
DebugMessage(M64MSG_WARNING, "Failed to set GL_SWAP_CONTROL to %i. (it's %i)", bVerticalSync, iActual);
if (CoreVideo_GL_GetAttribute(M64P_GL_BUFFER_SIZE, &iActual) == M64ERR_SUCCESS)
if (iActual != colorBufferDepth)
DebugMessage(M64MSG_WARNING, "Failed to set GL_BUFFER_SIZE to %i. (it's %i)", colorBufferDepth, iActual);
if (CoreVideo_GL_GetAttribute(M64P_GL_DEPTH_SIZE, &iActual) == M64ERR_SUCCESS)
if (iActual != depthBufferDepth)
DebugMessage(M64MSG_WARNING, "Failed to set GL_DEPTH_SIZE to %i. (it's %i)", depthBufferDepth, iActual);
#endif
#ifndef USE_GLES
/* Get function pointers to OpenGL extensions (blame Microsoft Windows for this) */
OGLExtensions_Init();
#endif
char caption[500];
sprintf(caption, "%s v%i.%i.%i", PLUGIN_NAME, VERSION_PRINTF_SPLIT(PLUGIN_VERSION));
CoreVideo_SetCaption(caption);
SetWindowMode();
InitState();
InitOGLExtension();
sprintf(m_strDeviceStats, "%.60s - %.128s : %.60s", m_pVendorStr, m_pRenderStr, m_pVersionStr);
TRACE0(m_strDeviceStats);
DebugMessage(M64MSG_INFO, "Using OpenGL: %s", m_strDeviceStats);
Unlock();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER); // Clear buffers
UpdateFrame();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER);
UpdateFrame();
m_bReady = true;
return true;
}
bool COGLGraphicsContext::Initialize(uint32 dwWidth, uint32 dwHeight, BOOL bWindowed )
{
DebugMessage(M64MSG_INFO, "Initializing OpenGL Device Context.");
Lock();
CGraphicsContext::Get()->m_supportTextureMirror = false;
CGraphicsContext::Initialize(dwWidth, dwHeight, bWindowed );
if( bWindowed )
{
windowSetting.statusBarHeightToUse = windowSetting.statusBarHeight;
windowSetting.toolbarHeightToUse = windowSetting.toolbarHeight;
}
else
{
windowSetting.statusBarHeightToUse = 0;
windowSetting.toolbarHeightToUse = 0;
}
int depthBufferDepth = options.OpenglDepthBufferSetting;
int colorBufferDepth = 32;
if( options.colorQuality == TEXTURE_FMT_A4R4G4B4 ) colorBufferDepth = 16;
// init sdl & gl
DebugMessage(M64MSG_VERBOSE, "Initializing video subsystem...");
if (CoreVideo_Init() != M64ERR_SUCCESS)
return false;
/* set opengl attributes */
CoreVideo_GL_SetAttribute(M64P_GL_DOUBLEBUFFER, 1);
CoreVideo_GL_SetAttribute(M64P_GL_BUFFER_SIZE, colorBufferDepth);
CoreVideo_GL_SetAttribute(M64P_GL_DEPTH_SIZE, depthBufferDepth);
/* Set the video mode */
m64p_video_mode ScreenMode = bWindowed ? M64VIDEO_WINDOWED : M64VIDEO_FULLSCREEN;
if (CoreVideo_SetVideoMode(windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, colorBufferDepth, ScreenMode) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "Failed to set %i-bit video mode: %ix%i", colorBufferDepth, (int)windowSetting.uDisplayWidth, (int)windowSetting.uDisplayHeight);
CoreVideo_Quit();
return false;
}
char caption[500];
sprintf(caption, "%s v%i.%i.%i", PLUGIN_NAME, VERSION_PRINTF_SPLIT(PLUGIN_VERSION));
CoreVideo_SetCaption(caption);
SetWindowMode();
InitState();
InitOGLExtension();
sprintf(m_strDeviceStats, "%s - %s : %s", m_pVendorStr, m_pRenderStr, m_pVersionStr);
TRACE0(m_strDeviceStats);
DebugMessage(M64MSG_INFO, "Using OpenGL: %s", m_strDeviceStats);
Unlock();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER); // Clear buffers
UpdateFrame();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER);
UpdateFrame();
m_bReady = true;
status.isVertexShaderEnabled = false;
return true;
}
bool COGLGraphicsContext::Initialize(uint32 dwWidth, uint32 dwHeight, BOOL bWindowed )
{
DebugMessage(M64MSG_INFO, "Initializing OpenGL Device Context.");
Lock();
CGraphicsContext::Get()->m_supportTextureMirror = false;
CGraphicsContext::Initialize(dwWidth, dwHeight, bWindowed );
if( bWindowed )
{
windowSetting.statusBarHeightToUse = windowSetting.statusBarHeight;
windowSetting.toolbarHeightToUse = windowSetting.toolbarHeight;
}
else
{
windowSetting.statusBarHeightToUse = 0;
windowSetting.toolbarHeightToUse = 0;
}
int depthBufferDepth = options.OpenglDepthBufferSetting;
int colorBufferDepth = 32;
int bVerticalSync = windowSetting.bVerticalSync;
if( options.colorQuality == TEXTURE_FMT_A4R4G4B4 ) colorBufferDepth = 16;
/* // init sdl & gl
DebugMessage(M64MSG_VERBOSE, "Initializing video subsystem...");
if (CoreVideo_Init() != M64ERR_SUCCESS)
return false;
*/
/* hard-coded attribute values */
const int iDOUBLEBUFFER = 1;
/* set opengl attributes */
// CoreVideo_GL_SetAttribute(M64P_GL_DOUBLEBUFFER, iDOUBLEBUFFER);
// CoreVideo_GL_SetAttribute(M64P_GL_SWAP_CONTROL, bVerticalSync);
// CoreVideo_GL_SetAttribute(M64P_GL_BUFFER_SIZE, colorBufferDepth);
// CoreVideo_GL_SetAttribute(M64P_GL_DEPTH_SIZE, depthBufferDepth);
//
// /* set multisampling */
// if (options.multiSampling > 0)
// {
// CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLEBUFFERS, 1);
// if (options.multiSampling <= 2)
// CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 2);
// else if (options.multiSampling <= 4)
// CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 4);
// else if (options.multiSampling <= 8)
// CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 8);
// else
// CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 16);
// }
//
// /* Set the video mode */
// m64p_video_mode ScreenMode = bWindowed ? M64VIDEO_WINDOWED : M64VIDEO_FULLSCREEN;
// if (CoreVideo_SetVideoMode(windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, colorBufferDepth, ScreenMode) != M64ERR_SUCCESS)
// {
// DebugMessage(M64MSG_ERROR, "Failed to set %i-bit video mode: %ix%i", colorBufferDepth, (int)windowSetting.uDisplayWidth, (int)windowSetting.uDisplayHeight);
// CoreVideo_Quit();
// return false;
// }
//
//#ifdef WIN32
// GLenum err = glewInit();
// if (GLEW_OK != err)
// {
// /* Problem: glewInit failed, something is seriously wrong. */
// fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
// }
//#endif
//
// char caption[500];
// sprintf(caption, "%s v%i.%i.%i", PLUGIN_NAME, VERSION_PRINTF_SPLIT(PLUGIN_VERSION));
// CoreVideo_SetCaption(caption);
// SetWindowMode();
/*
SDL_Surface* screen;
SDL_Init(SDL_INIT_VIDEO);
if (!(screen = SDL_SetVideoMode(1024, 768, 16, SDL_SWSURFACE )))
{
SDL_QuitSubSystem( SDL_INIT_VIDEO );
return FALSE;
}
EGLNativeWindowType EGL_handle;
EGLContext EGL_context;
HDC EGL_device;
EGLint EGL_version_major,EGL_version_minor;
EGLint nConfigs;
EGLConfig EGL_config;
GLint success;
const EGLint ConfigAttribs[] =
{
EGL_LEVEL, 0,
EGL_DEPTH_SIZE, 16,
EGL_STENCIL_SIZE, 0,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NATIVE_RENDERABLE, EGL_FALSE,
EGL_NONE
};
const EGLint ContextAttribs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
SDL_GetWMInfo(&info);
EGL_handle = (EGLNativeWindowType) info.window;
EGL_device = GetDC(EGL_handle);
printf("EGL Context Creation\n");
EGL_display = eglGetDisplay((EGLNativeDisplayType) EGL_device);
if (EGL_display == EGL_NO_DISPLAY){
printf( "EGL Display Get failed: %s \n", EGLErrorString());
return FALSE;
}
if (!eglInitialize(EGL_display, &EGL_version_major, &EGL_version_minor)){
printf( "EGL Display Initialize failed: %s \n", EGLErrorString());
return FALSE;
}
if (!eglChooseConfig(EGL_display, ConfigAttribs, &EGL_config, 1, &nConfigs)){
printf( "EGL Configuration failed: %s \n", EGLErrorString());
return FALSE;
} else if (nConfigs != 1){
printf( "EGL Configuration failed: nconfig %i, %s \n", nConfigs, EGLErrorString());
return FALSE;
}
EGL_surface = eglCreateWindowSurface(EGL_display, EGL_config, EGL_handle, NULL);
if (EGL_surface == EGL_NO_SURFACE){
printf("EGL Surface Creation failed: %s will attempt without window... \n", EGLErrorString());
EGL_surface = eglCreateWindowSurface(EGL_display, EGL_config, NULL, NULL);
if (EGL_surface == EGL_NO_SURFACE){
printf( "EGL Surface Creation failed: %s \n", EGLErrorString());
return FALSE;
}
}
eglBindAPI(EGL_OPENGL_ES_API);
EGL_context = eglCreateContext(EGL_display, EGL_config, EGL_NO_CONTEXT, ContextAttribs);
if (EGL_context == EGL_NO_CONTEXT){
printf( "EGL Context Creation failed: %s \n", EGLErrorString());
return FALSE;
}
if (!eglMakeCurrent(EGL_display, EGL_surface, EGL_surface, EGL_context)){
printf( "EGL Make Current failed: %s \n", EGLErrorString());
return FALSE;
};
eglSwapInterval(EGL_display, 1);
*/
#ifdef USE_SDL
//// paulscode, added for switching between RGBA8888 and RGB565
// (part of the color banding fix)
int bitsPP;
if( Android_JNI_UseRGBA8888() )
bitsPP = 32;
else
bitsPP = 16;
/* Set the video mode */
SDL_Surface* hScreen;
printf( "Setting video mode %dx%d...\n", windowSetting.uDisplayWidth, windowSetting.uDisplayHeight );
// TODO: I should actually check what the pixelformat is, rather than assuming 16 bpp (RGB_565) or 32 bpp (RGBA_8888):
// if (!(hScreen = SDL_SetVideoMode( windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, 16, SDL_HWSURFACE )))
if (!(hScreen = SDL_SetVideoMode( windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, bitsPP, SDL_HWSURFACE )))
{
printf( "Problem setting videomode %dx%d: %s\n", windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, SDL_GetError() );
SDL_QuitSubSystem( SDL_INIT_VIDEO );
return false;
}
#endif
InitState();
InitOGLExtension();
sprintf(m_strDeviceStats, "%.60s - %.128s : %.60s", m_pVendorStr, m_pRenderStr, m_pVersionStr);
TRACE0(m_strDeviceStats);
DebugMessage(M64MSG_INFO, "Using OpenGL: %s", m_strDeviceStats);
GLint precision,range;
glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_LOW_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Vertex Shader lowp precision:%i range:%i",precision,range);
glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Vertex Shader mediump precision:%i range:%i",precision,range);
glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Vertex Shader highp precision:%i range:%i",precision,range);
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER ,GL_LOW_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Fragment Shader lowp precision:%i range:%i",precision,range);
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Fragment Shader mediump precision:%i range:%i",precision,range);
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Fragment Shader highp precision:%i range:%i",precision,range);
Unlock();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER); // Clear buffers
UpdateFrame();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER);
UpdateFrame();
m_bReady = true;
status.isVertexShaderEnabled = false;
return true;
}
