Fix a few lingering merge issues, remove unused files

Author: davepagurek

src/webgl/p5.RendererGL.Retained.js

@@ -141,7 +141,7 @@ p5.RendererGL.prototype.drawBuffers = function(gId) {
     this._useVertexColor = (geometry.model.vertexColors.length > 0);
 
     let fillShader;
-    if (this.states._drawingFilter && this.states.userFillShader) {
+    if (this._drawingFilter && this.states.userFillShader) {
       fillShader = this.states.userFillShader;
     } else {
       fillShader = this._getFillShader();

src/webgl/p5.RendererGL.js

@@ -28,9 +28,6 @@ defineStrokeJoinEnum('BEVEL', 2);
 
 import lightingShader from './shaders/lighting.glsl';
 import webgl2CompatibilityShader from './shaders/webgl2Compatibility.glsl';
-import immediateVert from './shaders/immediate.vert';
-import vertexColorVert from './shaders/vertexColor.vert';
-import vertexColorFrag from './shaders/vertexColor.frag';
 import normalVert from './shaders/normal.vert';
 import normalFrag from './shaders/normal.frag';
 import basicFrag from './shaders/basic.frag';
@@ -50,9 +47,6 @@ import imageLightDiffusedFrag from './shaders/imageLightDiffused.frag';
 import imageLightSpecularFrag from './shaders/imageLightSpecular.frag';
 
 const defaultShaders = {
-  immediateVert,
-  vertexColorVert,
-  vertexColorFrag,
   normalVert,
   normalFrag,
   basicFrag,
@@ -560,7 +554,8 @@ p5.RendererGL = class RendererGL extends Renderer {
     this.executeZoom = false;
     this.executeRotateAndMove = false;
 
-    this.states._drawingFilter = false;
+    this._drawingFilter = false;
+    this._drawingImage = false;
 
     this.states.specularShader = undefined;
     this.sphereMapping = undefined;
@@ -1160,9 +1155,10 @@ p5.RendererGL = class RendererGL extends Renderer {
     target.filterCamera._resize();
     this._pInst.setCamera(target.filterCamera);
     this._pInst.resetMatrix();
-    this.states._drawingFilter = true;
+    this._drawingFilter = true;
     this._pInst.image(fbo, -target.width / 2, -target.height / 2,
       target.width, target.height);
+    this._drawingFilter = false;
     this._pInst.clearDepth();
     this._pInst.pop();
     this._pInst.pop();
@@ -1663,9 +1659,9 @@ p5.RendererGL = class RendererGL extends Renderer {
    */
   _getFillShader() {
     // If drawing an image, check for user-defined image shader and filters
-    if (this.states._drawingImage) {
+    if (this._drawingImage) {
       // Use user-defined image shader if available and no filter is applied
-      if (this.states.userImageShader && !this.states._drawingFilter) {
+      if (this.states.userImageShader && !this._drawingFilter) {
         return this.states.userImageShader;
       } else {
         return this._getLightShader(); // Fallback to light shader
@@ -1676,11 +1672,11 @@ p5.RendererGL = class RendererGL extends Renderer {
       return this.states.userFillShader;
     }
     // Use normal shader if normal material is active
-    else if (this._useNormalMaterial) {
+    else if (this.states._useNormalMaterial) {
       return this._getNormalShader();
     }
     // Use light shader if lighting or textures are enabled
-    else if (this._enableLighting || this._tex) {
+    else if (this.states._enableLighting || this.states._tex) {
       return this._getLightShader();
     }
     // Default to color shader if no other conditions are met
@@ -1761,20 +1757,6 @@ p5.RendererGL = class RendererGL extends Renderer {
     return this._defaultLightShader;
   }
 
-  _getImmediateModeShader() {
-    if (!this._defaultImmediateModeShader) {
-      this._defaultImmediateModeShader = new p5.Shader(
-        this,
-        this._webGL2CompatibilityPrefix('vert', 'mediump') +
-        defaultShaders.immediateVert,
-        this._webGL2CompatibilityPrefix('frag', 'mediump') +
-        defaultShaders.vertexColorFrag
-      );
-    }
-
-    return this._defaultImmediateModeShader;
-  }
-
   baseNormalShader() {
     return this._getNormalShader();
   }

src/webgl/shaders/immediate.vert

@@ -229,65 +229,59 @@ visualSuite('WebGL', function() {
 
   visualSuite('ShaderFunctionality', function() {
     visualTest('FillShader', async (p5, screenshot) => {
-      return new Promise(async resolve => {
-        p5.createCanvas(50, 50, p5.WEBGL);
-        const img = await new Promise(resolve => p5.loadImage('unit/assets/cat.jpg', resolve));
-        const fillShader = p5.createShader(
-          `
-        attribute vec3 aPosition;
-        void main() {
-          gl_Position = vec4(aPosition, 1.0);
-        }
-        `,
-          `
-        precision mediump float;
-        void main() {
-          gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
-        }
+      p5.createCanvas(50, 50, p5.WEBGL);
+      const img = await new Promise(resolve => p5.loadImage('/unit/assets/cat.jpg', resolve));
+      const fillShader = p5.createShader(
         `
-        );
-        p5.shader(fillShader);
-        p5.lights();
-        p5.texture(img);
-        p5.noStroke();
-        p5.rect(-p5.width / 2, -p5.height / 2, p5.width, p5.height);
-        screenshot();
-        resolve();
-      });
+      attribute vec3 aPosition;
+      void main() {
+        gl_Position = vec4(aPosition, 1.0);
+      }
+      `,
+        `
+      precision mediump float;
+      void main() {
+        gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+      }
+      `
+      );
+      p5.shader(fillShader);
+      p5.lights();
+      p5.texture(img);
+      p5.noStroke();
+      p5.rect(-p5.width / 2, -p5.height / 2, p5.width, p5.height);
+      screenshot();
     });
 
     visualTest('StrokeShader', (p5, screenshot) => {
-      return new Promise(resolve => {
-        p5.createCanvas(50, 50, p5.WEBGL);
-        // Create a stroke shader with a fading effect based on distance
-        const strokeshader = p5.baseStrokeShader().modify({
-          'Inputs getPixelInputs': `(Inputs inputs) {
-          float opacity = 1.0 - smoothstep(
-            0.0,
-            15.0,
-            length(inputs.position - inputs.center)
-          );
-          inputs.color *= opacity;
-          return inputs;
-        }`
-        });
-
-        p5.strokeShader(strokeshader);
-        p5.strokeWeight(15);
-        p5.line(
-          -p5.width / 3,
-          p5.sin(p5.millis() * 0.001) * p5.height / 4,
-          p5.width / 3,
-          p5.sin(p5.millis() * 0.001 + 1) * p5.height / 4
+      p5.createCanvas(50, 50, p5.WEBGL);
+      // Create a stroke shader with a fading effect based on distance
+      const strokeshader = p5.baseStrokeShader().modify({
+        'Inputs getPixelInputs': `(Inputs inputs) {
+        float opacity = 1.0 - smoothstep(
+          0.0,
+          15.0,
+          length(inputs.position - inputs.center)
         );
-        screenshot();
-        resolve();
+        inputs.color *= opacity;
+        return inputs;
+      }`
       });
+
+      p5.strokeShader(strokeshader);
+      p5.strokeWeight(15);
+      p5.line(
+        -p5.width / 3,
+        p5.sin(p5.millis() * 0.001) * p5.height / 4,
+        p5.width / 3,
+        p5.sin(p5.millis() * 0.001 + 1) * p5.height / 4
+      );
+      screenshot();
     });
 
     visualTest('ImageShader', async (p5, screenshot) => {
       p5.createCanvas(50, 50, p5.WEBGL);
-      const img = await new Promise(resolve => p5.loadImage('unit/assets/cat.jpg', resolve));
+      const img = await new Promise(resolve => p5.loadImage('/unit/assets/cat.jpg', resolve));
       const imgShader = p5.createShader(
         `
       precision mediump float;

src/webgl/shaders/vertexColor.frag

@@ -123,13 +123,11 @@ suite('p5.Shader', function() {
       var expectedUniforms = [
         'uModelViewMatrix',
         'uProjectionMatrix',
-        /*'uResolution',*/
-        'uPointSize'
       ];
 
       testShader(
         'Immediate Mode Shader',
-        myp5._renderer._getImmediateModeShader(),
+        myp5._renderer._getColorShader(),
         expectedAttributes,
         expectedUniforms
       );
@@ -154,7 +152,7 @@ suite('p5.Shader', function() {
       myp5.fill(0);
       var retainedColorShader = myp5._renderer._getColorShader();
       var texLightShader = myp5._renderer._getLightShader();
-      var immediateColorShader = myp5._renderer._getImmediateModeShader();
+      var immediateColorShader = myp5._renderer._getColorShader();
       var selectedRetainedShader = myp5._renderer._getFillShader();
       var selectedImmediateShader = myp5._renderer._getFillShader();