MGislv/GLideN64
1
0
Fork 0
mirror of https://github.com/blawar/GLideN64.git synced 2024-06-24 21:39:35 +00:00
Code Issues Projects Releases Wiki Activity

Make separate vertex shaders for triangles and rects.

Browse Source
This commit is contained in:
Sergey Lipskiy 2016-12-31 19:29:50 +07:00
parent ccde41b7de
commit 599f7b1e93
12 changed files with 182 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/BufferCopy/RDRAMtoColorBuffer.cpp
View File

@ -253,6 +253,7 @@ void RDRAMtoColorBuffer::copyFromRDRAM(u32 _address, bool _bCFB)
const u32 cycleType = gDP.otherMode.cycleType;
gDP.otherMode.cycleType = G_CYC_1CYCLE;
CombinerInfo::get().setPolygonMode(OGLRender::rsTexRect);
CombinerInfo::get().setCombine(EncodeCombineMode(0, 0, 0, TEXEL0, 0, 0, 0, TEXEL0, 0, 0, 0, TEXEL0, 0, 0, 0, TEXEL0));
currentCombiner()->disableBlending();
gDP.otherMode.cycleType = cycleType;

27
src/Combiner.cpp
View File

@ -76,6 +76,7 @@ void Combiner_Init() {
cmbInfo.init();
InitShaderCombiner();
if (cmbInfo.getCombinersNumber() == 0) {
cmbInfo.setPolygonMode(OGLRender::rsTexRect);
gDP.otherMode.cycleType = G_CYC_COPY;
cmbInfo.setCombine(EncodeCombineMode(0, 0, 0, TEXEL0, 0, 0, 0, TEXEL0, 0, 0, 0, TEXEL0, 0, 0, 0, TEXEL0));
gDP.otherMode.cycleType = G_CYC_FILL;
@ -98,14 +99,7 @@ CombinerKey::CombinerKey(u64 _mux)
// High byte of muxs0 is zero. We can use it for addtional combiner flags:
// [0 - 0] polygon type: 0 - triangle, 1 - rect
// [1 - 2] cycle type
u32 flags;
if (gDP.otherMode.cycleType >= G_CYC_COPY) {
flags = 1U;
}
else {
const OGLRender::RENDER_STATE rs = video().getRender().getRenderState();
flags = (rs == OGLRender::rsRect || rs == OGLRender::rsTexRect) ? 1U : 0U;
}
u32 flags = CombinerInfo::get().isRectMode() ? 1U : 0U;
flags |= (gDP.otherMode.cycleType << 1);
m_key.muxs0 |= (flags << 24);
@ -138,7 +132,9 @@ bool CombinerKey::operator<(const CombinerKey & _other) const
bool CombinerKey::isRectKey() const
{
return ((m_key.muxs0 >> 24) & 1) != 0;
// return ((m_key.muxs0 >> 24) & 1) != 0;
bool res = ((m_key.muxs0 >> 24) & 1) != 0;
return res;
}
/*---------------CombinerInfo-------------*/
@ -393,6 +389,19 @@ void CombinerInfo::updateParameters(OGLRender::RENDER_STATE _renderState)
m_pUniformCollection->updateUniforms(m_pCurrent, _renderState);
}
void CombinerInfo::setPolygonMode(OGLRender::RENDER_STATE _renderState)
{
switch (_renderState) {
case OGLRender::rsRect:
case OGLRender::rsTexRect:
m_rectMode = true;
break;
default:
m_rectMode = false;
break;
}
}
#ifndef GLES2
#define SHADER_STORAGE_FOLDER_NAME L"shaders"
static

5
src/Combiner.h
View File

@ -162,10 +162,14 @@ public:
// Update uniforms for GL without UniformBlock support
void updateParameters(OGLRender::RENDER_STATE _renderState);
void setPolygonMode(OGLRender::RENDER_STATE _renderState);
bool isRectMode() const { return m_rectMode; }
private:
CombinerInfo()
: m_bChanged(false)
, m_bShaderCacheSupported(false)
, m_rectMode(true)
, m_shadersLoaded(0)
, m_configOptionsBitSet(0)
, m_pCurrent(nullptr) {}
@ -178,6 +182,7 @@ private:
bool m_bChanged;
bool m_bShaderCacheSupported;
bool m_rectMode;
u32 m_shadersLoaded;
u32 m_configOptionsBitSet;

2
src/GLSLCombiner.h
View File

@ -26,7 +26,7 @@ public:
void updateBlendMode(bool _bForce = false);
void disableBlending();
const CombinerKey & getKey() const { return m_key; }
CombinerKey getKey() const { return m_key; }
bool usesTile(u32 _t) const {
if (_t == 0)

25
src/OGL3X/GLSLCombiner_ogl3x.cpp
View File

@ -22,6 +22,8 @@ using namespace std;
static GLuint g_vertex_shader_object;
static GLuint g_vertex_shader_object_notex;
static GLuint g_vertex_shader_object_rect;
static GLuint g_vertex_shader_object_texrect;
static GLuint g_calc_light_shader_object;
static GLuint g_calc_mipmap_shader_object;
static GLuint g_calc_noise_shader_object;
@ -176,7 +178,7 @@ void InitShadowMapShader()
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, fboFormats.lutInternalFormat, 256, 1, 0, fboFormats.lutFormat, fboFormats.lutType, nullptr);
g_draw_shadow_map_program = createShaderProgram(default_vertex_shader, shadow_map_fragment_shader_float);
g_draw_shadow_map_program = createRectShaderProgram(vertex_shader_rect_nocolor, shadow_map_fragment_shader_float);
}
static
@ -211,6 +213,8 @@ void InitShaderCombiner()
{
g_vertex_shader_object = _createShader(GL_VERTEX_SHADER, vertex_shader);
g_vertex_shader_object_notex = _createShader(GL_VERTEX_SHADER, vertex_shader_notex);
g_vertex_shader_object_texrect = _createShader(GL_VERTEX_SHADER, vertex_shader_texrect);
g_vertex_shader_object_rect = _createShader(GL_VERTEX_SHADER, vertex_shader_rect);
strFragmentShader.reserve(1024*5);
@ -224,7 +228,7 @@ void InitShaderCombiner()
#endif // GLESX
noiseTex.init();
g_monochrome_image_program = createShaderProgram(default_vertex_shader, zelda_monochrome_fragment_shader);
g_monochrome_image_program = createRectShaderProgram(vertex_shader_rect_nocolor, zelda_monochrome_fragment_shader);
glUseProgram(g_monochrome_image_program);
const int texLoc = glGetUniformLocation(g_monochrome_image_program, "uColorImage");
glUniform1i(texLoc, 0);
@ -250,6 +254,10 @@ void DestroyShaderCombiner() {
g_vertex_shader_object = 0;
glDeleteShader(g_vertex_shader_object_notex);
g_vertex_shader_object_notex = 0;
glDeleteShader(g_vertex_shader_object_texrect);
g_vertex_shader_object_texrect = 0;
glDeleteShader(g_vertex_shader_object_rect);
g_vertex_shader_object_rect = 0;
#ifndef GLESX
glDeleteShader(g_calc_light_shader_object);
g_calc_light_shader_object = 0;
@ -451,6 +459,8 @@ ShaderCombiner::ShaderCombiner(Combiner & _color, Combiner & _alpha, const gDPCo
}
#endif // GLESX
// Shader program generation
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
const GLchar * strShaderData = strFragmentShader.data();
glShaderSource(fragmentShader, 1, &strShaderData, nullptr);
@ -461,9 +471,9 @@ ShaderCombiner::ShaderCombiner(Combiner & _color, Combiner & _alpha, const gDPCo
m_program = glCreateProgram();
_locate_attributes();
if (usesTexture())
glAttachShader(m_program, g_vertex_shader_object);
glAttachShader(m_program, m_key.isRectKey() ? g_vertex_shader_object_texrect : g_vertex_shader_object);
else
glAttachShader(m_program, g_vertex_shader_object_notex);
glAttachShader(m_program, m_key.isRectKey() ? g_vertex_shader_object_rect : g_vertex_shader_object_notex);
glAttachShader(m_program, fragmentShader);
#ifndef GLESX
if (bUseHWLight)
@ -561,10 +571,13 @@ void ShaderCombiner::_locateUniforms() {
void ShaderCombiner::_locate_attributes() const {
glBindAttribLocation(m_program, SC_POSITION, "aPosition");
glBindAttribLocation(m_program, SC_COLOR, "aColor");
glBindAttribLocation(m_program, SC_TEXCOORD0, "aTexCoord0");
glBindAttribLocation(m_program, SC_TEXCOORD1, "aTexCoord1");
glBindAttribLocation(m_program, SC_TEXCOORD, "aTexCoord");
glBindAttribLocation(m_program, SC_NUMLIGHTS, "aNumLights");
glBindAttribLocation(m_program, SC_MODIFY, "aModify");
glBindAttribLocation(m_program, SC_RECT_POSITION, "aRectPosition");
glBindAttribLocation(m_program, SC_RECT_COLOR, "aRectColor");
glBindAttribLocation(m_program, SC_TEXCOORD0, "aTexCoord0");
glBindAttribLocation(m_program, SC_TEXCOORD1, "aTexCoord1");
}
void ShaderCombiner::update(bool _bForce) {

144
src/OGL3X/Shaders_ogl3x.h
View File

@ -13,12 +13,10 @@ static const char* vertex_shader =
MAIN_SHADER_VERSION
"in highp vec4 aPosition; \n"
"in lowp vec4 aColor; \n"
"in highp vec2 aTexCoord0; \n"
"in highp vec2 aTexCoord1; \n"
"in highp vec2 aTexCoord; \n"
"in lowp float aNumLights; \n"
"in highp vec4 aModify; \n"
" \n"
"uniform int uRenderState; \n"
"uniform int uTexturePersp; \n"
" \n"
"uniform lowp int uFogUsage; \n"
@ -61,36 +59,30 @@ MAIN_SHADER_VERSION
"{ \n"
" gl_Position = aPosition; \n"
" vShadeColor = aColor; \n"
" if (uRenderState < 3) { \n"
" vec2 texCoord = aTexCoord0; \n"
" texCoord *= uTexScale; \n"
" if (uTexturePersp == 0 && aModify[2] == 0.0) texCoord *= 0.5;\n"
" vTexCoord0 = calcTexCoord(texCoord, 0); \n"
" vTexCoord1 = calcTexCoord(texCoord, 1); \n"
" vLodTexCoord = texCoord; \n"
" vNumLights = aNumLights; \n"
" if (aModify != vec4(0.0)) { \n"
" if ((aModify[0]) != 0.0) { \n"
" gl_Position.xy = gl_Position.xy * uScreenCoordsScale + vec2(-1.0, 1.0); \n"
" gl_Position.xy *= gl_Position.w; \n"
" } \n"
" if ((aModify[1]) != 0.0) \n"
" gl_Position.z *= gl_Position.w; \n"
" if ((aModify[3]) != 0.0) \n"
" vNumLights = 0.0; \n"
" vec2 texCoord = aTexCoord; \n"
" texCoord *= uTexScale; \n"
" if (uTexturePersp == 0 && aModify[2] == 0.0) texCoord *= 0.5;\n"
" vTexCoord0 = calcTexCoord(texCoord, 0); \n"
" vTexCoord1 = calcTexCoord(texCoord, 1); \n"
" vLodTexCoord = texCoord; \n"
" vNumLights = aNumLights; \n"
" if (aModify != vec4(0.0)) { \n"
" if ((aModify[0]) != 0.0) { \n"
" gl_Position.xy = gl_Position.xy * uScreenCoordsScale + vec2(-1.0, 1.0); \n"
" gl_Position.xy *= gl_Position.w; \n"
" } \n"
" if (uFogUsage == 1) { \n"
" lowp float fp; \n"
" if (aPosition.z < -aPosition.w && aModify[1] == 0.0) \n"
" fp = -uFogScale.s + uFogScale.t; \n"
" else \n"
" fp = aPosition.z/aPosition.w*uFogScale.s + uFogScale.t;\n"
" vShadeColor.a = clamp(fp, 0.0, 1.0); \n"
" } \n"
" } else { \n"
" vTexCoord0 = aTexCoord0; \n"
" vTexCoord1 = aTexCoord1; \n"
" vNumLights = 0.0; \n"
" if ((aModify[1]) != 0.0) \n"
" gl_Position.z *= gl_Position.w; \n"
" if ((aModify[3]) != 0.0) \n"
" vNumLights = 0.0; \n"
" } \n"
" if (uFogUsage == 1) { \n"
" lowp float fp; \n"
" if (aPosition.z < -aPosition.w && aModify[1] == 0.0) \n"
" fp = -uFogScale.s + uFogScale.t; \n"
" else \n"
" fp = aPosition.z/aPosition.w*uFogScale.s + uFogScale.t; \n"
" vShadeColor.a = clamp(fp, 0.0, 1.0); \n"
" } \n"
#ifndef GLESX
" gl_ClipDistance[0] = gl_Position.w - gl_Position.z; \n"
@ -105,8 +97,6 @@ MAIN_SHADER_VERSION
"in lowp float aNumLights; \n"
"in highp vec4 aModify; \n"
" \n"
"uniform int uRenderState; \n"
" \n"
"uniform lowp int uFogUsage; \n"
"uniform mediump vec2 uFogScale; \n"
"uniform mediump vec2 uScreenCoordsScale;\n"
@ -118,28 +108,24 @@ MAIN_SHADER_VERSION
"{ \n"
" gl_Position = aPosition; \n"
" vShadeColor = aColor; \n"
" if (uRenderState < 3) { \n"
" vNumLights = aNumLights; \n"
" if (aModify != vec4(0.0)) { \n"
" if ((aModify[0]) != 0.0) { \n"
" gl_Position.xy = gl_Position.xy * uScreenCoordsScale + vec2(-1.0, 1.0); \n"
" gl_Position.xy *= gl_Position.w; \n"
" } \n"
" if ((aModify[1]) != 0.0) \n"
" gl_Position.z *= gl_Position.w; \n"
" if ((aModify[3]) != 0.0) \n"
" vNumLights = 0.0; \n"
" vNumLights = aNumLights; \n"
" if (aModify != vec4(0.0)) { \n"
" if ((aModify[0]) != 0.0) { \n"
" gl_Position.xy = gl_Position.xy * uScreenCoordsScale + vec2(-1.0, 1.0); \n"
" gl_Position.xy *= gl_Position.w; \n"
" } \n"
" if (uFogUsage == 1) { \n"
" lowp float fp; \n"
" if (aPosition.z < -aPosition.w && aModify[1] == 0.0) \n"
" fp = -uFogScale.s + uFogScale.t; \n"
" else \n"
" fp = aPosition.z/aPosition.w*uFogScale.s + uFogScale.t;\n"
" vShadeColor.a = clamp(fp, 0.0, 1.0); \n"
" } \n"
" } else { \n"
" vNumLights = 0.0; \n"
" if ((aModify[1]) != 0.0) \n"
" gl_Position.z *= gl_Position.w; \n"
" if ((aModify[3]) != 0.0) \n"
" vNumLights = 0.0; \n"
" } \n"
" if (uFogUsage == 1) { \n"
" lowp float fp; \n"
" if (aPosition.z < -aPosition.w && aModify[1] == 0.0) \n"
" fp = -uFogScale.s + uFogScale.t; \n"
" else \n"
" fp = aPosition.z/aPosition.w*uFogScale.s + uFogScale.t; \n"
" vShadeColor.a = clamp(fp, 0.0, 1.0); \n"
" } \n"
#ifndef GLESX
" gl_ClipDistance[0] = gl_Position.w - gl_Position.z; \n"
@ -147,6 +133,44 @@ MAIN_SHADER_VERSION
"} \n"
;
static const char* vertex_shader_texrect =
MAIN_SHADER_VERSION
"in highp vec4 aRectPosition; \n"
"in lowp vec4 aRectColor; \n"
"in highp vec2 aTexCoord0; \n"
"in highp vec2 aTexCoord1; \n"
" \n"
"out lowp vec4 vShadeColor; \n"
"out mediump vec2 vTexCoord0; \n"
"out mediump vec2 vTexCoord1; \n"
"void main() \n"
"{ \n"
" gl_Position = aRectPosition; \n"
" vShadeColor = aRectColor; \n"
" vTexCoord0 = aTexCoord0; \n"
" vTexCoord1 = aTexCoord1; \n"
#ifndef GLESX
" gl_ClipDistance[0] = gl_Position.w - gl_Position.z; \n"
#endif
"} \n"
;
static const char* vertex_shader_rect =
MAIN_SHADER_VERSION
"in highp vec4 aRectPosition; \n"
"in lowp vec4 aRectColor; \n"
" \n"
"out lowp vec4 vShadeColor; \n"
"void main() \n"
"{ \n"
" gl_Position = aRectPosition; \n"
" vShadeColor = aRectColor; \n"
#ifndef GLESX
" gl_ClipDistance[0] = gl_Position.w - gl_Position.z; \n"
#endif
"} \n"
;
static const char* fragment_shader_header_common_variables =
MAIN_SHADER_VERSION
"uniform sampler2D uTex0; \n"
@ -675,12 +699,12 @@ MAIN_SHADER_VERSION
;
#endif // GL_IMAGE_TEXTURES_SUPPORT
static const char* default_vertex_shader =
static const char* vertex_shader_rect_nocolor =
MAIN_SHADER_VERSION
"in highp vec4 aPosition; \n"
"in highp vec4 aRectPosition; \n"
"void main() \n"
"{ \n"
" gl_Position = aPosition; \n"
" gl_Position = aRectPosition; \n"
"} \n"
;
@ -726,12 +750,12 @@ MAIN_SHADER_VERSION
const char * strTexrectDrawerVertexShader =
MAIN_SHADER_VERSION
"in highp vec4 aPosition; \n"
"in highp vec4 aRectPosition; \n"
"in highp vec2 aTexCoord0; \n"
"out mediump vec2 vTexCoord0; \n"
"void main() \n"
"{ \n"
" gl_Position = aPosition; \n"
" gl_Position = aRectPosition; \n"
" vTexCoord0 = aTexCoord0; \n"
"} \n"
;

41
src/OpenGL.cpp
View File

@ -412,8 +412,8 @@ void OGLRender::TexrectDrawer::init()
std::string fragmentShader(config.texture.bilinearMode == BILINEAR_STANDARD ? strTexrectDrawerTexBilinearFilter : strTexrectDrawerTex3PointFilter);
fragmentShader += strTexrectDrawerFragmentShaderTex;
m_programTex = createShaderProgram(strTexrectDrawerVertexShader, fragmentShader.c_str());
m_programClean = createShaderProgram(strTexrectDrawerVertexShader, strTexrectDrawerFragmentShaderClean);
m_programTex = createRectShaderProgram(strTexrectDrawerVertexShader, fragmentShader.c_str());
m_programClean = createRectShaderProgram(strTexrectDrawerVertexShader, strTexrectDrawerFragmentShaderClean);
glUseProgram(m_programTex);
GLint loc = glGetUniformLocation(m_programTex, "uTex0");
@ -1160,6 +1160,7 @@ void OGLRender::_updateStates(RENDER_STATE _renderState) const
OGLVideo & ogl = video();
CombinerInfo & cmbInfo = CombinerInfo::get();
cmbInfo.setPolygonMode(_renderState);
cmbInfo.update();
if (gSP.changed & CHANGED_GEOMETRYMODE) {
@ -1238,11 +1239,10 @@ void OGLRender::_setColorArray() const
void OGLRender::_setTexCoordArrays() const
{
if (m_renderState == rsTriangle) {
glDisableVertexAttribArray(SC_TEXCOORD1);
if (currentCombiner()->usesTexture())
glEnableVertexAttribArray(SC_TEXCOORD0);
glEnableVertexAttribArray(SC_TEXCOORD);
else
glDisableVertexAttribArray(SC_TEXCOORD0);
glDisableVertexAttribArray(SC_TEXCOORD);
} else {
if (currentCombiner()->usesTile(0))
glEnableVertexAttribArray(SC_TEXCOORD0);
@ -1296,7 +1296,7 @@ void OGLRender::_prepareDrawTriangle(bool _dma)
glVertexAttribPointer(SC_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(SPVertex), &pVtx->flat_r);
else
glVertexAttribPointer(SC_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(SPVertex), &pVtx->r);
glVertexAttribPointer(SC_TEXCOORD0, 2, GL_FLOAT, GL_FALSE, sizeof(SPVertex), &pVtx->s);
glVertexAttribPointer(SC_TEXCOORD, 2, GL_FLOAT, GL_FALSE, sizeof(SPVertex), &pVtx->s);
if (config.generalEmulation.enableHWLighting) {
glEnableVertexAttribArray(SC_NUMLIGHTS);
glVertexAttribPointer(SC_NUMLIGHTS, 1, GL_BYTE, GL_FALSE, sizeof(SPVertex), &pVtx->HWLight);
@ -1478,8 +1478,6 @@ void OGLRender::drawLine(int _v0, int _v1, float _width)
if (m_renderState != rsLine || CombinerInfo::get().isChanged()) {
_setColorArray();
glDisableVertexAttribArray(SC_TEXCOORD0);
glDisableVertexAttribArray(SC_TEXCOORD1);
glVertexAttribPointer(SC_POSITION, 4, GL_FLOAT, GL_FALSE, sizeof(SPVertex), &triangles.vertices[0].x);
glVertexAttribPointer(SC_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(SPVertex), &triangles.vertices[0].r);
glEnableVertexAttribArray(SC_MODIFY);
@ -1511,15 +1509,12 @@ void OGLRender::drawRect(int _ulx, int _uly, int _lrx, int _lry, float *_pColor)
const bool updateArrays = m_renderState != rsRect;
if (updateArrays || CombinerInfo::get().isChanged()) {
m_renderState = rsRect;
glDisableVertexAttribArray(SC_COLOR);
glDisableVertexAttribArray(SC_TEXCOORD0);
glDisableVertexAttribArray(SC_TEXCOORD1);
glDisableVertexAttribArray(SC_NUMLIGHTS);
glDisableVertexAttribArray(SC_MODIFY);
}
if (updateArrays)
glVertexAttribPointer(SC_POSITION, 4, GL_FLOAT, GL_FALSE, sizeof(GLVertex), &m_rect[0].x);
glVertexAttribPointer(SC_RECT_POSITION, 4, GL_FLOAT, GL_FALSE, sizeof(GLVertex), &m_rect[0].x);
currentCombiner()->updateRenderState();
FrameBuffer * pCurrentBuffer = frameBufferList().getCurrent();
@ -1559,9 +1554,9 @@ void OGLRender::drawRect(int _ulx, int _uly, int _lrx, int _lry, float *_pColor)
}
if (gDP.otherMode.cycleType == G_CYC_FILL)
glVertexAttrib4fv(SC_COLOR, _pColor);
glVertexAttrib4fv(SC_RECT_COLOR, _pColor);
else
glVertexAttrib4f(SC_COLOR, 0.0f, 0.0f, 0.0f, 0.0f);
glVertexAttrib4f(SC_RECT_COLOR, 0.0f, 0.0f, 0.0f, 0.0f);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
gSP.changed |= CHANGED_GEOMETRYMODE | CHANGED_VIEWPORT;
@ -1729,6 +1724,7 @@ void OGLRender::drawTexturedRect(const TexturedRectParams & _params)
gSP.changed &= ~CHANGED_GEOMETRYMODE; // Don't update cull mode
if (!m_texrectDrawer.isEmpty()) {
CombinerInfo & cmbInfo = CombinerInfo::get();
cmbInfo.setPolygonMode(rsTexRect);
cmbInfo.update();
currentCombiner()->updateRenderState();
_updateTextures(rsTexRect);
@ -1743,7 +1739,6 @@ void OGLRender::drawTexturedRect(const TexturedRectParams & _params)
const bool updateArrays = m_renderState != rsTexRect;
if (updateArrays || CombinerInfo::get().isChanged()) {
m_renderState = rsTexRect;
glDisableVertexAttribArray(SC_COLOR);
_setTexCoordArrays();
GLfloat alpha = 0.0f;
@ -1753,18 +1748,16 @@ void OGLRender::drawTexturedRect(const TexturedRectParams & _params)
if (combine.mA0 == G_ACMUX_0 && combine.aA0 == G_ACMUX_SHADE)
alpha = 1.0f;
}
glVertexAttrib4f(SC_COLOR, 0, 0, 0, alpha);
glVertexAttrib4f(SC_RECT_COLOR, 0, 0, 0, alpha);
}
if (updateArrays) {
#ifdef RENDERSTATE_TEST
StateChanges++;
#endif
glVertexAttribPointer(SC_POSITION, 4, GL_FLOAT, GL_FALSE, sizeof(GLVertex), &m_rect[0].x);
glVertexAttribPointer(SC_RECT_POSITION, 4, GL_FLOAT, GL_FALSE, sizeof(GLVertex), &m_rect[0].x);
glVertexAttribPointer(SC_TEXCOORD0, 2, GL_FLOAT, GL_FALSE, sizeof(GLVertex), &m_rect[0].s0);
glVertexAttribPointer(SC_TEXCOORD1, 2, GL_FLOAT, GL_FALSE, sizeof(GLVertex), &m_rect[0].s1);
glDisableVertexAttribArray(SC_NUMLIGHTS);
glDisableVertexAttribArray(SC_MODIFY);
}
currentCombiner()->updateRenderState();
@ -2143,7 +2136,8 @@ void OGLRender::_initStates()
{
glDisable(GL_CULL_FACE);
glEnableVertexAttribArray(SC_POSITION);
glEnable( GL_DEPTH_TEST );
glEnableVertexAttribArray(SC_RECT_POSITION);
glEnable(GL_DEPTH_TEST);
glDepthFunc( GL_ALWAYS );
glDepthMask( GL_FALSE );
glEnable( GL_SCISSOR_TEST );
@ -2202,7 +2196,7 @@ void OGLRender::_initData()
triangles.num = 0;
#ifdef NO_BLIT_BUFFER_COPY
m_programCopyTex = createShaderProgram(strTexrectDrawerVertexShader, strTextureCopyShader);
m_programCopyTex = createRectShaderProgram(strTexrectDrawerVertexShader, strTextureCopyShader);
glUseProgram(m_programCopyTex);
GLint loc = glGetUniformLocation(m_programCopyTex, "uTex0");
assert(loc >= 0);
@ -2256,12 +2250,9 @@ void OGLRender::copyTexturedRect(GLint _srcX0, GLint _srcY0, GLint _srcX1, GLint
GLint _dstX0, GLint _dstY0, GLint _dstX1, GLint _dstY1,
GLuint _dstWidth, GLuint _dstHeight, GLenum _filter)
{
glDisableVertexAttribArray(SC_COLOR);
glDisableVertexAttribArray(SC_TEXCOORD1);
glDisableVertexAttribArray(SC_NUMLIGHTS);
glDisableVertexAttribArray(SC_MODIFY);
glEnableVertexAttribArray(SC_TEXCOORD0);
glVertexAttribPointer(SC_POSITION, 4, GL_FLOAT, GL_FALSE, sizeof(GLVertex), &m_rect[0].x);
glVertexAttribPointer(SC_RECT_POSITION, 4, GL_FLOAT, GL_FALSE, sizeof(GLVertex), &m_rect[0].x);
glVertexAttribPointer(SC_TEXCOORD0, 2, GL_FLOAT, GL_FALSE, sizeof(GLVertex), &m_rect[0].s0);
glUseProgram(m_programCopyTex);

70
src/PostProcessor.cpp
View File

@ -30,20 +30,20 @@ PostProcessor PostProcessor::processor;
static const char * vertexShader =
SHADER_VERSION
"#if (__VERSION__ > 120) \n"
"# define IN in \n"
"# define OUT out \n"
"#else \n"
"# define IN attribute \n"
"# define OUT varying \n"
"#endif // __VERSION \n"
"IN highp vec2 aPosition; \n"
"IN highp vec2 aTexCoord; \n"
"OUT mediump vec2 vTexCoord; \n"
"void main(){ \n"
"gl_Position = vec4(aPosition.x, aPosition.y, 0.0, 1.0);\n"
"vTexCoord = aTexCoord; \n"
"} \n"
"#if (__VERSION__ > 120) \n"
"# define IN in \n"
"# define OUT out \n"
"#else \n"
"# define IN attribute \n"
"# define OUT varying \n"
"#endif // __VERSION \n"
"IN highp vec2 aRectPosition; \n"
"IN highp vec2 aTexCoord0; \n"
"OUT mediump vec2 vTexCoord; \n"
"void main() { \n"
"gl_Position = vec4(aRectPosition.x, aRectPosition.y, 0.0, 1.0);\n"
"vTexCoord = aTexCoord0; \n"
"} \n"
;
static const char* extractBloomShader =
@ -263,31 +263,6 @@ FRAGMENT_SHADER_END
"} \n"
;
static
GLuint _createShaderProgram(const char * _strVertex, const char * _strFragment)
{
GLuint vertex_shader_object = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader_object, 1, &_strVertex, nullptr);
glCompileShader(vertex_shader_object);
assert(checkShaderCompileStatus(vertex_shader_object));
GLuint fragment_shader_object = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader_object, 1, &_strFragment, nullptr);
glCompileShader(fragment_shader_object);
assert(checkShaderCompileStatus(fragment_shader_object));
GLuint program = glCreateProgram();
glBindAttribLocation(program, SC_POSITION, "aPosition");
glBindAttribLocation(program, SC_TEXCOORD0, "aTexCoord");
glAttachShader(program, vertex_shader_object);
glAttachShader(program, fragment_shader_object);
glLinkProgram(program);
glDeleteShader(vertex_shader_object);
glDeleteShader(fragment_shader_object);
assert(checkProgramLinkStatus(program));
return program;
}
static
void _initTexture(CachedTexture * pTexture)
{
@ -362,7 +337,7 @@ void PostProcessor::_initCommon()
void PostProcessor::_initGammaCorrection()
{
m_gammaCorrectionProgram = _createShaderProgram(vertexShader, gammaCorrectionShader);
m_gammaCorrectionProgram = createRectShaderProgram(vertexShader, gammaCorrectionShader);
glUseProgram(m_gammaCorrectionProgram);
int loc = glGetUniformLocation(m_gammaCorrectionProgram, "Sample0");
assert(loc >= 0);
@ -376,7 +351,7 @@ void PostProcessor::_initGammaCorrection()
void PostProcessor::_initBlur()
{
m_extractBloomProgram = _createShaderProgram(vertexShader, extractBloomShader);
m_extractBloomProgram = createRectShaderProgram(vertexShader, extractBloomShader);
glUseProgram(m_extractBloomProgram);
int loc = glGetUniformLocation(m_extractBloomProgram, "Sample0");
assert(loc >= 0);
@ -385,7 +360,7 @@ void PostProcessor::_initBlur()
assert(loc >= 0);
glUniform1i(loc, config.bloomFilter.thresholdLevel);
m_seperableBlurProgram = _createShaderProgram(vertexShader, seperableBlurShader);
m_seperableBlurProgram = createRectShaderProgram(vertexShader, seperableBlurShader);
glUseProgram(m_seperableBlurProgram);
loc = glGetUniformLocation(m_seperableBlurProgram, "Sample0");
assert(loc >= 0);
@ -406,7 +381,7 @@ void PostProcessor::_initBlur()
assert(loc >= 0);
glUniform1f(loc, config.bloomFilter.blurStrength/100.0f);
m_glowProgram = _createShaderProgram(vertexShader, glowShader);
m_glowProgram = createRectShaderProgram(vertexShader, glowShader);
glUseProgram(m_glowProgram);
loc = glGetUniformLocation(m_glowProgram, "Sample0");
assert(loc >= 0);
@ -429,7 +404,7 @@ void PostProcessor::_initBlur()
void PostProcessor::_initOrientationCorrection()
{
m_orientationCorrectionProgram = _createShaderProgram(vertexShader, orientationCorrectionShader);
m_orientationCorrectionProgram = createRectShaderProgram(vertexShader, orientationCorrectionShader);
glUseProgram(m_orientationCorrectionProgram);
int loc = glGetUniformLocation(m_orientationCorrectionProgram, "Sample0");
assert(loc >= 0);
@ -534,14 +509,9 @@ void PostProcessor::_setGLState() {
+1.0, +1.0, +1.0, +1.0
};
glEnableVertexAttribArray(SC_POSITION);
glVertexAttribPointer(SC_POSITION, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (float*)vert);
glVertexAttribPointer(SC_RECT_POSITION, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (float*)vert);
glEnableVertexAttribArray(SC_TEXCOORD0);
glVertexAttribPointer(SC_TEXCOORD0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (float*)vert + 2);
glDisableVertexAttribArray(SC_COLOR);
glDisableVertexAttribArray(SC_TEXCOORD1);
glDisableVertexAttribArray(SC_NUMLIGHTS);
glDisableVertexAttribArray(SC_MODIFY);
glViewport(0, 0, video().getWidth(), video().getHeight());
glScissor(0, 0, m_pResultBuffer->m_pTexture->realWidth, m_pResultBuffer->m_pTexture->realHeight);
gSP.changed |= CHANGED_VIEWPORT;

4
src/ShaderUtils.cpp
View File

@ -56,7 +56,7 @@ void logErrorShader(GLenum _shaderType, const std::string & _strShader)
}
}
GLuint createShaderProgram(const char * _strVertex, const char * _strFragment)
GLuint createRectShaderProgram(const char * _strVertex, const char * _strFragment)
{
GLuint vertex_shader_object = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader_object, 1, &_strVertex, nullptr);
@ -75,7 +75,7 @@ GLuint createShaderProgram(const char * _strVertex, const char * _strFragment)
logErrorShader(GL_VERTEX_SHADER, _strFragment);
GLuint program = glCreateProgram();
glBindAttribLocation(program, SC_POSITION, "aPosition");
glBindAttribLocation(program, SC_RECT_POSITION, "aRectPosition");
glBindAttribLocation(program, SC_TEXCOORD0, "aTexCoord0");
glBindAttribLocation(program, SC_TEXCOORD1, "aTexCoord1");
glAttachShader(program, vertex_shader_object);

2
src/ShaderUtils.h
View File

@ -4,7 +4,7 @@
#include "OpenGL.h"
#include "Combiner.h"
GLuint createShaderProgram(const char * _strVertex, const char * _strFragment);
GLuint createRectShaderProgram(const char * _strVertex, const char * _strFragment);
bool checkShaderCompileStatus(GLuint obj);
bool checkProgramLinkStatus(GLuint obj);
void logErrorShader(GLenum _shaderType, const std::string & _strShader);

16
src/TextDrawer.cpp
View File

@ -63,12 +63,12 @@ SHADER_VERSION
"# define IN attribute \n"
"# define OUT varying \n"
"#endif // __VERSION \n"
"IN highp vec4 aPosition; \n"
"OUT mediump vec2 texpos; \n"
"void main(void) { \n"
" gl_Position = vec4(aPosition.xy, 0, 1); \n"
" texpos = aPosition.zw; \n"
"} \n"
"IN highp vec4 aRectPosition; \n"
"OUT mediump vec2 texpos; \n"
"void main(void) { \n"
" gl_Position = vec4(aRectPosition.xy, 0, 1); \n"
" texpos = aRectPosition.zw; \n"
"} \n"
;
static
@ -267,7 +267,7 @@ void TextDrawer::init()
return;
}
m_program = createShaderProgram(strDrawTextVertexShader, strDrawTextFragmentShader);
m_program = createRectShaderProgram(strDrawTextVertexShader, strDrawTextFragmentShader);
if(m_program == 0)
return;
@ -340,7 +340,7 @@ void TextDrawer::renderText(const char *_pText, float _x, float _y) const
/* Set up the VBO for our vertex data */
glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
glVertexAttribPointer(SC_POSITION, 4, GL_FLOAT, GL_FALSE, 0, 0);
glVertexAttribPointer(SC_RECT_POSITION, 4, GL_FLOAT, GL_FALSE, 0, 0);
std::vector<point> coords(6 * strlen(_pText));
int c = 0;

11
src/gSP.h
View File

@ -35,10 +35,13 @@
#define SC_POSITION 1
#define SC_COLOR 2
#define SC_TEXCOORD0 3
#define SC_TEXCOORD1 4
#define SC_NUMLIGHTS 5
#define SC_MODIFY 6
#define SC_TEXCOORD 3
#define SC_NUMLIGHTS 4
#define SC_MODIFY 5
#define SC_RECT_POSITION 6
#define SC_RECT_COLOR 7
#define SC_TEXCOORD0 8
#define SC_TEXCOORD1 9
struct SPVertex
{