mirror of
https://github.com/wheremyfoodat/Panda3DS.git
synced 2025-04-06 06:05:40 +12:00
253 lines
12 KiB
Diff
253 lines
12 KiB
Diff
diff --git a/src/host_shaders/opengl_fragment_shader.frag b/src/host_shaders/opengl_fragment_shader.frag
|
|
index 9f07df0b..96a35afa 100644
|
|
--- a/src/host_shaders/opengl_fragment_shader.frag
|
|
+++ b/src/host_shaders/opengl_fragment_shader.frag
|
|
@@ -1,4 +1,5 @@
|
|
-#version 410 core
|
|
+#version 300 es
|
|
+precision mediump float;
|
|
|
|
in vec4 v_quaternion;
|
|
in vec4 v_colour;
|
|
@@ -41,8 +42,8 @@ vec3 normal;
|
|
const uint samplerEnabledBitfields[2] = uint[2](0x7170e645u, 0x7f013fefu);
|
|
|
|
bool isSamplerEnabled(uint environment_id, uint lut_id) {
|
|
- uint index = 7 * environment_id + lut_id;
|
|
- uint arrayIndex = (index >> 5);
|
|
+ uint index = 7u * environment_id + lut_id;
|
|
+ uint arrayIndex = (index >> 5u);
|
|
return (samplerEnabledBitfields[arrayIndex] & (1u << (index & 31u))) != 0u;
|
|
}
|
|
|
|
@@ -166,11 +167,17 @@ float lutLookup(uint lut, int index) {
|
|
return texelFetch(u_tex_luts, ivec2(index, int(lut)), 0).r;
|
|
}
|
|
|
|
+// some gles versions have bitfieldExtractCompat and complain if you redefine it, some don't and compile error, using this instead
|
|
+uint bitfieldExtractCompat(uint val, int off, int size) {
|
|
+ uint mask = uint((1 << size) - 1);
|
|
+ return uint(val >> off) & mask;
|
|
+}
|
|
+
|
|
vec3 regToColor(uint reg) {
|
|
// Normalization scale to convert from [0...255] to [0.0...1.0]
|
|
const float scale = 1.0 / 255.0;
|
|
|
|
- return scale * vec3(float(bitfieldExtract(reg, 20, 8)), float(bitfieldExtract(reg, 10, 8)), float(bitfieldExtract(reg, 00, 8)));
|
|
+ return scale * vec3(float(bitfieldExtractCompat(reg, 20, 8)), float(bitfieldExtractCompat(reg, 10, 8)), float(bitfieldExtractCompat(reg, 00, 8)));
|
|
}
|
|
|
|
// Convert an arbitrary-width floating point literal to an f32
|
|
@@ -201,7 +208,7 @@ float lightLutLookup(uint environment_id, uint lut_id, uint light_id, vec3 light
|
|
// These are the spotlight attenuation LUTs
|
|
bit_in_config1 = 8 + int(light_id & 7u);
|
|
lut_index = 8u + light_id;
|
|
- } else if (lut_id <= 6) {
|
|
+ } else if (lut_id <= 6u) {
|
|
bit_in_config1 = 16 + int(lut_id);
|
|
lut_index = lut_id;
|
|
} else {
|
|
@@ -210,16 +217,16 @@ float lightLutLookup(uint environment_id, uint lut_id, uint light_id, vec3 light
|
|
|
|
bool current_sampler_enabled = isSamplerEnabled(environment_id, lut_id); // 7 luts per environment
|
|
|
|
- if (!current_sampler_enabled || (bitfieldExtract(GPUREG_LIGHTING_CONFIG1, bit_in_config1, 1) != 0u)) {
|
|
+ if (!current_sampler_enabled || (bitfieldExtractCompat(GPUREG_LIGHTING_CONFIG1, bit_in_config1, 1) != 0u)) {
|
|
return 1.0;
|
|
}
|
|
|
|
- uint scale_id = bitfieldExtract(GPUREG_LIGHTING_LUTINPUT_SCALE, int(lut_id) << 2, 3);
|
|
+ uint scale_id = bitfieldExtractCompat(GPUREG_LIGHTING_LUTINPUT_SCALE, int(lut_id) << 2, 3);
|
|
float scale = float(1u << scale_id);
|
|
if (scale_id >= 6u) scale /= 256.0;
|
|
|
|
float delta = 1.0;
|
|
- uint input_id = bitfieldExtract(GPUREG_LIGHTING_LUTINPUT_SELECT, int(lut_id) << 2, 3);
|
|
+ uint input_id = bitfieldExtractCompat(GPUREG_LIGHTING_LUTINPUT_SELECT, int(lut_id) << 2, 3);
|
|
switch (input_id) {
|
|
case 0u: {
|
|
delta = dot(normal, normalize(half_vector));
|
|
@@ -243,9 +250,9 @@ float lightLutLookup(uint environment_id, uint lut_id, uint light_id, vec3 light
|
|
|
|
// Sign extend them. Normally bitfieldExtract would do that but it's missing on some versions
|
|
// of GLSL so we do it manually
|
|
- int se_x = bitfieldExtract(GPUREG_LIGHTi_SPOTDIR_LOW, 0, 13);
|
|
- int se_y = bitfieldExtract(GPUREG_LIGHTi_SPOTDIR_LOW, 16, 13);
|
|
- int se_z = bitfieldExtract(GPUREG_LIGHTi_SPOTDIR_HIGH, 0, 13);
|
|
+ int se_x = int(bitfieldExtractCompat(uint(GPUREG_LIGHTi_SPOTDIR_LOW), 0, 13));
|
|
+ int se_y = int(bitfieldExtractCompat(uint(GPUREG_LIGHTi_SPOTDIR_LOW), 16, 13));
|
|
+ int se_z = int(bitfieldExtractCompat(uint(GPUREG_LIGHTi_SPOTDIR_HIGH), 0, 13));
|
|
|
|
if ((se_x & 0x1000) == 0x1000) se_x |= 0xffffe000;
|
|
if ((se_y & 0x1000) == 0x1000) se_y |= 0xffffe000;
|
|
@@ -272,9 +279,9 @@ float lightLutLookup(uint environment_id, uint lut_id, uint light_id, vec3 light
|
|
}
|
|
|
|
// 0 = enabled
|
|
- if (bitfieldExtract(GPUREG_LIGHTING_LUTINPUT_ABS, 1 + (int(lut_id) << 2), 1) == 0u) {
|
|
+ if (bitfieldExtractCompat(GPUREG_LIGHTING_LUTINPUT_ABS, 1 + (int(lut_id) << 2), 1) == 0u) {
|
|
// Two sided diffuse
|
|
- if (bitfieldExtract(GPUREG_LIGHTi_CONFIG, 1, 1) == 0u) {
|
|
+ if (bitfieldExtractCompat(GPUREG_LIGHTi_CONFIG, 1, 1) == 0u) {
|
|
delta = max(delta, 0.0);
|
|
} else {
|
|
delta = abs(delta);
|
|
@@ -298,7 +305,7 @@ vec3 rotateVec3ByQuaternion(vec3 v, vec4 q) {
|
|
// Implements the following algorthm: https://mathb.in/26766
|
|
void calcLighting(out vec4 primary_color, out vec4 secondary_color) {
|
|
uint GPUREG_LIGHTING_ENABLE = readPicaReg(0x008Fu);
|
|
- if (bitfieldExtract(GPUREG_LIGHTING_ENABLE, 0, 1) == 0u) {
|
|
+ if (bitfieldExtractCompat(GPUREG_LIGHTING_ENABLE, 0, 1) == 0u) {
|
|
primary_color = secondary_color = vec4(0.0);
|
|
return;
|
|
}
|
|
@@ -315,7 +322,7 @@ void calcLighting(out vec4 primary_color, out vec4 secondary_color) {
|
|
GPUREG_LIGHTING_LUTINPUT_ABS = readPicaReg(0x01D0u);
|
|
GPUREG_LIGHTING_LUTINPUT_SELECT = readPicaReg(0x01D1u);
|
|
|
|
- uint bump_mode = bitfieldExtract(GPUREG_LIGHTING_CONFIG0, 28, 2);
|
|
+ uint bump_mode = bitfieldExtractCompat(GPUREG_LIGHTING_CONFIG0, 28, 2);
|
|
|
|
// Bump mode is ignored for now because it breaks some games ie. Toad Treasure Tracker
|
|
switch (bump_mode) {
|
|
@@ -328,15 +335,15 @@ void calcLighting(out vec4 primary_color, out vec4 secondary_color) {
|
|
vec4 diffuse_sum = vec4(0.0, 0.0, 0.0, 1.0);
|
|
vec4 specular_sum = vec4(0.0, 0.0, 0.0, 1.0);
|
|
|
|
- uint environment_id = bitfieldExtract(GPUREG_LIGHTING_CONFIG0, 4, 4);
|
|
- bool clamp_highlights = bitfieldExtract(GPUREG_LIGHTING_CONFIG0, 27, 1) == 1u;
|
|
+ uint environment_id = bitfieldExtractCompat(GPUREG_LIGHTING_CONFIG0, 4, 4);
|
|
+ bool clamp_highlights = bitfieldExtractCompat(GPUREG_LIGHTING_CONFIG0, 27, 1) == 1u;
|
|
|
|
uint light_id;
|
|
vec3 light_vector;
|
|
vec3 half_vector;
|
|
|
|
for (uint i = 0u; i < GPUREG_LIGHTING_NUM_LIGHTS; i++) {
|
|
- light_id = bitfieldExtract(GPUREG_LIGHTING_LIGHT_PERMUTATION, int(i) << 2, 3);
|
|
+ light_id = bitfieldExtractCompat(GPUREG_LIGHTING_LIGHT_PERMUTATION, int(i) << 2, 3);
|
|
|
|
uint GPUREG_LIGHTi_SPECULAR0 = readPicaReg(0x0140u + (light_id << 4u));
|
|
uint GPUREG_LIGHTi_SPECULAR1 = readPicaReg(0x0141u + (light_id << 4u));
|
|
@@ -348,12 +355,12 @@ void calcLighting(out vec4 primary_color, out vec4 secondary_color) {
|
|
|
|
float light_distance;
|
|
vec3 light_position = vec3(
|
|
- decodeFP(bitfieldExtract(GPUREG_LIGHTi_VECTOR_LOW, 0, 16), 5u, 10u), decodeFP(bitfieldExtract(GPUREG_LIGHTi_VECTOR_LOW, 16, 16), 5u, 10u),
|
|
- decodeFP(bitfieldExtract(GPUREG_LIGHTi_VECTOR_HIGH, 0, 16), 5u, 10u)
|
|
+ decodeFP(bitfieldExtractCompat(GPUREG_LIGHTi_VECTOR_LOW, 0, 16), 5u, 10u), decodeFP(bitfieldExtractCompat(GPUREG_LIGHTi_VECTOR_LOW, 16, 16), 5u, 10u),
|
|
+ decodeFP(bitfieldExtractCompat(GPUREG_LIGHTi_VECTOR_HIGH, 0, 16), 5u, 10u)
|
|
);
|
|
|
|
// Positional Light
|
|
- if (bitfieldExtract(GPUREG_LIGHTi_CONFIG, 0, 1) == 0u) {
|
|
+ if (bitfieldExtractCompat(GPUREG_LIGHTi_CONFIG, 0, 1) == 0u) {
|
|
light_vector = light_position + v_view;
|
|
}
|
|
|
|
@@ -369,23 +376,23 @@ void calcLighting(out vec4 primary_color, out vec4 secondary_color) {
|
|
float NdotL = dot(normal, light_vector); // N dot Li
|
|
|
|
// Two sided diffuse
|
|
- if (bitfieldExtract(GPUREG_LIGHTi_CONFIG, 1, 1) == 0u)
|
|
+ if (bitfieldExtractCompat(GPUREG_LIGHTi_CONFIG, 1, 1) == 0u)
|
|
NdotL = max(0.0, NdotL);
|
|
else
|
|
NdotL = abs(NdotL);
|
|
|
|
float geometric_factor;
|
|
- bool use_geo_0 = bitfieldExtract(GPUREG_LIGHTi_CONFIG, 2, 1) == 1u;
|
|
- bool use_geo_1 = bitfieldExtract(GPUREG_LIGHTi_CONFIG, 3, 1) == 1u;
|
|
+ bool use_geo_0 = bitfieldExtractCompat(GPUREG_LIGHTi_CONFIG, 2, 1) == 1u;
|
|
+ bool use_geo_1 = bitfieldExtractCompat(GPUREG_LIGHTi_CONFIG, 3, 1) == 1u;
|
|
if (use_geo_0 || use_geo_1) {
|
|
geometric_factor = dot(half_vector, half_vector);
|
|
geometric_factor = geometric_factor == 0.0 ? 0.0 : min(NdotL / geometric_factor, 1.0);
|
|
}
|
|
|
|
float distance_attenuation = 1.0;
|
|
- if (bitfieldExtract(GPUREG_LIGHTING_CONFIG1, 24 + int(light_id), 1) == 0u) {
|
|
- uint GPUREG_LIGHTi_ATTENUATION_BIAS = bitfieldExtract(readPicaReg(0x014Au + (light_id << 4u)), 0, 20);
|
|
- uint GPUREG_LIGHTi_ATTENUATION_SCALE = bitfieldExtract(readPicaReg(0x014Bu + (light_id << 4u)), 0, 20);
|
|
+ if (bitfieldExtractCompat(GPUREG_LIGHTING_CONFIG1, 24 + int(light_id), 1) == 0u) {
|
|
+ uint GPUREG_LIGHTi_ATTENUATION_BIAS = bitfieldExtractCompat(readPicaReg(0x014Au + (light_id << 4u)), 0, 20);
|
|
+ uint GPUREG_LIGHTi_ATTENUATION_SCALE = bitfieldExtractCompat(readPicaReg(0x014Bu + (light_id << 4u)), 0, 20);
|
|
|
|
float distance_attenuation_bias = decodeFP(GPUREG_LIGHTi_ATTENUATION_BIAS, 7u, 12u);
|
|
float distance_attenuation_scale = decodeFP(GPUREG_LIGHTi_ATTENUATION_SCALE, 7u, 12u);
|
|
@@ -430,8 +437,8 @@ void calcLighting(out vec4 primary_color, out vec4 secondary_color) {
|
|
specular_sum.rgb += light_factor * clamp_factor * (specular0 + specular1);
|
|
}
|
|
|
|
- uint fresnel_output1 = bitfieldExtract(GPUREG_LIGHTING_CONFIG0, 2, 1);
|
|
- uint fresnel_output2 = bitfieldExtract(GPUREG_LIGHTING_CONFIG0, 3, 1);
|
|
+ uint fresnel_output1 = bitfieldExtractCompat(GPUREG_LIGHTING_CONFIG0, 2, 1);
|
|
+ uint fresnel_output2 = bitfieldExtractCompat(GPUREG_LIGHTING_CONFIG0, 3, 1);
|
|
// Uses parameters from the last light as Fresnel is only applied to the last light
|
|
float fresnel_factor;
|
|
|
|
diff --git a/src/host_shaders/opengl_vertex_shader.vert b/src/host_shaders/opengl_vertex_shader.vert
|
|
index 057f9a88..dc735ced 100644
|
|
--- a/src/host_shaders/opengl_vertex_shader.vert
|
|
+++ b/src/host_shaders/opengl_vertex_shader.vert
|
|
@@ -1,4 +1,6 @@
|
|
-#version 410 core
|
|
+#version 300 es
|
|
+precision mediump float;
|
|
+precision mediump int;
|
|
|
|
layout(location = 0) in vec4 a_coords;
|
|
layout(location = 1) in vec4 a_quaternion;
|
|
@@ -18,7 +20,7 @@ out vec2 v_texcoord2;
|
|
flat out vec4 v_textureEnvColor[6];
|
|
flat out vec4 v_textureEnvBufferColor;
|
|
|
|
-out float gl_ClipDistance[2];
|
|
+// out float gl_ClipDistance[2];
|
|
|
|
// TEV uniforms
|
|
uniform uint u_textureEnvColor[6];
|
|
@@ -81,8 +83,8 @@ void main() {
|
|
);
|
|
|
|
// There's also another, always-on clipping plane based on vertex z
|
|
- gl_ClipDistance[0] = -a_coords.z;
|
|
- gl_ClipDistance[1] = dot(clipData, a_coords);
|
|
+ // gl_ClipDistance[0] = -a_coords.z;
|
|
+ // gl_ClipDistance[1] = dot(clipData, a_coords);
|
|
|
|
v_quaternion = a_quaternion;
|
|
}
|
|
diff --git a/third_party/opengl/opengl.hpp b/third_party/opengl/opengl.hpp
|
|
index 607815fa..cbfcc096 100644
|
|
--- a/third_party/opengl/opengl.hpp
|
|
+++ b/third_party/opengl/opengl.hpp
|
|
@@ -602,22 +602,22 @@ namespace OpenGL {
|
|
static void disableScissor() { glDisable(GL_SCISSOR_TEST); }
|
|
static void enableBlend() { glEnable(GL_BLEND); }
|
|
static void disableBlend() { glDisable(GL_BLEND); }
|
|
- static void enableLogicOp() { glEnable(GL_COLOR_LOGIC_OP); }
|
|
- static void disableLogicOp() { glDisable(GL_COLOR_LOGIC_OP); }
|
|
+ static void enableLogicOp() { /* glEnable(GL_COLOR_LOGIC_OP); */ }
|
|
+ static void disableLogicOp() { /* glDisable(GL_COLOR_LOGIC_OP); */ }
|
|
static void enableDepth() { glEnable(GL_DEPTH_TEST); }
|
|
static void disableDepth() { glDisable(GL_DEPTH_TEST); }
|
|
static void enableStencil() { glEnable(GL_STENCIL_TEST); }
|
|
static void disableStencil() { glDisable(GL_STENCIL_TEST); }
|
|
|
|
- static void enableClipPlane(GLuint index) { glEnable(GL_CLIP_DISTANCE0 + index); }
|
|
- static void disableClipPlane(GLuint index) { glDisable(GL_CLIP_DISTANCE0 + index); }
|
|
+ static void enableClipPlane(GLuint index) { /* glEnable(GL_CLIP_DISTANCE0 + index); */ }
|
|
+ static void disableClipPlane(GLuint index) { /* glDisable(GL_CLIP_DISTANCE0 + index); */ }
|
|
|
|
static void setDepthFunc(DepthFunc func) { glDepthFunc(static_cast<GLenum>(func)); }
|
|
static void setColourMask(GLboolean r, GLboolean g, GLboolean b, GLboolean a) { glColorMask(r, g, b, a); }
|
|
static void setDepthMask(GLboolean mask) { glDepthMask(mask); }
|
|
|
|
// TODO: Add a proper enum for this
|
|
- static void setLogicOp(GLenum op) { glLogicOp(op); }
|
|
+ static void setLogicOp(GLenum op) { /* glLogicOp(op); */ }
|
|
|
|
enum Primitives {
|
|
Triangle = GL_TRIANGLES,
|