refactor: Rework features that use external libraries into optional plugins (#1470)

plugins/visualizers/romfs/shaders/default/fragment.glsl

@@ -0,0 +1,40 @@
+#version 330 core
+
+in VertexData {
+    vec3 normal;
+    vec4 fragColor;
+    vec2 texCoord;
+    vec3 lightPosition;
+    vec3 fragPosition;
+    vec4 lightBrightness;
+    vec3 lightColor;
+} vertexData;
+
+out vec4 outColor;
+
+uniform sampler2D modelTexture;
+
+void main() {
+    vec3 ambientLightColor = vec3(1.0, 1.0, 1.0);
+
+    // Ambient lighting
+    vec3 ambient = vertexData.lightBrightness.x * ambientLightColor;
+
+    // Diffuse lighting
+    vec3 normalVector = normalize(vertexData.normal);
+
+    vec3 lightDirection = normalize(vertexData.lightPosition - vertexData.fragPosition);
+    float diffuse = vertexData.lightBrightness.y * max(dot(normalVector, lightDirection), 0.0);
+
+    // Specular lighting
+    vec3 viewDirection = normalize(-vertexData.fragPosition);
+    vec3 reflectDirection = normalize(-reflect(lightDirection, normalVector));
+    float reflectionIntensity = pow(max(dot(viewDirection, reflectDirection), 0.0), vertexData.lightBrightness.w);
+    float specular = vertexData.lightBrightness.z * reflectionIntensity;
+
+    float dst = distance(vertexData.lightPosition, vertexData.fragPosition);
+    float attn = 1./(1.0f + 0.1f*dst + 0.01f*dst*dst) ;
+    vec3 color = ((diffuse + specular)*attn + ambient) * vertexData.lightColor;
+    outColor = (texture(modelTexture, vertexData.texCoord) + vertexData.fragColor) * vec4(color, 1.0);
+}
+

plugins/visualizers/romfs/shaders/default/lightFragment.glsl

@@ -0,0 +1,22 @@
+#version 330
+
+in VertexData {
+    vec3 normal;
+    vec4 color;
+    vec3 fragPosition;
+} vertexData;
+
+out vec4 outColor;
+
+void main() {
+
+    vec3 nLight = normalize(-vertexData.fragPosition);
+    vec3 nNormal = normalize(vertexData.normal);
+
+    float dotLN = dot(nLight, nNormal);
+
+    float diffuse = dotLN * 0.5;
+
+    vec3 color = (diffuse+0.7)*vertexData.color.xyz;
+    outColor = vec4(color, 1.0f);
+}

plugins/visualizers/romfs/shaders/default/lightVertex.glsl

@@ -0,0 +1,27 @@
+#version 330
+
+uniform mat4 modelMatrix;
+uniform mat4 viewMatrix;
+uniform mat4 projectionMatrix;
+
+layout (location = 0) in vec3 in_Position;
+layout (location = 1) in vec3 in_Normal;
+layout (location = 2) in vec4 in_Color;
+
+
+
+out VertexData {
+    vec3 normal;
+    vec4 color;
+    vec3 fragPosition;
+} vertexData;
+
+
+void main() {
+    vertexData.normal       = (modelMatrix * vec4(in_Normal,0)).xyz;
+    //vertexData.normal       = mat3(transpose(inverse(modelMatrix))) * in_Normal;
+    //vertexData.fragPosition = (viewMatrix * modelMatrix * vec4(in_Position, 1.0)).xyz;
+    vertexData.fragPosition = (modelMatrix * vec4(in_Position, 1.0)).xyz;
+    gl_Position             = projectionMatrix * viewMatrix * modelMatrix * vec4(in_Position, 1.0);
+    vertexData.color        = in_Color;
+}

plugins/visualizers/romfs/shaders/default/lineFragment.glsl

@@ -0,0 +1,8 @@
+#version 330 core
+
+in vec4 fragColor;
+out vec4 outColor;
+
+void main() {
+    outColor = fragColor;
+}

plugins/visualizers/romfs/shaders/default/lineVertex.glsl

@@ -0,0 +1,15 @@
+#version 330 core
+
+layout (location = 0) in vec3 in_Position;
+layout (location = 1) in vec4 in_Color;
+
+uniform mat4 modelMatrix;
+uniform mat4 viewMatrix;
+uniform mat4 projectionMatrix;
+
+out vec4 fragColor;
+
+void main() {
+    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_Position, 1.0);
+    fragColor   = in_Color;
+}

plugins/visualizers/romfs/shaders/default/vertex.glsl

@@ -0,0 +1,39 @@
+#version 330 core
+layout (location = 0) in vec3 in_Position;
+layout (location = 1) in vec4 in_Color;
+layout (location = 2) in vec3 in_Normal;
+layout (location = 3) in vec2 in_TexCoord;
+
+uniform mat4 modelScale;
+
+uniform mat4 modelMatrix;
+uniform mat4 viewMatrix;
+uniform mat4 projectionMatrix;
+
+uniform vec3 lightPosition;
+uniform vec4 lightBrightness;
+uniform vec3 lightColor;
+
+out VertexData {
+     vec3 normal;
+     vec4 fragColor;
+     vec2 texCoord;
+     vec3 lightPosition;
+     vec3 fragPosition;
+     vec4 lightBrightness;
+     vec3 lightColor;
+} vertexData;
+
+void main() {
+     gl_Position                   = projectionMatrix * viewMatrix * modelScale * vec4(in_Position, 1.0);
+
+     vertexData.normal             = mat3(transpose(inverse(modelScale))) * in_Normal;
+     vertexData.fragPosition       = vec3(viewMatrix * modelScale * vec4(in_Position, 1.0));
+     vertexData.fragColor          = in_Color;
+     vertexData.texCoord           = in_TexCoord;
+     vertexData.lightBrightness    = lightBrightness;
+     vertexData.lightColor         = lightColor;
+
+     // Transform world-space light position to view-space light position
+     vertexData.lightPosition      = vec3(viewMatrix * modelMatrix * vec4(lightPosition, 1.0));
+}