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

Rewrite OpenGL functionality using GLES2 compatible functions.

Browse Source
This commit is contained in:
Sergey Lipskiy 2014-05-21 19:43:22 +07:00
parent 6bac605fe2
commit a3d740ff23
7 changed files with 981 additions and 761 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Combiner.cpp
View File

@ -135,6 +135,17 @@ void Combiner_UpdateAlphaTestInfo()
combiner.current->compiled->UpdateAlphaTestInfo();
}
void Combiner_UpdateTextureInfo()
{
if (combiner.current != NULL)
combiner.current->compiled->UpdateTextureInfo();
}
void Combiner_UpdateRenderState() {
if (combiner.current != NULL)
combiner.current->compiled->UpdateRenderState();
}
void Combiner_SimplifyCycle( CombineCycle *cc, CombinerStage *stage )
{
// Load the first operand
@ -306,6 +317,10 @@ DWORD64 Combiner_EncodeCombineMode( WORD saRGB0, WORD sbRGB0, WORD mRGB0, WORD a
void Combiner_SelectCombine( u64 mux )
{
if (combiner.current != NULL && combiner.current->combine.mux == mux) {
combiner.changed = false;
return;
}
CachedCombiner *current = combiner.root;
CachedCombiner *parent = current;
@ -334,6 +349,7 @@ void Combiner_SelectCombine( u64 mux )
}
combiner.current = current;
combiner.changed = true;
gDP.changed |= CHANGED_COMBINE_COLORS;
}

18
Combiner.h
View File

@ -114,10 +114,12 @@ struct CombineCycle
class OGLCombiner {
public:
virtual void Set() = 0;
virtual void UpdateColors() = 0;
virtual void UpdateFBInfo() = 0;
virtual void UpdateDepthInfo() = 0;
virtual void UpdateAlphaTestInfo() = 0;
virtual void UpdateColors(bool _bForce = false) = 0;
virtual void UpdateFBInfo(bool _bForce = false) = 0;
virtual void UpdateDepthInfo(bool _bForce = false) = 0;
virtual void UpdateAlphaTestInfo(bool _bForce = false) = 0;
virtual void UpdateTextureInfo(bool _bForce = false) = 0;
virtual void UpdateRenderState(bool _bForce = false) = 0;
};
struct CachedCombiner
@ -137,7 +139,11 @@ extern struct CombinerInfo
CachedCombiner *root, *current;
BOOL usesT0, usesT1, usesLOD;
bool usesT0, usesT1, usesLOD, usesShadeColor, changed;
CombinerInfo() :
root(NULL), current(NULL), usesT0(false), usesT1(false),
usesShadeColor(false), changed(false) {}
} combiner;
#define SetConstant( constant, color, alpha ) \
@ -210,6 +216,8 @@ void Combiner_UpdateCombineColors();
void Combiner_UpdateCombineFBInfo();
void Combiner_UpdateCombineDepthInfo();
void Combiner_UpdateAlphaTestInfo();
void Combiner_UpdateTextureInfo();
void Combiner_UpdateRenderState();
void Combiner_SetCombine( u64 mux );
void Combiner_Destroy();

329
GLSLCombiner.cpp
View File

@ -51,6 +51,7 @@ bool check_shader_compile_status(GLuint obj)
GLchar shader_log[nShaderLogSize];
GLsizei nLogSize = nShaderLogSize;
glGetShaderInfoLog(obj, nShaderLogSize, &nLogSize, shader_log);
shader_log[nLogSize] = 0;
display_warning(shader_log);
return false;
}
@ -215,22 +216,22 @@ const char *ColorInput_1cycle[] = {
"combined_color.rgb",
"readtex0.rgb",
"readtex1.rgb",
"prim_color.rgb",
"uPrimColor.rgb",
"vec_color.rgb",
"env_color.rgb",
"center_color.rgb",
"scale_color.rgb",
"uEnvColor.rgb",
"uCenterColor.rgb",
"uScaleColor.rgb",
"combined_color.a",
"readtex0.a",
"readtex1.a",
"prim_color.a",
"uPrimColor.a",
"vec_color.a",
"env_color.a",
"uEnvColor.a",
"lod_frac", // TODO: emulate lod_fraction
"vec3(prim_lod)",
"vec3(uPrimLod)",
"vec3(0.5 + 0.5*snoise(noiseCoord2D))",
"vec3(k4)",
"vec3(k5)",
"vec3(uK4)",
"vec3(uK5)",
"vec3(1.0)",
"vec3(0.0)"
};
@ -239,22 +240,22 @@ const char *ColorInput_2cycle[] = {
"combined_color.rgb",
"readtex1.rgb",
"readtex0.rgb",
"prim_color.rgb",
"uPrimColor.rgb",
"vec_color.rgb",
"env_color.rgb",
"center_color.rgb",
"scale_color.rgb",
"uEnvColor.rgb",
"uCenterColor.rgb",
"uScaleColor.rgb",
"combined_color.a",
"readtex1.a",
"readtex0.a",
"prim_color.a",
"uPrimColor.a",
"vec_color.a",
"env_color.a",
"uEnvColor.a",
"lod_frac", // TODO: emulate lod_fraction
"vec3(prim_lod)",
"vec3(uPrimLod)",
"vec3(0.5 + 0.5*snoise(noiseCoord2D))",
"vec3(k4)",
"vec3(k5)",
"vec3(uK4)",
"vec3(uK5)",
"vec3(1.0)",
"vec3(0.0)"
};
@ -263,22 +264,22 @@ const char *AlphaInput_1cycle[] = {
"combined_color.a",
"readtex0.a",
"readtex1.a",
"prim_color.a",
"uPrimColor.a",
"vec_color.a",
"env_color.a",
"center_color.a",
"scale_color.a",
"uEnvColor.a",
"uCenterColor.a",
"uScaleColor.a",
"combined_color.a",
"readtex0.a",
"readtex1.a",
"prim_color.a",
"uPrimColor.a",
"vec_color.a",
"env_color.a",
"lod_frac", // TODO: emulate lod_fraction
"prim_lod",
"uEnvColor.a",
"lod_frac",
"uPrimLod",
"1.0",
"k4",
"k5",
"uK4",
"uK5",
"1.0",
"0.0"
};
@ -287,22 +288,22 @@ const char *AlphaInput_2cycle[] = {
"combined_color.a",
"readtex1.a",
"readtex0.a",
"prim_color.a",
"uPrimColor.a",
"vec_color.a",
"env_color.a",
"center_color.a",
"scale_color.a",
"uEnvColor.a",
"uCenterColor.a",
"uScaleColor.a",
"combined_color.a",
"readtex1.a",
"readtex0.a",
"prim_color.a",
"uPrimColor.a",
"vec_color.a",
"env_color.a",
"lod_frac", // TODO: emulate lod_fraction
"prim_lod",
"uEnvColor.a",
"lod_frac",
"uPrimLod",
"1.0",
"k4",
"k5",
"uK4",
"uK5",
"1.0",
"0.0"
};
@ -391,7 +392,7 @@ GLSLCombiner::GLSLCombiner(Combiner *_color, Combiner *_alpha) {
strcat(fragment_shader, fragment_shader_header_main);
const bool bUseLod = (m_nInputs & (1<<LOD_FRACTION)) > 0;
if (bUseLod)
strcat(fragment_shader, " float lod_frac = calc_lod(prim_lod, 255.0*vec2(secondary_color.g, secondary_color.b)); \n");
strcat(fragment_shader, " float lod_frac = calc_lod(uPrimLod, vLodTexCoord); \n");
if ((m_nInputs & ((1<<TEXEL0)|(1<<TEXEL1)|(1<<TEXEL0_ALPHA)|(1<<TEXEL1_ALPHA))) > 0) {
strcat(fragment_shader, fragment_shader_readtex0color);
strcat(fragment_shader, fragment_shader_readtex1color);
@ -399,10 +400,10 @@ GLSLCombiner::GLSLCombiner(Combiner *_color, Combiner *_alpha) {
assert(strstr(strCombiner, "readtex") == 0);
}
if (OGL.bHWLighting)
strcat(fragment_shader, " float intensity = calc_light(int(secondary_color.r), input_color); \n");
strcat(fragment_shader, " float intensity = calc_light(int(vNumLights), vShadeColor.rgb, input_color); \n");
else
strcat(fragment_shader, " input_color = gl_Color.rgb;\n");
strcat(fragment_shader, " vec_color = vec4(input_color, gl_Color.a); \n");
strcat(fragment_shader, " input_color = vShadeColor.rgb;\n");
strcat(fragment_shader, " vec_color = vec4(input_color, vShadeColor.a); \n");
strcat(fragment_shader, strCombiner);
strcat(fragment_shader, " gl_FragColor = vec4(color2, alpha2); \n");
@ -417,8 +418,8 @@ GLSLCombiner::GLSLCombiner(Combiner *_color, Combiner *_alpha) {
#ifdef USE_TOONIFY
strcat(fragment_shader, " toonify(intensity); \n");
#endif
strcat(fragment_shader, " if (fog_enabled > 0) \n");
strcat(fragment_shader, " gl_FragColor = vec4(mix(gl_Fog.color.rgb, gl_FragColor.rgb, gl_FogFragCoord), gl_FragColor.a); \n");
strcat(fragment_shader, " if (uEnableFog > 0) \n");
strcat(fragment_shader, " gl_FragColor = vec4(mix(gl_FragColor.rgb, uFogColor.rgb, gl_FogFragCoord), gl_FragColor.a); \n");
strcat(fragment_shader, fragment_shader_end);
@ -436,12 +437,11 @@ GLSLCombiner::GLSLCombiner(Combiner *_color, Combiner *_alpha) {
u32 uShaderIdx = 0;
m_program = glCreateProgram();
_locate_attributes();
glAttachShader(m_program, g_vertex_shader_object);
m_aShaders[uShaderIdx++] = g_vertex_shader_object;
glAttachShader(m_program, fragmentShader);
m_aShaders[uShaderIdx++] = fragmentShader;
glAttachShader(m_program, g_calc_depth_shader_object);
m_aShaders[uShaderIdx++] = g_calc_depth_shader_object;
if (OGL.bHWLighting) {
glAttachShader(m_program, g_calc_light_shader_object);
m_aShaders[uShaderIdx++] = g_calc_light_shader_object;
@ -461,6 +461,7 @@ GLSLCombiner::GLSLCombiner(Combiner *_color, Combiner *_alpha) {
assert(uShaderIdx <= sizeof(m_aShaders)/sizeof(m_aShaders[0]));
glLinkProgram(m_program);
assert(check_program_link_status(m_program));
_locateUniforms();
}
GLSLCombiner::~GLSLCombiner() {
@ -473,10 +474,75 @@ GLSLCombiner::~GLSLCombiner() {
glDeleteProgram(m_program);
}
#define LocateUniform(A) \
m_uniforms.A.loc = glGetUniformLocation(m_program, #A);
void GLSLCombiner::_locateUniforms() {
LocateUniform(uTex0);
LocateUniform(uTex1);
LocateUniform(uTlutImage);
LocateUniform(uZlutImage);
LocateUniform(uDepthImage);
LocateUniform(uEnableFog);
LocateUniform(uEnableDither);
LocateUniform(uEnableLod);
LocateUniform(uEnableAlphaTest);
LocateUniform(uEnableDepth);
LocateUniform(uEnableDepthCompare)
LocateUniform(uEnableDepthUpdate);
LocateUniform(uDepthMode);
LocateUniform(uFb8Bit);
LocateUniform(uFbFixedAlpha);
LocateUniform(uMaxTile)
LocateUniform(uTextureDetail);
LocateUniform(uTexturePersp);
LocateUniform(uFogMultiplier);
LocateUniform(uFogOffset);
LocateUniform(uK4);
LocateUniform(uK5);
LocateUniform(uPrimLod);
LocateUniform(uNoiseTime);
LocateUniform(uLodXScale);
LocateUniform(uLodYScale);
LocateUniform(uMinLod);
LocateUniform(uDepthTrans);
LocateUniform(uDepthScale);
LocateUniform(uAlphaTestValue);
LocateUniform(uEnvColor);
LocateUniform(uPrimColor);
LocateUniform(uFogColor);
LocateUniform(uCenterColor);
LocateUniform(uScaleColor);
LocateUniform(uRenderState);
LocateUniform(uTexScale);
LocateUniform(uTexOffset[0]);
LocateUniform(uTexOffset[1]);
LocateUniform(uCacheShiftScale[0]);
LocateUniform(uCacheShiftScale[1]);
LocateUniform(uCacheScale[0]);
LocateUniform(uCacheScale[1]);
LocateUniform(uCacheOffset[0]);
LocateUniform(uCacheOffset[1]);
}
void GLSLCombiner::_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_STSCALED, "aSTScaled");
glBindAttribLocation(m_program, SC_NUMLIGHTS, "aNumLights");
}
void GLSLCombiner::Set() {
combiner.usesT0 = FALSE;
combiner.usesT1 = FALSE;
combiner.usesLOD = (m_nInputs & (1<<LOD_FRACTION)) > 0 ? TRUE : FALSE;
combiner.usesT0 = (m_nInputs & ((1<<TEXEL0)|(1<<TEXEL0_ALPHA))) != 0;
combiner.usesT1 = (m_nInputs & ((1<<TEXEL1)|(1<<TEXEL1_ALPHA))) != 0;
combiner.usesLOD = (m_nInputs & (1<<LOD_FRACTION)) != 0;
combiner.usesShadeColor = (m_nInputs & ((1<<SHADE)|(1<<SHADE_ALPHA))) != 0;
combiner.vertex.color = COMBINED;
combiner.vertex.alpha = COMBINED;
@ -484,68 +550,93 @@ void GLSLCombiner::Set() {
glUseProgram(m_program);
int texture0_location = glGetUniformLocation(m_program, "texture0");
if (texture0_location != -1) {
glUniform1i(texture0_location, 0);
combiner.usesT0 = TRUE;
}
_setIUniform(m_uniforms.uTex0, 0, true);
_setIUniform(m_uniforms.uTex1, 1, true);
int texture1_location = glGetUniformLocation(m_program, "texture1");
if (texture1_location != -1) {
glUniform1i(texture1_location, 1);
combiner.usesT1 = TRUE;
}
UpdateColors();
UpdateAlphaTestInfo();
UpdateRenderState(true);
UpdateColors(true);
UpdateTextureInfo(true);
UpdateAlphaTestInfo(true);
UpdateDepthInfo(true);
}
void GLSLCombiner::UpdateColors() {
int prim_color_location = glGetUniformLocation(m_program, "prim_color");
glUniform4f(prim_color_location, gDP.primColor.r, gDP.primColor.g, gDP.primColor.b, gDP.primColor.a);
void GLSLCombiner::UpdateRenderState(bool _bForce) {
_setIUniform(m_uniforms.uRenderState, OGL.renderState, _bForce);
}
int env_color_location = glGetUniformLocation(m_program, "env_color");
glUniform4f(env_color_location, gDP.envColor.r, gDP.envColor.g, gDP.envColor.b, gDP.envColor.a);
int prim_lod_location = glGetUniformLocation(m_program, "prim_lod");
glUniform1f(prim_lod_location, gDP.primColor.l);
void GLSLCombiner::UpdateColors(bool _bForce) {
_setV4Uniform(m_uniforms.uEnvColor, &gDP.envColor.r, _bForce);
_setV4Uniform(m_uniforms.uPrimColor, &gDP.primColor.r, _bForce);
_setFUniform(m_uniforms.uPrimLod, gDP.primColor.l, _bForce);
_setV4Uniform(m_uniforms.uFogColor, &gDP.fogColor.r, _bForce);
_setV4Uniform(m_uniforms.uCenterColor, &gDP.key.center.r, _bForce);
_setV4Uniform(m_uniforms.uScaleColor, &gDP.key.scale.r, _bForce);
_setIUniform(m_uniforms.uEnableFog, (OGL.fog && (gSP.geometryMode & G_FOG) != 0), _bForce);
_setFUniform(m_uniforms.uFogMultiplier, (float)gSP.fog.multiplier / 255.0f, _bForce);
_setFUniform(m_uniforms.uFogOffset, (float)gSP.fog.offset / 255.0f, _bForce);
_setFUniform(m_uniforms.uK4, gDP.convert.k4, _bForce);
_setFUniform(m_uniforms.uK5, gDP.convert.k5, _bForce);
if (combiner.usesLOD) {
BOOL bCalcLOD = gDP.otherMode.textureLOD == G_TL_LOD;
int lod_en_location = glGetUniformLocation(m_program, "lod_enabled");
glUniform1i(lod_en_location, bCalcLOD);
if (bCalcLOD) {
int scale_x_location = glGetUniformLocation(m_program, "lod_x_scale");
glUniform1f(scale_x_location, OGL.scaleX);
int scale_y_location = glGetUniformLocation(m_program, "lod_y_scale");
glUniform1f(scale_y_location, OGL.scaleY);
int min_lod_location = glGetUniformLocation(m_program, "min_lod");
glUniform1f(min_lod_location, gDP.primColor.m);
int max_tile_location = glGetUniformLocation(m_program, "max_tile");
glUniform1i(max_tile_location, gSP.texture.level);
int texture_detail_location = glGetUniformLocation(m_program, "texture_detail");
glUniform1i(texture_detail_location, gDP.otherMode.textureDetail);
int uCalcLOD = gDP.otherMode.textureLOD == G_TL_LOD ? 1 : 0;
_setIUniform(m_uniforms.uEnableLod, uCalcLOD, _bForce);
if (uCalcLOD) {
_setFUniform(m_uniforms.uLodXScale, OGL.scaleX, _bForce);
_setFUniform(m_uniforms.uLodYScale, OGL.scaleY, _bForce);
_setFUniform(m_uniforms.uMinLod, gDP.primColor.m, _bForce);
_setIUniform(m_uniforms.uMaxTile, gSP.texture.level, _bForce);
_setIUniform(m_uniforms.uTextureDetail, gDP.otherMode.textureDetail, _bForce);
}
}
int nDither = (gDP.otherMode.alphaCompare == 3 && (gDP.otherMode.colorDither == 2 || gDP.otherMode.alphaDither == 2)) ? 1 : 0;
int dither_location = glGetUniformLocation(m_program, "dither_enabled");
glUniform1i(dither_location, nDither);
_setIUniform(m_uniforms.uEnableDither, nDither, _bForce);
if ((m_nInputs & (1<<NOISE)) + nDither > 0) {
int time_location = glGetUniformLocation(m_program, "time");
glUniform1f(time_location, (float)(rand()&255));
}
if ((m_nInputs & (1<<NOISE)) + nDither > 0)
_setFUniform(m_uniforms.uNoiseTime, (float)(rand()&255), _bForce);
int fog_location = glGetUniformLocation(m_program, "fog_enabled");
glUniform1i(fog_location, (gSP.geometryMode & G_FOG) > 0 ? 1 : 0);
int fb8bit_location = glGetUniformLocation(m_program, "fb_8bit_mode");
glUniform1i(fb8bit_location, 0);
_setIUniform(m_uniforms.uEnableFog, (gSP.geometryMode & G_FOG) > 0 ? 1 : 0, _bForce);
if (!_bForce)
return;
_setIUniform(m_uniforms.uFb8Bit, 0, _bForce);
_setIUniform(m_uniforms.uFbFixedAlpha, 0, _bForce);
_setIUniform(m_uniforms.uEnableDepth, 0, _bForce);
}
void GLSLCombiner::UpdateFBInfo() {
void GLSLCombiner::UpdateTextureInfo(bool _bForce) {
_setIUniform(m_uniforms.uTexturePersp, gDP.otherMode.texturePersp, _bForce);
_setV2Uniform(m_uniforms.uTexScale, gSP.texture.scales, gSP.texture.scalet, _bForce);
if (combiner.usesT0)
{
if (gSP.textureTile[0])
{
_setV2Uniform(m_uniforms.uTexOffset[0], gSP.textureTile[0]->fuls, gSP.textureTile[0]->fult, _bForce);
}
if (cache.current[0])
{
_setV2Uniform(m_uniforms.uCacheShiftScale[0], cache.current[0]->shiftScaleS, cache.current[0]->shiftScaleT, _bForce);
_setV2Uniform(m_uniforms.uCacheScale[0], cache.current[0]->scaleS, cache.current[0]->scaleT, _bForce);
_setV2Uniform(m_uniforms.uCacheOffset[0], cache.current[0]->offsetS, cache.current[0]->offsetT, _bForce);
}
}
if (combiner.usesT1)
{
if (gSP.textureTile[1])
{
_setV2Uniform(m_uniforms.uTexOffset[1], gSP.textureTile[1]->fuls, gSP.textureTile[1]->fult, _bForce);
}
if (cache.current[1])
{
_setV2Uniform(m_uniforms.uCacheShiftScale[1], cache.current[1]->shiftScaleS, cache.current[1]->shiftScaleT, _bForce);
_setV2Uniform(m_uniforms.uCacheScale[1], cache.current[1]->scaleS, cache.current[1]->scaleT, _bForce);
_setV2Uniform(m_uniforms.uCacheOffset[1], cache.current[1]->offsetS, cache.current[1]->offsetT, _bForce);
}
}
}
void GLSLCombiner::UpdateFBInfo(bool _bForce) {
int nFb8bitMode = 0, nFbFixedAlpha = 0;
if (cache.current[0] != NULL && cache.current[0]->frameBufferTexture == TRUE) {
if (cache.current[0]->size == G_IM_SIZ_8b) {
@ -561,51 +652,39 @@ void GLSLCombiner::UpdateFBInfo() {
nFbFixedAlpha |= 2;
}
}
int fb8bit_location = glGetUniformLocation(m_program, "fb_8bit_mode");
glUniform1i(fb8bit_location, nFb8bitMode);
int fbFixedAlpha_location = glGetUniformLocation(m_program, "fb_fixed_alpha");
glUniform1i(fbFixedAlpha_location, nFbFixedAlpha);
_setIUniform(m_uniforms.uFb8Bit, nFb8bitMode, _bForce);
_setIUniform(m_uniforms.uFbFixedAlpha, nFbFixedAlpha, _bForce);
}
void GLSLCombiner::UpdateDepthInfo() {
void GLSLCombiner::UpdateDepthInfo(bool _bForce) {
if (!OGL.bImageTexture)
return;
if (frameBuffer.top == NULL || frameBuffer.top->pDepthBuffer == NULL)
return;
int nDepthEnabled = (gSP.geometryMode & G_ZBUFFER) > 0 ? 1 : 0;
int depth_enabled_location = glGetUniformLocation(m_program, "depthEnabled");
glUniform1i(depth_enabled_location, nDepthEnabled);
const int nDepthEnabled = (gSP.geometryMode & G_ZBUFFER) > 0 ? 1 : 0;
_setIUniform(m_uniforms.uEnableDepth, nDepthEnabled, _bForce);
if (nDepthEnabled == 0)
return;
const int depth_mode_location = glGetUniformLocation(m_program, "depthMode");
glUniform1i(depth_mode_location, gDP.otherMode.depthMode);
const int depth_compare_location = glGetUniformLocation(m_program, "depthCompareEnabled");
glUniform1i(depth_compare_location, gDP.otherMode.depthCompare);
const int depth_update_location = glGetUniformLocation(m_program, "depthUpdateEnabled");
glUniform1i(depth_update_location, gDP.otherMode.depthUpdate);
const int depth_scale_location = glGetUniformLocation(m_program, "depthScale");
glUniform1f(depth_scale_location, gSP.viewport.vscale[2]*32768);
const int depth_trans_location = glGetUniformLocation(m_program, "depthTrans");
glUniform1f(depth_trans_location, gSP.viewport.vtrans[2]*32768);
GLuint texture = frameBuffer.top->pDepthBuffer->depth_texture->glName;
_setIUniform(m_uniforms.uDepthMode, gDP.otherMode.depthMode, _bForce);
_setIUniform(m_uniforms.uEnableDepthCompare, gDP.otherMode.depthCompare, _bForce);
_setIUniform(m_uniforms.uEnableDepthUpdate, gDP.otherMode.depthUpdate, _bForce);
_setFUniform(m_uniforms.uDepthScale, gSP.viewport.vscale[2]*32768.0f, _bForce);
_setFUniform(m_uniforms.uDepthTrans, gSP.viewport.vtrans[2]*32768.0f, _bForce);
}
void GLSLCombiner::UpdateAlphaTestInfo() {
int at_enabled_location = glGetUniformLocation(m_program, "alphaTestEnabled");
int at_value_location = glGetUniformLocation(m_program, "alphaTestValue");
void GLSLCombiner::UpdateAlphaTestInfo(bool _bForce) {
if ((gDP.otherMode.alphaCompare == G_AC_THRESHOLD) && !(gDP.otherMode.alphaCvgSel)) {
glUniform1i(at_enabled_location, 1);
glUniform1f(at_value_location, gDP.blendColor.a);
_setIUniform(m_uniforms.uEnableAlphaTest, 1, _bForce);
_setFUniform(m_uniforms.uAlphaTestValue, gDP.blendColor.a, _bForce);
} else if (gDP.otherMode.cvgXAlpha) {
glUniform1i(at_enabled_location, 1);
glUniform1f(at_value_location, 0.5f);
_setIUniform(m_uniforms.uEnableAlphaTest, 1, _bForce);
_setFUniform(m_uniforms.uAlphaTestValue, 0.5f, _bForce);
} else {
glUniform1i(at_enabled_location, 0);
glUniform1f(at_value_location, 0.0f);
_setIUniform(m_uniforms.uEnableAlphaTest, 0, _bForce);
_setFUniform(m_uniforms.uAlphaTestValue, 0.0f, _bForce);
}
}

62
GLSLCombiner.h
View File

@ -6,12 +6,66 @@ public:
GLSLCombiner(Combiner *_color, Combiner *_alpha);
virtual ~GLSLCombiner();
virtual void Set();
virtual void UpdateColors();
virtual void UpdateFBInfo();
virtual void UpdateDepthInfo();
virtual void UpdateAlphaTestInfo();
virtual void UpdateColors(bool _bForce = false);
virtual void UpdateFBInfo(bool _bForce = false);
virtual void UpdateDepthInfo(bool _bForce = false);
virtual void UpdateAlphaTestInfo(bool _bForce = false);
virtual void UpdateTextureInfo(bool _bForce = false);
virtual void UpdateRenderState(bool _bForce = false);
private:
struct iUniform {GLint loc; int val;};
struct fUniform {GLint loc; float val;};
struct fv2Uniform {GLint loc; float val[2];};
struct fv4Uniform {GLint loc; float val[4];};
struct UniformLocation
{
iUniform uTex0, uTex1, uTlutImage, uZlutImage, uDepthImage,
uEnableFog, uEnableDither, uEnableLod, uEnableAlphaTest,
uEnableDepth, uEnableDepthCompare, uEnableDepthUpdate,
uDepthMode, uFb8Bit, uFbFixedAlpha, uRenderState,
uMaxTile, uTextureDetail, uTexturePersp;
fUniform uFogMultiplier, uFogOffset, uK4, uK5, uPrimLod, uNoiseTime,
uLodXScale, uLodYScale, uMinLod, uDepthTrans, uDepthScale, uAlphaTestValue;
fv4Uniform uEnvColor, uPrimColor, uFogColor, uCenterColor, uScaleColor;
fv2Uniform uTexScale, uTexOffset[2], uCacheShiftScale[2],
uCacheScale[2], uCacheOffset[2];
};
void _locate_attributes() const;
void _locateUniforms();
void _setIUniform(iUniform & _u, int _val, bool _force) {
if (_force|| _u.val != _val) {
_u.val = _val;
glUniform1i(_u.loc, _val);
}
}
void _setFUniform(fUniform & _u, float _val, bool _force) {
if (_force|| _u.val != _val) {
_u.val = _val;
glUniform1f(_u.loc, _val);
}
}
void _setV2Uniform(fv2Uniform & _u, float _val1, float _val2, bool _force) {
if (_force|| _u.val[0] != _val1 || _u.val[1] != _val2) {
_u.val[0] = _val1;
_u.val[2] = _val2;
glUniform2f(_u.loc, _val1, _val2);
}
}
void _setV4Uniform(fv4Uniform & _u, float * _pVal, bool _force) {
const size_t szData = sizeof(float)*4;
if (_force|| memcmp(_u.val, _pVal, szData) > 0) {
memcpy(_u.val, _pVal, szData);
glUniform4fv(_u.loc, 1, _pVal);
}
}
UniformLocation m_uniforms;
GLuint m_aShaders[8];
GLuint m_program;
int m_nInputs;

942
OpenGL.cpp
View File

File diff suppressed because it is too large Load Diff

161
OpenGL.h
View File

@ -27,12 +27,7 @@
struct GLVertex
{
float x, y, z, w;
struct
{
float r, g, b, a;
} color, secondaryColor;
float s0, t0, s1, t1;
float fog;
};
struct GLInfo
@ -41,6 +36,7 @@ struct GLInfo
HGLRC hRC;
HDC hDC;
HWND hWnd;
HWND hFullscreenWnd;
#elif defined(USE_SDL)
SDL_Surface *hScreen;
#endif // _WINDOWS
@ -52,41 +48,87 @@ struct GLInfo
float scaleX, scaleY;
BOOL EXT_fog_coord; // TNT, GeForce, Rage 128, Radeon
BOOL EXT_secondary_color; // GeForce, Radeon
#define INDEXMAP_SIZE 64
#define VERTBUFF_SIZE 256
#define ELEMBUFF_SIZE 1024
int maxTextureUnits; // TNT = 2, GeForce = 2-4, Rage 128 = 2, Radeon = 3-6
struct {
SPVertex vertices[VERTBUFF_SIZE];
GLubyte elements[ELEMBUFF_SIZE];
int num;
BOOL enable2xSaI;
BOOL frameBufferTextures;
u32 textureBitDepth;
float originAdjust;
GLVertex vertices[256];
BYTE triangles[80][3];
u32 indexmap[INDEXMAP_SIZE];
u32 indexmapinv[VERTBUFF_SIZE];
u32 indexmap_prev;
u32 indexmap_nomap;
} triangles;
GLVertex rect[4];
int maxTextureUnits; // TNT = 2, GeForce = 2-4, Rage 128 = 2, Radeon = 3-6
BYTE numTriangles;
BYTE numVertices;
#ifdef _WINDOWS
HWND hFullscreenWnd;
#endif
BYTE combiner;
enum {
fbNone,
fbFBO,
fbFBOEXT
} framebuffer_mode;
} framebufferMode;
enum {
rsNone = 0,
rsTriangle = 1,
rsRect = 2,
rsTexRect = 3,
rsLine = 4
} renderState;
bool bImageTexture;
bool captureScreen;
// Settings. TODO: Move to Settings class
BOOL bHWLighting;
BOOL enable2xSaI;
BOOL frameBufferTextures;
u32 textureBitDepth;
float originAdjust;
};
extern GLInfo OGL;
struct GLcolor
{
float r, g, b, a;
};
bool OGL_Start();
void OGL_Stop();
void OGL_AddTriangle(int v0, int v1, int v2);
void OGL_DrawTriangles();
void OGL_DrawTriangle(SPVertex *vertices, int v0, int v1, int v2);
void OGL_DrawLine(int v0, int v1, float width);
void OGL_DrawRect(int ulx, int uly, int lrx, int lry, float *color);
void OGL_DrawTexturedRect(float ulx, float uly, float lrx, float lry, float uls, float ult, float lrs, float lrt, bool flip);
void OGL_UpdateScale();
void OGL_ClearDepthBuffer();
void OGL_ClearColorBuffer( float *color );
void OGL_ResizeWindow();
void OGL_SaveScreenshot();
void OGL_SwapBuffers();
void OGL_ReadScreen( void **dest, long *width, long *height );
void ogl_glGenFramebuffers (GLsizei n, GLuint *framebuffers);
void ogl_glBindFramebuffer (GLenum target, GLuint framebuffer);
void ogl_glDeleteFramebuffers (GLsizei n, const GLuint *framebuffers);
void ogl_glFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level);
void ogl_glGenRenderbuffers (GLsizei n, GLuint *renderbuffers);
void ogl_glBindRenderbuffer (GLenum target, GLuint renderbuffer);
void ogl_glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
void ogl_glDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers);
void ogl_glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
void ogl_glDrawBuffers (GLsizei n, const GLenum *bufs, GLuint texture);
GLenum ogl_glCheckFramebufferStatus (GLenum target);
void ogl_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
bool checkFBO();
#ifdef _WINDOWS
extern PFNGLCREATESHADERPROC glCreateShader;
@ -99,7 +141,9 @@ extern PFNGLUSEPROGRAMPROC glUseProgram;
extern PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
extern PFNGLUNIFORM1IPROC glUniform1i;
extern PFNGLUNIFORM1FPROC glUniform1f;
extern PFNGLUNIFORM2FPROC glUniform2f;
extern PFNGLUNIFORM4FPROC glUniform4f;
extern PFNGLUNIFORM4FVPROC glUniform4fv;
extern PFNGLDETACHSHADERPROC glDetachShader;
extern PFNGLDELETESHADERPROC glDeleteShader;
extern PFNGLDELETEPROGRAMPROC glDeleteProgram;
@ -108,45 +152,14 @@ extern PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
extern PFNGLGETSHADERIVPROC glGetShaderiv;
extern PFNGLGETPROGRAMIVPROC glGetProgramiv;
extern PFNGLSECONDARYCOLOR3FPROC glSecondaryColor3f;
extern PFNGLCOMBINERPARAMETERFVNVPROC glCombinerParameterfvNV;
extern PFNGLCOMBINERPARAMETERFNVPROC glCombinerParameterfNV;
extern PFNGLCOMBINERPARAMETERIVNVPROC glCombinerParameterivNV;
extern PFNGLCOMBINERPARAMETERINVPROC glCombinerParameteriNV;
extern PFNGLCOMBINERINPUTNVPROC glCombinerInputNV;
extern PFNGLCOMBINEROUTPUTNVPROC glCombinerOutputNV;
extern PFNGLFINALCOMBINERINPUTNVPROC glFinalCombinerInputNV;
extern PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC glGetCombinerInputParameterfvNV;
extern PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC glGetCombinerInputParameterivNV;
extern PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC glGetCombinerOutputParameterfvNV;
extern PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC glGetCombinerOutputParameterivNV;
extern PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC glGetFinalCombinerInputParameterfvNV;
extern PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC glGetFinalCombinerInputParameterivNV;
extern PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
extern PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
extern PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
extern PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation;
extern PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f;
extern PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv;
extern PFNGLACTIVETEXTUREPROC glActiveTexture;
extern PFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture;
extern PFNGLMULTITEXCOORD2FPROC glMultiTexCoord2f;
extern PFNGLSECONDARYCOLOR3FVEXTPROC glSecondaryColor3fvEXT;
extern PFNGLSECONDARYCOLOR3BEXTPROC glSecondaryColor3bEXT;
extern PFNGLSECONDARYCOLOR3BVEXTPROC glSecondaryColor3bvEXT;
extern PFNGLSECONDARYCOLOR3DEXTPROC glSecondaryColor3dEXT;
extern PFNGLSECONDARYCOLOR3DVEXTPROC glSecondaryColor3dvEXT;
extern PFNGLSECONDARYCOLOR3FEXTPROC glSecondaryColor3fEXT;
extern PFNGLSECONDARYCOLOR3FVEXTPROC glSecondaryColor3fvEXT;
extern PFNGLSECONDARYCOLOR3IEXTPROC glSecondaryColor3iEXT;
extern PFNGLSECONDARYCOLOR3IVEXTPROC glSecondaryColor3ivEXT;
extern PFNGLSECONDARYCOLOR3SEXTPROC glSecondaryColor3sEXT;
extern PFNGLSECONDARYCOLOR3SVEXTPROC glSecondaryColor3svEXT;
extern PFNGLSECONDARYCOLOR3UBEXTPROC glSecondaryColor3ubEXT;
extern PFNGLSECONDARYCOLOR3UBVEXTPROC glSecondaryColor3ubvEXT;
extern PFNGLSECONDARYCOLOR3UIEXTPROC glSecondaryColor3uiEXT;
extern PFNGLSECONDARYCOLOR3UIVEXTPROC glSecondaryColor3uivEXT;
extern PFNGLSECONDARYCOLOR3USEXTPROC glSecondaryColor3usEXT;
extern PFNGLSECONDARYCOLOR3USVEXTPROC glSecondaryColor3usvEXT;
extern PFNGLSECONDARYCOLORPOINTEREXTPROC glSecondaryColorPointerEXT;
extern PFNGLDRAWBUFFERSPROC glDrawBuffers;
extern PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers;
@ -181,34 +194,4 @@ extern PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT;
extern PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT;
extern PFNGLBLITFRAMEBUFFEREXTPROC glBlitFramebufferEXT;
#endif // !_WINDOWS
bool OGL_Start();
void OGL_Stop();
void OGL_AddTriangle( SPVertex *vertices, int v0, int v1, int v2 );
void OGL_DrawTriangles();
void OGL_DrawLine( SPVertex *vertices, int v0, int v1, float width );
void OGL_DrawRect( int ulx, int uly, int lrx, int lry, float *color );
void OGL_DrawTexturedRect( float ulx, float uly, float lrx, float lry, float uls, float ult, float lrs, float lrt, bool flip );
void OGL_UpdateScale();
void OGL_ClearDepthBuffer();
void OGL_ClearColorBuffer( float *color );
void OGL_ResizeWindow();
void OGL_SaveScreenshot();
void OGL_SwapBuffers();
void OGL_ReadScreen( void **dest, long *width, long *height );
void ogl_glGenFramebuffers (GLsizei n, GLuint *framebuffers);
void ogl_glBindFramebuffer (GLenum target, GLuint framebuffer);
void ogl_glDeleteFramebuffers (GLsizei n, const GLuint *framebuffers);
void ogl_glFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level);
void ogl_glGenRenderbuffers (GLsizei n, GLuint *renderbuffers);
void ogl_glBindRenderbuffer (GLenum target, GLuint renderbuffer);
void ogl_glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
void ogl_glDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers);
void ogl_glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
void ogl_glDrawBuffers (GLsizei n, const GLenum *bufs, GLuint texture);
GLenum ogl_glCheckFramebufferStatus (GLenum target);
void ogl_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
bool checkFBO();
#endif

214
Shaders.h
View File

@ -1,44 +1,82 @@
static const char* vertex_shader =
"uniform float time; \n"
"varying vec2 noiseCoord2D; \n"
"varying vec4 secondary_color; \n"
"void main() \n"
"{ \n"
" gl_Position = ftransform(); \n"
" gl_FrontColor = gl_Color; \n"
" gl_TexCoord[0] = gl_MultiTexCoord0; \n"
" gl_TexCoord[1] = gl_MultiTexCoord1; \n"
" gl_FogFragCoord = (gl_Fog.end - gl_FogCoord) * gl_Fog.scale; \n"
"attribute vec4 aPosition; \n"
"attribute vec4 aColor; \n"
"attribute vec2 aTexCoord0; \n"
"attribute vec2 aTexCoord1; \n"
"attribute float aSTScaled; \n"
"attribute float aNumLights; \n"
" \n"
"uniform int uRenderState; \n"
"uniform int uTexturePersp; \n"
"uniform float uNoiseTime; \n"
"uniform float uFogMultiplier, uFogOffset; \n"
" \n"
"uniform vec2 uTexScale; \n"
"uniform vec2 uTexOffset[2]; \n"
"uniform vec2 uCacheShiftScale[2]; \n"
"uniform vec2 uCacheScale[2]; \n"
"uniform vec2 uCacheOffset[2]; \n"
" \n"
"varying vec4 vShadeColor; \n"
"varying vec2 vTexCoord0; \n"
"varying vec2 vTexCoord1; \n"
"varying vec2 vLodTexCoord; \n"
"varying vec2 vNoiseCoord2D; \n"
"varying float vNumLights; \n"
"void main() \n"
"{ \n"
" gl_Position = aPosition; \n"
" vShadeColor = aColor; \n"
" if (uRenderState == 1.0) { \n"
" vec2 vTexCoord = aTexCoord0; \n"
" if (aSTScaled == 0) vTexCoord *= uTexScale; \n"
" if (uTexturePersp == 0) vTexCoord *= 0.5; \n"
" vTexCoord0 = ((vTexCoord*uCacheShiftScale[0]) + \n"
" (uCacheOffset[0] - uTexOffset[0])) * uCacheScale[0]; \n"
" vTexCoord1 = ((vTexCoord*uCacheShiftScale[1]) + \n"
" (uCacheOffset[1] - uTexOffset[1])) * uCacheScale[1]; \n"
" vLodTexCoord = vTexCoord * uCacheShiftScale[0]; \n"
" } else { \n"
" vTexCoord0 = aTexCoord0; \n"
" vTexCoord1 = aTexCoord1; \n"
" } \n"
" vNoiseCoord2D = gl_Vertex.xy + vec2(0.0, uNoiseTime); \n"
" gl_FogFragCoord = max(-1.0, aPosition.z / aPosition.w) \n"
" * uFogMultiplier + uFogOffset; \n"
" gl_FogFragCoord = clamp(gl_FogFragCoord, 0.0, 1.0); \n"
" secondary_color = gl_SecondaryColor; \n"
" noiseCoord2D = gl_Vertex.xy + vec2(0.0, time); \n"
"} \n"
" vNumLights = aNumLights; \n"
"} \n"
;
static const char* fragment_shader_header_common_variables =
"uniform sampler2D texture0; \n"
"uniform sampler2D texture1; \n"
"uniform vec4 prim_color; \n"
"uniform vec4 env_color; \n"
"uniform vec4 center_color; \n"
"uniform vec4 scale_color; \n"
"uniform float k4; \n"
"uniform float k5; \n"
"uniform float prim_lod; \n"
"uniform int dither_enabled; \n"
"uniform int fog_enabled; \n"
"uniform int fb_8bit_mode; \n"
"uniform int fb_fixed_alpha; \n"
"varying vec4 secondary_color; \n"
"varying vec2 noiseCoord2D; \n"
"uniform sampler2D uTex0; \n"
"uniform sampler2D uTex1; \n"
"uniform vec4 uPrimColor; \n"
"uniform vec4 uEnvColor; \n"
"uniform vec4 uCenterColor; \n"
"uniform vec4 uScaleColor; \n"
"uniform vec4 uFogColor; \n"
"uniform float uK4; \n"
"uniform float uK5; \n"
"uniform float uPrimLod; \n"
"uniform int uEnableDither; \n"
"uniform int uEnableFog; \n"
"uniform int uFb8Bit; \n"
"uniform int uFbFixedAlpha; \n"
"varying vec4 vShadeColor; \n"
"varying vec2 vTexCoord0; \n"
"varying vec2 vTexCoord1; \n"
"varying vec2 vLodTexCoord; \n"
"varying vec2 vNoiseCoord2D; \n"
"varying float vNumLights; \n"
"vec3 input_color; \n"
;
static const char* fragment_shader_header_common_functions =
" \n"
"float snoise(vec2 v); \n"
"float calc_light(in int nLights, out vec3 output_color); \n"
"float calc_lod(in float prim_lod, in vec2 texCoord); \n"
"float calc_light(in int nLights, in vec3 input_color, out vec3 output_color);\n"
"float calc_lod(in float uPrimLod, in vec2 texCoord); \n"
"bool depth_compare(); \n"
"bool alpha_test(in float alphaValue); \n"
#ifdef USE_TOONIFY
@ -48,15 +86,15 @@ static const char* fragment_shader_header_common_functions =
static const char* fragment_shader_calc_light =
" \n"
"float calc_light(in int nLights, out vec3 output_color) { \n"
" output_color = gl_Color.rgb; \n"
"float calc_light(in int nLights, in vec3 input_color, out vec3 output_color) {\n"
" output_color = input_color; \n"
" if (nLights == 0) \n"
" return 1.0; \n"
" float full_intensity = 0.0; \n"
" output_color = vec3(gl_LightSource[nLights].ambient); \n"
" vec3 lightDir, lightColor; \n"
" float intensity; \n"
" vec3 n = normalize(gl_Color.rgb); \n"
" vec3 n = normalize(input_color); \n"
" for (int i = 0; i < nLights; i++) { \n"
" lightDir = vec3(gl_LightSource[i].position); \n"
" intensity = max(dot(n,lightDir),0.0); \n"
@ -69,31 +107,31 @@ static const char* fragment_shader_calc_light =
;
static const char* fragment_shader_calc_lod =
"uniform int lod_enabled; \n"
"uniform float lod_x_scale; \n"
"uniform float lod_y_scale; \n"
"uniform float min_lod; \n"
"uniform int max_tile; \n"
"uniform int texture_detail; \n"
"uniform int uEnableLod; \n"
"uniform float uLodXScale; \n"
"uniform float uLodYScale; \n"
"uniform float uMinLod; \n"
"uniform int uMaxTile; \n"
"uniform int uTextureDetail; \n"
" \n"
"float calc_lod(in float prim_lod, in vec2 texCoord) { \n"
" if (lod_enabled == 0) \n"
" return prim_lod; \n"
"float calc_lod(in float uPrimLod, in vec2 texCoord) { \n"
" if (uEnableLod == 0) \n"
" return uPrimLod; \n"
" vec2 dx = dFdx(texCoord); \n"
" dx.x *= lod_x_scale; \n"
" dx.y *= lod_y_scale; \n"
" dx.x *= uLodXScale; \n"
" dx.y *= uLodYScale; \n"
" vec2 dy = dFdy(texCoord); \n"
" dy.x *= lod_x_scale; \n"
" dy.y *= lod_y_scale; \n"
" dy.x *= uLodXScale; \n"
" dy.y *= uLodYScale; \n"
" float lod = max(length(dx), length(dy)); \n"
" float lod_frac; \n"
" if (lod < 1.0) { \n"
" lod_frac = max(lod, min_lod); \n"
" if (texture_detail == 1) \n"
" lod_frac = max(lod, uMinLod); \n"
" if (uTextureDetail == 1) \n"
" lod_frac = 1.0 - lod_frac; \n"
" } else { \n"
" float tile = min(float(max_tile), floor(log2(floor(lod)))); \n"
" lod_frac = max(min_lod, fract(lod/pow(2.0, tile)));\n"
" float tile = min(float(uMaxTile), floor(log2(floor(lod)))); \n"
" lod_frac = max(uMinLod, fract(lod/pow(2.0, tile)));\n"
" } \n"
" return lod_frac; \n"
"} \n"
@ -103,8 +141,9 @@ static const char* fragment_shader_header_main =
" \n"
"void main() \n"
"{ \n"
" if (dither_enabled > 0) \n"
" if (snoise(noiseCoord2D) < 0.0) discard; \n"
//" if (uEnableDither != 0) { \n"
//" if (snoise(vNoiseCoord2D) < 0.0) discard; \n"
//" } \n"
" vec4 vec_color, combined_color; \n"
" float alpha1, alpha2; \n"
" vec3 color1, color2; \n"
@ -125,22 +164,22 @@ static const char* fragment_shader_toonify =
#endif
static const char* fragment_shader_default =
//" gl_FragColor = texture2D(texture0, gl_TexCoord[0].st); \n"
//" gl_FragColor = texture2D(uTex0, gl_TexCoord[0].st); \n"
//" gl_FragColor = gl_Color; \n"
" vec4 color = texture2D(texture0, gl_TexCoord[0].st); \n"
" gl_FragColor = gl_Color*color; \n"
" vec4 color = texture2D(uTex0, vTexCoord0); \n"
" gl_FragColor = vShadeColor*color; \n"
;
static const char* fragment_shader_readtex0color =
" vec4 readtex0 = texture2D(texture0, gl_TexCoord[0].st); \n"
" if (fb_8bit_mode == 1 || fb_8bit_mode == 3) readtex0 = vec4(readtex0.r); \n"
" if (fb_fixed_alpha == 1 || fb_fixed_alpha == 3) readtex0.a = 0.825; \n"
" vec4 readtex0 = texture2D(uTex0, vTexCoord0); \n"
" if (uFb8Bit == 1 || uFb8Bit == 3) readtex0 = vec4(readtex0.r); \n"
" if (uFbFixedAlpha == 1 || uFbFixedAlpha == 3) readtex0.a = 0.825; \n"
;
static const char* fragment_shader_readtex1color =
" vec4 readtex1 = texture2D(texture1, gl_TexCoord[1].st); \n"
" if (fb_8bit_mode == 2 || fb_8bit_mode == 3) readtex1 = vec4(readtex1.r); \n"
" if (fb_fixed_alpha == 2 || fb_fixed_alpha == 3) readtex1.a = 0.825; \n"
" vec4 readtex1 = texture2D(uTex1, vTexCoord1); \n"
" if (uFb8Bit == 2 || uFb8Bit == 3) readtex1 = vec4(readtex1.r); \n"
" if (uFbFixedAlpha == 2 || uFbFixedAlpha == 3) readtex1.a = 0.825; \n"
;
static const char* fragment_shader_end =
@ -149,33 +188,33 @@ static const char* fragment_shader_end =
static const char* depth_compare_shader_float =
"#version 420 core \n"
"uniform int depthEnabled; \n"
"uniform int depthMode; \n"
"uniform int depthCompareEnabled; \n"
"uniform int depthUpdateEnabled; \n"
"uniform float depthTrans; \n"
"uniform float depthScale; \n"
"layout(binding = 0, r16ui) uniform readonly uimage2D zlut_image;\n"
"layout(binding = 2, rgba32f) uniform restrict image2D depth_image;\n"
"uniform int uEnableDepth; \n"
"uniform int uDepthMode; \n"
"uniform int uEnableDepthCompare; \n"
"uniform int uEnableDepthUpdate; \n"
"uniform float uDepthTrans; \n"
"uniform float uDepthScale; \n"
"layout(binding = 0, r16ui) uniform readonly uimage2D uZlutImage;\n"
"layout(binding = 2, rgba32f) uniform restrict image2D uDepthImage;\n"
"void write_depth(in highp float dz, in ivec2 coord) \n"
"{ \n"
" highp float fZ = 2.0*gl_FragCoord.z - 1.0; \n"
" fZ = (depthScale*fZ + depthTrans)*8.0; \n"
" fZ = (uDepthScale*fZ + uDepthTrans)*8.0; \n"
" const highp int iZ = int(floor(fZ + 0.5)); \n"
" int y0 = clamp(iZ/512, 0, 511); \n"
" int x0 = iZ - 512*y0; \n"
" unsigned int iN64z = imageLoad(zlut_image,ivec2(x0,y0)).r;\n"
" unsigned int iN64z = imageLoad(uZlutImage,ivec2(x0,y0)).r;\n"
" highp float n64z = clamp(float(iN64z)/65532.0, 0.0, 1.0);\n"
" highp vec4 depth = vec4(n64z, gl_FragCoord.z, dz, 1.0); \n"
" memoryBarrier(); \n"
" imageStore(depth_image,coord,depth); \n"
" imageStore(uDepthImage,coord,depth); \n"
"} \n"
"bool depth_compare() \n"
"{ \n"
" if (depthEnabled == 0) return true; \n"
" if (uEnableDepth == 0) return true; \n"
" ivec2 coord = ivec2(gl_FragCoord.xy); \n"
" memoryBarrier(); \n"
" highp vec4 depth = imageLoad(depth_image,coord); \n"
" highp vec4 depth = imageLoad(uDepthImage,coord); \n"
" highp float bufZ = depth.g; \n"
" highp float curZ = gl_FragCoord.z; \n"
" highp float dz = fwidth(gl_FragCoord.z); \n"
@ -185,7 +224,7 @@ static const char* depth_compare_shader_float =
" const bool bNearer = (curZ - dzMax) <= bufZ; \n"
" const bool bMax = bufZ == 1.0; \n"
" bool bRes; \n"
" switch(depthMode) { \n"
" switch(uDepthMode) { \n"
" case 0: \n"
" case 1: \n"
" bRes = bMax || bNearer; \n"
@ -200,44 +239,45 @@ static const char* depth_compare_shader_float =
" bRes = bInfront; \n"
" break; \n"
" } \n"
" if (depthUpdateEnabled > 0 && bRes) { \n"
" if (uEnableDepthUpdate > 0 && bRes) { \n"
" write_depth(dz, coord); \n"
" } \n"
" if (depthCompareEnabled > 0) \n"
" if (uEnableDepthCompare > 0) \n"
" return bRes; \n"
" return true; \n"
"} \n"
;
static const char* alpha_test_fragment_shader =
"uniform int alphaTestEnabled; \n"
"uniform float alphaTestValue; \n"
"uniform int uEnableAlphaTest; \n"
"uniform float uAlphaTestValue; \n"
"bool alpha_test(in float alphaValue) \n"
"{ \n"
" if (alphaTestEnabled == 0) return true; \n"
" if (alphaTestValue > 0.0) return alphaValue >= alphaTestValue;\n"
" if (uEnableAlphaTest == 0) return true; \n"
" if (uAlphaTestValue > 0.0) return alphaValue >= uAlphaTestValue;\n"
" return alphaValue > 0.0; \n"
"} \n"
;
static const char* shadow_map_vertex_shader =
"#version 420 core \n"
"attribute highp vec4 aPosition; \n"
"void main() \n"
"{ \n"
" gl_Position = ftransform(); \n"
" gl_FrontColor = gl_Color; \n"
" gl_Position = aPosition; \n"
"} \n"
;
static const char* shadow_map_fragment_shader_float =
"#version 420 core \n"
"layout(binding = 1, r16ui) uniform readonly uimage1D tlut_image;\n"
"layout(binding = 2, rgba32f) uniform readonly image2D depth_image;\n"
"layout(binding = 1, r16ui) uniform readonly uimage1D uTlutImage;\n"
"layout(binding = 2, rgba32f) uniform readonly image2D uDepthImage;\n"
"float get_alpha() \n"
"{ \n"
" ivec2 coord = ivec2(gl_FragCoord.xy); \n"
" float bufZ = imageLoad(depth_image,coord).r; \n"
" float bufZ = imageLoad(uDepthImage,coord).r; \n"
" int index = min(255, int(bufZ*255.0)); \n"
" unsigned int iAlpha = imageLoad(tlut_image,index).r; \n"
" unsigned int iAlpha = imageLoad(uTlutImage,index).r; \n"
" memoryBarrier(); \n"
" return float(iAlpha/256)/255.0; \n"
"} \n"