The-Homebrew-Cloud/dolphin
2
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-02-21 11:37:14 +01:00
Code Issues Packages Projects Releases Wiki Activity

VideoSW: Use OpenGL Core context

Browse Source
This commit is contained in:
degasus 2015-10-09 09:25:09 +02:00
parent 61c3a0d9e4
commit b69bff0690
4 changed files with 52 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
Source/Core/Common/GL/GLUtil.cpp
View File

@ -16,7 +16,7 @@ void InitInterface()
GLInterface = HostGL_CreateGLInterface(); GLInterface = HostGL_CreateGLInterface();
} }
GLuint OpenGL_CompileProgram(const char* vertexShader, const char* fragmentShader) GLuint OpenGL_CompileProgram(const std::string& vertexShader, const std::string& fragmentShader)
{ {
// generate objects // generate objects
GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER); GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
@ -24,7 +24,8 @@ GLuint OpenGL_CompileProgram(const char* vertexShader, const char* fragmentShade
GLuint programID = glCreateProgram(); GLuint programID = glCreateProgram();
// compile vertex shader // compile vertex shader
glShaderSource(vertexShaderID, 1, &vertexShader, nullptr); const char* shader = vertexShader.c_str();
glShaderSource(vertexShaderID, 1, &shader, nullptr);
glCompileShader(vertexShaderID); glCompileShader(vertexShaderID);
#if defined(_DEBUG) || defined(DEBUGFAST) || defined(DEBUG_GLSL) #if defined(_DEBUG) || defined(DEBUGFAST) || defined(DEBUG_GLSL)
GLint Result = GL_FALSE; GLint Result = GL_FALSE;
@ -35,22 +36,23 @@ GLuint OpenGL_CompileProgram(const char* vertexShader, const char* fragmentShade
if (Result && stringBufferUsage) if (Result && stringBufferUsage)
{ {
ERROR_LOG(VIDEO, "GLSL vertex shader warnings:\n%s%s", stringBuffer, vertexShader); ERROR_LOG(VIDEO, "GLSL vertex shader warnings:\n%s%s", stringBuffer, vertexShader.c_str());
} }
else if (!Result) else if (!Result)
{ {
ERROR_LOG(VIDEO, "GLSL vertex shader error:\n%s%s", stringBuffer, vertexShader); ERROR_LOG(VIDEO, "GLSL vertex shader error:\n%s%s", stringBuffer, vertexShader.c_str());
} }
else else
{ {
DEBUG_LOG(VIDEO, "GLSL vertex shader compiled:\n%s", vertexShader); DEBUG_LOG(VIDEO, "GLSL vertex shader compiled:\n%s", vertexShader.c_str());
} }
bool shader_errors = !Result; bool shader_errors = !Result;
#endif #endif
// compile fragment shader // compile fragment shader
glShaderSource(fragmentShaderID, 1, &fragmentShader, nullptr); shader = fragmentShader.c_str();
glShaderSource(fragmentShaderID, 1, &shader, nullptr);
glCompileShader(fragmentShaderID); glCompileShader(fragmentShaderID);
#if defined(_DEBUG) || defined(DEBUGFAST) || defined(DEBUG_GLSL) #if defined(_DEBUG) || defined(DEBUGFAST) || defined(DEBUG_GLSL)
glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &Result); glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &Result);
@ -58,15 +60,15 @@ GLuint OpenGL_CompileProgram(const char* vertexShader, const char* fragmentShade
if (Result && stringBufferUsage) if (Result && stringBufferUsage)
{ {
ERROR_LOG(VIDEO, "GLSL fragment shader warnings:\n%s%s", stringBuffer, fragmentShader); ERROR_LOG(VIDEO, "GLSL fragment shader warnings:\n%s%s", stringBuffer, fragmentShader.c_str());
} }
else if (!Result) else if (!Result)
{ {
ERROR_LOG(VIDEO, "GLSL fragment shader error:\n%s%s", stringBuffer, fragmentShader); ERROR_LOG(VIDEO, "GLSL fragment shader error:\n%s%s", stringBuffer, fragmentShader.c_str());
} }
else else
{ {
DEBUG_LOG(VIDEO, "GLSL fragment shader compiled:\n%s", fragmentShader); DEBUG_LOG(VIDEO, "GLSL fragment shader compiled:\n%s", fragmentShader.c_str());
} }
shader_errors |= !Result; shader_errors |= !Result;
@ -82,11 +84,11 @@ GLuint OpenGL_CompileProgram(const char* vertexShader, const char* fragmentShade
if (Result && stringBufferUsage) if (Result && stringBufferUsage)
{ {
ERROR_LOG(VIDEO, "GLSL linker warnings:\n%s%s%s", stringBuffer, vertexShader, fragmentShader); ERROR_LOG(VIDEO, "GLSL linker warnings:\n%s%s%s", stringBuffer, vertexShader.c_str(), fragmentShader.c_str());
} }
else if (!Result && !shader_errors) else if (!Result && !shader_errors)
{ {
ERROR_LOG(VIDEO, "GLSL linker error:\n%s%s%s", stringBuffer, vertexShader, fragmentShader); ERROR_LOG(VIDEO, "GLSL linker error:\n%s%s%s", stringBuffer, vertexShader.c_str(), fragmentShader.c_str());
} }
#endif #endif

4
Source/Core/Common/GL/GLUtil.h
View File

@ -4,6 +4,8 @@
#pragma once #pragma once
#include <string>
#include "Common/GL/GLExtensions/GLExtensions.h" #include "Common/GL/GLExtensions/GLExtensions.h"
#ifndef _WIN32 #ifndef _WIN32
@ -14,7 +16,7 @@
void InitInterface(); void InitInterface();
// Helpers // Helpers
GLuint OpenGL_CompileProgram(const char *vertexShader, const char *fragmentShader); GLuint OpenGL_CompileProgram(const std::string& vertexShader, const std::string& fragmentShader);
// Creates and deletes a VAO and VBO suitable for attributeless rendering. // Creates and deletes a VAO and VBO suitable for attributeless rendering.
// Called by the Renderer. // Called by the Renderer.

81
Source/Core/VideoBackends/Software/SWOGLWindow.cpp
View File

@ -14,7 +14,7 @@ void SWOGLWindow::Init(void *window_handle)
{ {
InitInterface(); InitInterface();
GLInterface->SetMode(GLInterfaceMode::MODE_DETECT); GLInterface->SetMode(GLInterfaceMode::MODE_DETECT);
if (!GLInterface->Create(window_handle, false)) if (!GLInterface->Create(window_handle))
{ {
INFO_LOG(VIDEO, "GLInterface::Create failed."); INFO_LOG(VIDEO, "GLInterface::Create failed.");
} }
@ -42,39 +42,47 @@ void SWOGLWindow::Prepare()
ERROR_LOG(VIDEO, "GLExtensions::Init failed!Does your video card support OpenGL 2.0?"); ERROR_LOG(VIDEO, "GLExtensions::Init failed!Does your video card support OpenGL 2.0?");
return; return;
} }
else if (GLExtensions::Version() < 310)
{
ERROR_LOG(VIDEO, "OpenGL Version %d detected, but at least 3.1 is required.", GLExtensions::Version());
return;
}
static const char *fragShaderText = std::string frag_shader =
"#ifdef GL_ES\n" "in vec2 TexCoord;\n"
"precision highp float;\n" "out vec4 ColorOut;\n"
"#endif\n"
"varying vec2 TexCoordOut;\n"
"uniform sampler2D Texture;\n" "uniform sampler2D Texture;\n"
"void main() {\n" "void main() {\n"
" gl_FragColor = texture2D(Texture, TexCoordOut);\n" " ColorOut = texture2D(Texture, TexCoord);\n"
"}\n";
static const char *vertShaderText =
"#ifdef GL_ES\n"
"precision highp float;\n"
"#endif\n"
"attribute vec4 pos;\n"
"attribute vec2 TexCoordIn;\n "
"varying vec2 TexCoordOut;\n "
"void main() {\n"
" gl_Position = pos;\n"
" TexCoordOut = TexCoordIn;\n"
"}\n"; "}\n";
m_image_program = OpenGL_CompileProgram(vertShaderText, fragShaderText); std::string vertex_shader =
"out vec2 TexCoord;\n"
"void main() {\n"
" vec2 rawpos = vec2(gl_VertexID & 1, (gl_VertexID & 2) >> 1);\n"
" gl_Position = vec4(rawpos * 2.0 - 1.0, 0.0, 1.0);\n"
" TexCoord = vec2(rawpos.x, -rawpos.y);\n"
"}\n";
std::string header =
GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGL ?
"#version 140\n"
:
"#version 300 es\n"
"precision highp float;\n";
m_image_program = OpenGL_CompileProgram(header + vertex_shader, header + frag_shader);
glUseProgram(m_image_program); glUseProgram(m_image_program);
m_uni_tex = glGetUniformLocation(m_image_program, "Texture"); glUniform1i(glGetUniformLocation(m_image_program, "Texture"), 0);
m_attr_pos = glGetAttribLocation(m_image_program, "pos");
m_attr_tex = glGetAttribLocation(m_image_program, "TexCoordIn");
glUniform1i(m_uni_tex, 0);
glGenTextures(1, &m_image_texture); glGenTextures(1, &m_image_texture);
glBindTexture(GL_TEXTURE_2D, m_image_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glGenVertexArrays(1, &m_image_vao);
} }
void SWOGLWindow::PrintText(const std::string& text, int x, int y, u32 color) void SWOGLWindow::PrintText(const std::string& text, int x, int y, u32 color)
@ -97,32 +105,13 @@ void SWOGLWindow::ShowImage(u8* data, int stride, int width, int height, float a
glBindTexture(GL_TEXTURE_2D, m_image_texture); glBindTexture(GL_TEXTURE_2D, m_image_texture);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4); // 4-byte pixel alignment glPixelStorei(GL_UNPACK_ALIGNMENT, 4); // 4-byte pixel alignment
//glPixelStorei(GL_UNPACK_ROW_LENGTH, stride); glPixelStorei(GL_UNPACK_ROW_LENGTH, stride / 4);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)width, (GLsizei)height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)width, (GLsizei)height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glUseProgram(m_image_program); glUseProgram(m_image_program);
static const GLfloat verts[4][2] = {
{ -1, -1}, // Left top
{ -1, 1}, // left bottom
{ 1, 1}, // right bottom
{ 1, -1} // right top
};
static const GLfloat texverts[4][2] = {
{0, 1},
{0, 0},
{1, 0},
{1, 1}
};
glVertexAttribPointer(m_attr_pos, 2, GL_FLOAT, GL_FALSE, 0, verts); glBindVertexArray(m_image_vao);
glVertexAttribPointer(m_attr_tex, 2, GL_FLOAT, GL_FALSE, 0, texverts); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glEnableVertexAttribArray(m_attr_pos);
glEnableVertexAttribArray(m_attr_tex);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableVertexAttribArray(m_attr_pos);
glDisableVertexAttribArray(m_attr_tex);
// TODO: implement OSD // TODO: implement OSD
// for (TextData& text : m_text) // for (TextData& text : m_text)

3
Source/Core/VideoBackends/Software/SWOGLWindow.h
View File

@ -41,6 +41,5 @@ private:
bool m_init {false}; bool m_init {false};
u32 m_image_program, m_image_texture; u32 m_image_program, m_image_texture, m_image_vao;
int m_attr_pos, m_attr_tex, m_uni_tex;
}; };