Remove debug logs from the Shader Generator file

preview/global/sketch.js

@@ -7,12 +7,15 @@ let myModel;
 let starShader;
 let starStrokeShader;
 let stars;
+let ditheringShader;
+let originalFrameBuffer;
+let blurredFrameBuffer;
 
 function starShaderCallback() {
   const time = uniformFloat(() => millis());
   getWorldInputs((inputs) => {
     inputs.position.y += instanceID() * 20 - 1000;
-    inputs.position.x += 40*sin(time * 0.001 + instanceID());
+    inputs.position.x += 40 * sin(time * 0.001 + instanceID());
     return inputs;
   });
   getObjectInputs((inputs) => {
@@ -21,30 +24,71 @@ function starShaderCallback() {
   })
 }
 
+function ditheringCallback() {
+  const time = uniformFloat(() => millis())
+
+  function rand(co) {
+    return fract(sin(dot(co, [12.9898, 78.233])) * 43758.5453);
+  }
+
+  function grayscale(col) {
+    return dot([col.x, col.y, col.z], [0.21, 0.72, 0.07])
+  }
+
+  getColor((input, canvasContent) => {
+    let col = texture(canvasContent, input.texCoord);
+    col.z = 0.55;
+    col += rand(input.texCoord +  time/10000000000) * 0.15 - 0.05;
+    let greyscaleValue = grayscale(col);
+    col.x = greyscaleValue
+    col.y = greyscaleValue
+    return col;
+  });
+}
+
+function bloom() {
+  const blurred = uniformTexture(() => blurredFrameBuffer);
+  const original = uniformTexture(() => originalFrameBuffer);
+
+  getColor((input, canvasContent) => {
+    const blurredCol = texture(blurred, input.texCoord);
+    const originalCol = texture(original, input.texCoord);
+    const brightPass = max(originalCol - 0.0, 0.0) * 3.0;
+    // const bloom = original + blurred * brightPass;
+    // return bloom;
+    return texture(blurred, input.texCoord) + texture(original, input.texCoord);
+  });
+}
+
 async function setup(){
   createCanvas(windowWidth, windowHeight, WEBGL);
-  stars = buildGeometry(() => sphere(20, 7, 4))
+  stars = buildGeometry(() => sphere(20, 3, 3))
   starShader = baseMaterialShader().modify(starShaderCallback); 
   starStrokeShader = baseStrokeShader().modify(starShaderCallback)
+  ditheringShader = baseFilterShader().modify(ditheringCallback);
+  originalFrameBuffer = createFramebuffer();
+  blurredFrameBuffer = createFramebuffer();
+  bloomShader = baseFilterShader().modify(bloom);
 }
 
 function draw(){
-  background(0,200,240);
+  originalFrameBuffer.begin();
   orbitControl();
-  // noStroke();
-
+  background(0,0,0);
   push();
   stroke(255,0,255)
   fill(255,200,255)
   strokeShader(starStrokeShader)
   shader(starShader);
   model(stars, 100);
   pop();
-  push();
-  shader(baseMaterialShader());
-  noStroke();
-  rotateX(HALF_PI);
-  translate(0, 0, -250);
-  plane(10000)
-  pop();
+  originalFrameBuffer.end();
+
+  blurredFrameBuffer.begin();
+    image(originalFrameBuffer, -windowWidth/2, -windowHeight/2)
+    filter(BLUR)
+  blurredFrameBuffer.end();
+
+  // image(originalFrameBuffer, -windowWidth/2, -windowHeight/2)
+  filter(bloomShader);
 }

src/webgl/ShaderGenerator.js

@@ -36,8 +36,6 @@ function shadergenerator(p5, fn) {
       }
       const generator = new ShaderGenerator(generatorFunction, this, options.srcLocations)
       const generatedModifyArgument = generator.generate();
-      console.log("SRC STRING: ", generatorFunction);
-      console.log("NEW OPTIONS:", generatedModifyArgument)
       return oldModify.call(this, generatedModifyArgument);
     }
     else {
@@ -479,7 +477,6 @@ function shadergenerator(p5, fn) {
     }
   }
 
-  // TODO: Correct the implementation for floats/ genType etc
   class ModulusNode extends BinaryOperatorNode {
     constructor(a, b) {
       super(a, b);
@@ -616,7 +613,6 @@ function shadergenerator(p5, fn) {
 
       Object.keys(availableHooks).forEach((hookName) => {
         const hookTypes = originalShader.hookTypes(hookName);
-        console.log(hookTypes);
         this[hookTypes.name] = function(userCallback) {
           // Create the initial nodes which are passed to the user callback
           // Also generate a string of the arguments for the code generation
@@ -779,14 +775,6 @@ function shadergenerator(p5, fn) {
   // GLSL Built in functions
   // Add a whole lot of these functions.
   // https://docs.gl/el3/abs
-  //  In reality many of these have multiple overrides which will need to address later.
-  // Also, their return types depend on the genType which will need to address urgently
-  //      genType clamp(genType x,
-  //                    genType minVal,
-  //                    genType maxVal);
-  //      genType clamp(genType x,
-  //                    float minVal,
-  //                    float maxVal);
   const builtInGLSLFunctions = {
     //////////// Trigonometry //////////
     'acos': { args: ['genType'], returnType: 'genType', isp5Function: true},
@@ -821,12 +809,12 @@ function shadergenerator(p5, fn) {
     // 'isnan': {},
     'log': { args: ['genType'], returnType: 'genType', isp5Function: true},
     'log2': { args: ['genType'], returnType: 'genType', isp5Function: false},
-    'max': { args: ['genType'], returnType: 'genType', isp5Function: true},
-    'min': { args: ['genType'], returnType: 'genType', isp5Function: true},
-    'mix': { args: ['genType'], returnType: 'genType', isp5Function: false},
+    'max': { args: ['genType', 'genType'], returnType: 'genType', isp5Function: true},
+    'min': { args: ['genType', 'genType'], returnType: 'genType', isp5Function: true},
+    'mix': { args: ['genType', 'genType', 'genType'], returnType: 'genType', isp5Function: false},
     // 'mod': {},
     // 'modf': {},
-    'pow': { args: ['genType'], returnType: 'genType', isp5Function: true},
+    'pow': { args: ['genType', 'genType'], returnType: 'genType', isp5Function: true},
     'round': { args: ['genType'], returnType: 'genType', isp5Function: true},
     'roundEven': { args: ['genType'], returnType: 'genType', isp5Function: false},
     // 'sign': {},
@@ -853,7 +841,6 @@ function shadergenerator(p5, fn) {
   Object.entries(builtInGLSLFunctions).forEach(([functionName, properties]) => {
     if (properties.isp5Function) {
       const originalFn = fn[functionName];
-
       fn[functionName] = function (...args) {
         if (GLOBAL_SHADER?.isGenerating) {
           return new FunctionCallNode(functionName, args, properties)