Addresses issue #6587 #6665

Garima3110 · 2023-12-27T07:22:54Z

Addresses issue: Use Cubemaps for Light Feature Performance Improvement #6587

Changes to this solution are still in progress.
I would love to have suggestions to this . Thank you..!

PR Checklist

npm run lint passes
Inline documentation is included / updated
Unit tests are included / updated

davepagurek · 2023-12-28T16:01:19Z

@diyaayay looks like the PR is up here! I'm also going to give it a review soon when I get the chance, but it would be great to get your take on it too!

davepagurek

Thanks for taking this on! I've added some comments here on some bits I think we'll need in order to make this work on WebGL 1 and WebGL 2.

Also once the pieces are all working, it would be great to make a p5 editor sketch using a newly built version of p5 so that we can test it out!

davepagurek · 2023-12-28T19:07:27Z

src/webgl/p5.RendererGL.js

      );
    }
+    // Create a shader for cubemap conversion
+    const cubemapShader = this._pInst.createShader(


Just above this, we create and cache a shader so that we only ever need one copy. Can we add that caching here too?

I have applied caching mechanism to possibly all the shaders. I am not sure whether this aligns with what you were suggesting through this @davepagurek .PLease have a look into the changes I've made.
Thanks.!

I think we don't want to wrap all the existing shader sources in a caching function, since those are just the sources for one part of a shader (e.g. just the vertex or fragment source, and often not the full source either, since we need to add a prefix to it.) A caching function would be good for this createShader call (since you're still creating a new shader every time this line is hit, currently.) A few lines up, this.diffusedShader already does caching, but can be refactored to use the same caching system you use here if you're factoring that out into a common pattern.

oh actually I see that you've added that in _getCubemapShader. I think rather than making a new shader here, we can just use const cubemapShader = this._getCubemapShader() instead.

davepagurek · 2023-12-28T19:12:07Z

src/webgl/p5.Texture.js

    : gl.getExtension('OES_texture_half_float');
  const supportsHalfFloatLinear = supportsHalfFloat &&
    gl.getExtension('OES_texture_half_float_linear');
+  const supportsCubemap = gl.getExtension('OES_texture_cube_map');


I think this might only be necessary for WebGL 1, is that something you can double check? If it's built into WebGL2, then this line would be supportsCubemap = webglVersion === constants.WEBGL2 || gl.getExtesion('OES_texture_cube_map')

yes , You are absolutely correct .
WebGL2 supports cubemap textures natively, so we don't need to explicitly check for the OES_texture_cube_map extension in most cases.
Mybad!
I'll just update this one too.

davepagurek · 2023-12-28T19:16:00Z

src/webgl/shaders/cubeFragment.glsl

+
+const vec2 invAtan = vec2(0.1591, 0.3183);
+
+vec2 SampleSphericalMap(vec3 v)


Might be worth adding a comment mentioning https://learnopengl.com/PBR/IBL/Diffuse-irradiance as a source so that we can refer back to it in the future

davepagurek · 2023-12-28T19:22:52Z

src/webgl/shaders/cubeFragment.glsl

@@ -0,0 +1,23 @@
+#version 330 core


Right now this shader will only work in WebGL 2 mode. For shaders we want to work in both versions, we add these macros to the start https://github.com/processing/p5.js/blob/main/src/webgl/shaders/webgl2Compatibility.glsl by concatenating it here:

p5.js/src/webgl/p5.RendererGL.js

Lines 83 to 85 in bda63ff

for (const key in defaultShaders) {

defaultShaders[key] = webgl2CompatibilityShader + defaultShaders[key];

}

...and by adding an appropriate prefix for the vertex/fragment shaders like this:

p5.js/src/webgl/p5.RendererGL.js

Lines 1745 to 1748 in bda63ff

this._defaultLightShader = new p5.Shader(

this,

this._webGL2CompatibilityPrefix('vert', 'highp') +

defaultShaders.lightVert,

To make this file use it, it would involve taking out the #version (that's added by the prefix we add), and replacing out and in with the macros OUT and IN which get #defined to the appropriate keyword depending on what WebGL version is being used. It also means not explicitly declaring out vec4 FragColor and instead using OUT_COLOR, which we also automatically add a definition for.

davepagurek · 2023-12-28T19:23:19Z

src/webgl/shaders/lighting.glsl

 uniform bool uUseImageLight;
 // texture for use in calculateImageDiffuse
-uniform sampler2D environmentMapDiffused;
+uniform sampler2D environmentMapDiffusedCubemap;


Should this be samplerCube?

davepagurek · 2023-12-28T19:26:14Z

src/webgl/shaders/lighting.glsl

  vec3 worldNormal = normalize(vNormal);
  vec2 newTexCoor = mapTextureToNormal( worldNormal );
-  vec4 texture = TEXTURE( environmentMapDiffused, newTexCoor );
+  vec4 texture = textureCube( environmentMapDiffusedCubemap, newTexCoor );


Previously, we were using the TEXTURE, which refers to a macro in https://github.com/processing/p5.js/blob/main/src/webgl/shaders/webgl2Compatibility.glsl to be either texture2D in WebGL1, or texture in WebGL2.

We need to do something similar for cubemap textures. In that file we'd have to #define TEXTURE_CUBE to either be textureCube in WebGL 1, or just texture in WebGL 2, and then use TEXTURE_CUBE(...) here.

Garima3110 · 2023-12-29T03:26:51Z

Thanks a lot @davepagurek for these suggestions ! I'll just look into these and get back to you soon.

davepagurek · 2023-12-30T14:49:43Z

src/webgl/p5.RendererGL.js

 defineStrokeJoinEnum('BEVEL', 2);

-const lightingShader = readFileSync(
+const getCachedShader= (shaderKey, shaderSource)=>{


I think this would need to be not just a const, but a property on p5.RendererGL, as each instance of a renderer will need its own shaders. We just want the ability to share those shaders within the renderer.

davepagurek · 2023-12-30T14:55:31Z

src/webgl/p5.RendererGL.js

-);
-const webgl2CompatibilityShader = readFileSync(
+));
+const webgl2CompatibilityShader = getCachedShader('webgl2CompatibilityShader',readFileSync(


I don't think we want to wrap all of these in getCachedShader -- these are not full shaders, just pieces of shader source that will combine with other pieces later to turn into a full shader.

davepagurek · 2023-12-30T14:56:56Z

src/webgl/p5.RendererGL.js

-const lightingShader = readFileSync(
+const getCachedShader= (shaderKey, shaderSource)=>{
+  if(!shaderCache[shaderKey]){
+    shaderCache[shaderKey]=p5.createShader(shaderSource);


Shaders also have both a vertex and a fragment shader, not a single shader source, so you'd need to add two parameters to the function and pass both into createShader.

That said, your _getCubemapShader implementation on its own does all the caching we need, so we might not need this in addition to that.

davepagurek · 2023-12-30T14:58:59Z

src/webgl/p5.Shader.js

          uniform.texture.src._animateGif(this._renderer._pInst);
        }
        break;
+      case gl.SAMPLER_CUBE:


Is this block the same as the one above? If so, we could do:

case gl.SAMPLER_2D: case gl.SAMPLER_CUBE: gl.activeTexture(gl.TEXTURE0 + uniform.samplerIndex); uniform.texture = data instanceof p5.Texture ? data : this._renderer.getTexture(data); // ...

...to handle both cases with the same code

davepagurek

Thanks for working on these changes! I left a few notes on the shader caching. I think if you were to try running this right now on a sketch using imageLight(), you'd run into some runtime errors. For next steps, I'd encourage you to try making a test sketch, running grunt browserify to generate lib/p5.js, then using that in the sketch to test out whether everything still runs. That will help ensure that you catch all the issues that one might run into when using the feature more easily than just looking at the code.

Once that's working, it would also be great to put that up in a p5 editor sketch so people looking at the PR can also test it out!

Garima3110 · 2023-12-30T16:38:33Z

Once that's working, it would also be great to put that up in a p5 editor sketch so people looking at the PR can also test it out!

Yeah sure @davepagurek ..!Thankyou for the suggestions , I'll just make these changes and get back to you soon :-)

Garima3110 · 2024-01-03T09:18:30Z

Once that's working, it would also be great to put that up in a p5 editor sketch so people looking at the PR can also test it out!

Hey @davepagurek ! I tried running this test sketch after building p5.js

let cubemap;
function preload() {
  // Load cubemap texture images
  let imgPaths = [
    '1/px.png',
    '1/nx.png',
    '1/py.png',
    '1/ny.png',
    '1/pz.png',
    '1/nz.png'
  ];

  cubemap = [];
  for (let i = 0; i < 6; i++) {
    cubemap[i] = loadImage(imgPaths[i]);
  }
}

function setup() {
  createCanvas(100, 100, WEBGL);
}
function draw() {
  background(220);
  imageMode(CENTER);
  push();
  translate(0, 0, -200);
  scale(2);
  image(cubemap[2], 0, 0, width, height);
  pop();
  ambientLight(50);
  const cubemapTexture=new CubemapTexture(WEBGL,cubemap,{});
  imageLight(cubemapTexture);
  specularMaterial(20);
  noStroke();
  scale(2);
  rotateX(frameCount * 0.005);
  rotateY(frameCount * 0.005);
  box(25);
}

Sketch:
https://editor.p5js.org/Garima3110/sketches/TSRG5grku
And got this on the console window:

davepagurek · 2024-01-19T00:40:03Z

src/webgl/p5.RendererGL.js

+    );
+
+    defaultShaders = {
+      immediateVert: renderer.getCachedShader('immediateVert',readFileSync(


One issue with this current structure is that we're calling getCachedShader in the in _resetContext`, so on load, it will try to make a bunch of shaders.

We maybe want to keep the shader source code in objects outside the constructor as it was before, and then we only call getCachedShader when we need to use the shader. e.g.:

_getCubemapShader() { return this.getCachedShader( 'defaultCubemapShader', this._webGL2CompatibilityPrefix('vert', 'mediump') + defaultShaders.cubemapVertexShader, this._webGL2CompatibilityPrefix('frag', 'mediump') + defaultShaders.cubemapFragmentShader ) }

davepagurek · 2024-01-21T17:56:52Z

src/webgl/shaders/cubeFragment.frag

+void main()
+{        
+    vec2 uv = SampleSphericalMap(normalize(localPos));
+    vec3 color = texture(equirectangularMap, uv).rgb;


You might need to use the TEXTURE macro here so that this will be translated to either texture() or texture2d() based on the environment it's being run in.

davepagurek · 2024-01-21T18:04:21Z

src/webgl/shaders/lighting.glsl

  vec3 worldNormal = normalize(vNormal);
  vec2 newTexCoor = mapTextureToNormal( worldNormal );
-  vec4 texture = TEXTURE( environmentMapDiffused, newTexCoor );
+  vec4 texture = TEXTURE_CUBE( environmentMapDiffusedCubemap, newTexCoor );


I wonder if the naming of texture is an issue here since in a WebGL 2 environment, TEXTURE_CUBE is also #defined as the builtin function texture()? Does the error go away if you rename this variable?

davepagurek · 2024-01-21T18:06:34Z

src/webgl/p5.RendererGL.js

+      });
+    }
+    // Use the diffusedShader for rendering
    newFramebuffer.draw(() => {


Probably not the cause of the error you're seeing, but I think we probably no longer need this newFramebuffer.draw(...) block since we are no longer using this framebuffer as the texture. (I think that means we actually need to call newFramebuffer.free() here to avoid a small memory leak?)

davepagurek · 2024-01-21T18:07:33Z

src/webgl/p5.RendererGL.js

+        this._pInst.rect(0, 0, width, height);
+
+        // Capture the rendered face and store it in the faces array
+        faces[i] = this._pInst.get(0, 0, width, height);


Also probably not the source of the error, but we might need to put this outside of the draw(...) block, and use faces[i] = newFramebuffer.get() instead of this._pInst.get(...).

Garima3110 · 2024-01-22T18:24:51Z

Thankyou @davepagurek for your suggestions, but that fragment shader error unfortunately didn't get resolved. i'll just again have a look at what's going wrong here ..

davepagurek · 2024-01-23T00:33:52Z

src/webgl/shaders/cubeVertex.vert

@@ -0,0 +1,13 @@
+// Adapted from:  https://learnopengl.com/PBR/IBL/Diffuse-irradiance
+layout (location = 0) in vec3 aPos;


This might also need to be changed into IN vec3 aPos in order to also work in WebGL 1 environments

davepagurek · 2024-01-23T00:45:44Z

src/webgl/shaders/lighting.glsl

  vec3 worldNormal = normalize(vNormal);
  vec2 newTexCoor = mapTextureToNormal( worldNormal );
-  vec4 texture = TEXTURE( environmentMapDiffused, newTexCoor );
+  vec4 texture = TEXTURE_CUBE( environmentMapDiffusedCubemap, newTexCoor );


OH you know what the issue might be? TEXTURE_CUBE takes in a vec3 as the coordinate instead of a vec2. The compiler probably doesn't know what to do with the combination of inputs we're giving it here, and that could be causing some more errors further on.

I think we can pass the normal directly in, like: TEXTURE_CUBE(environmentMapDiffusedCubemap, worldNormal)

OH you know what the issue might be? TEXTURE_CUBE takes in a vec3 as the coordinate instead of a vec2. The compiler probably doesn't know what to do with the combination of inputs we're giving it here, and that could be causing some more errors further on.

I think we can pass the normal directly in, like: TEXTURE_CUBE(environmentMapDiffusedCubemap, worldNormal)

Yes, you're correct! In many GLSL implementations, the textureCube function takes a vec3 as the first argument, representing the 3D direction vector in the cube map space. So, using TEXTURE_CUBE(environmentMapDiffusedCubemap, worldNormal) is likely the correct way to sample from the cube map based on the normal vector.
Thanks a lot for looking into this @davepagurek !!

Garima3110 · 2024-01-26T09:36:49Z

@davepagurek I fixed some errors somehow, now I'm stuck with this one. Could you give some suggestion on this one too?!
Thankyou.
Sketch with the latest build:
https://editor.p5js.org/Garima3110/sketches/CeG_DQ1n5

davepagurek · 2024-01-28T19:19:38Z

When I run the code I'm getting a slightly different error in the console:

Looks like it's coming from this:

var captureProjection = matrixInstance.mat4.perspective(matrixInstance.mat4.get(), Math.PI / 2, 1, 0.1, 10);

It looks like that bit of the sketch isn't in your code in this PR, is the PR or the sketch possibly using out of date code?

Garima3110 · 2024-02-02T13:46:40Z

It looks like that bit of the sketch isn't in your code in this PR, is the PR or the sketch possibly using out of date code?

@davepagurek Thanks a lot for pointing this out..!

I apologise deeply for the confusion here, and for the delay too..
here are the changes:

Sketch with the latest build:
https://editor.p5js.org/Garima3110/sketches/CeG_DQ1n5

davepagurek · 2024-02-05T20:53:00Z

Looks like it's hitting an error here because gl is undefined:

I think that's because it's expecting a renderer to be passed in, but we're passing in a p5 instance instead when we do cubemapTexture=new CubemapTexture(this._pInst,faces, {});. Maybe try cubemapTexture=new CubemapTexture(this,faces, {}); instead (with just this as the first argument)?

Garima3110 · 2024-03-30T12:08:13Z

Sorry for the extreme delay @davepagurek !
No error now, But the desired result is missing,
Sketch with the latest build :https://editor.p5js.org/Garima3110/sketches/20tKjsTup
I am looking for the cause of the same, if you have any suggestions please do let me know, Thankyou!

Garima3110 · 2024-06-20T12:32:55Z

Sketch with the latest changes:
https://editor.p5js.org/Garima3110/sketches/20tKjsTup
Unfortunately, a lot of errors this time! but just wanted to show what I am upto..!

perminder-17 · 2024-06-23T20:33:32Z

src/webgl/shaders/cubeVertex.vert

+OUT vec3 localPos;
+
+uniform mat4 projection;
+uniform mat4 view;


We don't have our uniforms named projection or view, we actually had our uniforms with name uModelViewMatrix and uProjectionMatrix i think

perminder-17 · 2024-06-23T20:41:58Z

src/webgl/shaders/cubeFragment.frag

+// Adapted from: https://learnopengl.com/PBR/IBL/Diffuse-irradiance
+IN vec3 localPos;
+
+uniform sampler2D equirectangularMap;


I think you have hard-coded the value of equirectangularMap to "0" which won't work or its actually a float value.

perminder-17 · 2024-06-23T21:00:52Z

src/webgl/p5.RendererGL.js

+    // Get the cubemap shader
+    const cubemapShader = this._getCubemapShader();
+    this._pInst.shader(cubemapShader);
+    cubemapShader.setUniform('equirectangularMap', 0);


This can't be hardcoded to 0. It must have a variable, a sampler2D texture specifically.

Actually I had this in mind that in WebGL (and OpenGL), when you set a texture uniform in a shader, you also need to specify which texture unit the texture is bound to.
If you see the next 2 lines:

this.GL.activeTexture(this.GL.TEXTURE0); this.GL.bindTexture(this.GL.TEXTURE_2D, input);

Here, this.GL.activeTexture(this.GL.TEXTURE0) activates texture unit 0, and this.GL.bindTexture(this.GL.TEXTURE_2D, input) binds the texture input to texture unit 0.
But lets just keep it simple and stick to what you have suggested. That seems to work fine.!

perminder-17 · 2024-06-23T21:03:02Z

src/webgl/shaders/cubeFragment.frag

@@ -0,0 +1,22 @@
+// Adapted from: https://learnopengl.com/PBR/IBL/Diffuse-irradiance
+IN vec3 localPos;


In my opinion I feel for maximum compatibility, we can do this one in GL ES 100 instead of 300? Using attribute instead of IN, using the spacial variable gl_FragColor instead of defining an OUT_COLOR, and using texture2D() instead of texture()? What you feel?

Well I started from that only , and was getting a lot of errors and from Dave's suggestion of using the macros instead resolved the errors , I again tried doing what u have suggested today, but strangely that gives in more errors! So I think we should stick to using these macros only :-)
You can refer to Dave's suggestion here in this comment:
#6665 (comment)

Hmmm...It looks like you need to use both webgl-1 and webgl-2 modes on shaders.

perminder-17 · 2024-06-23T21:29:55Z

src/webgl/p5.RendererGL.js

      // look up the texture from the diffusedTexture map
      let diffusedLight = this.getDiffusedTexture(this.activeImageLight);
-      shader.setUniform('environmentMapDiffused', diffusedLight);
+      shader.setUniform('environmentMapDiffusedCubemap', diffusedLight);


I am not sure but I feel diffusedLight is also a sampler2D texture, could it be passed as a uniform with samplerCube texture?

Here, diffusedLight is obtained from getDiffusedTexture, which returns a CubemapTexture object. Since environmentMapDiffusedCubemap in the shader expects a cubemap texture (samplerCube), so I think diffusedLight is being correctly assigned to the environmentMapDiffusedCubemap uniform in the shader, which is of type samplerCube.

Oooh...sorry. I overlooked this, previously we had diffusedLight with sampler2D texture so I got confused. I see you have updated getDiffusedTexture()

perminder-17 · 2024-06-23T22:00:51Z

src/webgl/p5.RendererGL.js

+    let captureProjection = new p5.Matrix();
+    captureProjection.perspective(Math.PI / 2.0, 1.0, 0.1, 10.0);
+
+    cubemapShader.setUniform('projection', captureProjection.mat4);


We should not set uniforms and again create a new uniform. I think we already have our uniform named uProjectionMatrix.

perminder-17 · 2024-06-23T22:02:06Z

src/webgl/p5.RendererGL.js

+
+      this.GL.clear(this.GL.COLOR_BUFFER_BIT | this.GL.DEPTH_BUFFER_BIT);
+
+      cubemapShader.setUniform('view', captureViews[i].mat4);


Same with this. We should not calculate the view matrix. We already had set up the modelVeiw matrix as "uModelViewMatrix".

perminder-17 · 2024-06-24T09:02:33Z

From my honest opinion I feel like you don't need to work anymore on the shaders part. vertex shaders looks good, Also fragment shaders looks correct to me. The only thing I want to recheck is, are we getting the correct uniforms in fragment shaders from the CPU?

perminder-17 · 2024-06-24T09:10:37Z

src/webgl/shaders/cubeFragment.frag

+void main()
+{        
+    vec2 uv = SampleSphericalMap(normalize(localPos));
+    vec3 color = texture(equirectangularMap, uv).rgb;


I feel like, texture() works on webgl-2 and texture2D() works on webgl-1. You may use TEXTURE() to run on both the modes.

I had tried that earlier, tried that again today as per your suggestion but both give the same results.
#6665 (comment)
So i think we should go with texture only (not super sure however) :-)

hmm...what kind of errors? If you want your code to run on both environments I think TEXTURE shouldn't give errors. I don't know why? We can debug it by first writing the code for webgl-1 (changing it to GL ES 100 version I mentioned above, let me know if texture2D works there), similarly change it to version 300 and let me know if texture() works there?

Sorry if it seems a long approach for you, But I seriously don't know why TEXTURE() is giving you errors. Also, can you share me the screenshots of the errors you are getting.

perminder-17 · 2024-06-24T09:14:55Z

src/webgl/shaders/cubeVertex.vert

@@ -0,0 +1,13 @@
+// Adapted from:  https://learnopengl.com/PBR/IBL/Diffuse-irradiance
+layout (location = 0) IN vec3 aPosition;


This looks good, but I feel like do we actually need this layout(). Can it be done just with IN vec3 aPosition;

Well honestly speaking , I'm also not sure about what exactly it signifies here, but as i searched on web , I found this
If your application code (typically written in a language like C++ or JavaScript) explicitly binds attribute locations using glBindAttribLocation, you can omit the layout(location = 0) in the shader. The application code would look something like this:

glBindAttribLocation(program, 0, "aPosition");

If your application does not do this, you should keep layout(location = 0) to ensure that the attribute location is explicitly defined.

Also , just to mention , I tried running the test sketch by omitting this, and the results were similar , So I think we should keep it for a safer side as its not causing any error.
What say?!

Yes, this should not give any errors. Since, vertex shaders are just dealing with the positions, I think we don't have layout(...) at other files and they are working perfectly.

But the main reason in my mind is, since we only use layout with in we can't use it with attributes, where I think is layout used only for webgl-2? If that the case, layout should be omitted.

Garima3110 added 2 commits December 24, 2023 22:46

Extending p5.texture for cubemap textures

227fe69

Merge remote-tracking branch 'upstream/main' into cubeMap

8e2d05c

davepagurek self-requested a review December 28, 2023 16:00

Garima3110 added 4 commits December 28, 2023 21:46

Merge remote-tracking branch 'upstream/main' into cubeMap

317d915

Added vertex and fragment shaders for cubemaps

917de2f

Updated src/webgl/shaders/lighting.glsl file for cubemaps

5139c0a

Storing the diffuse irradiance in a cubemap texture

45e33d5

davepagurek reviewed Dec 28, 2023

View reviewed changes

Garima3110 added 10 commits December 29, 2023 12:56

Added caching mechanism for shaders

1d54fad

Updated caching for some shaders

1ff8702

Updated p5.Texture.js

6cd7856

Updated cubeVertex and cubeFragment shaders

4401ebd

renamed cubemap shader files

37751d9

Updated p5.RendererGL.js

93b8b50

Updated p5.Texture.js

66dc0dc

Updated lighting.glsl

cffda69

Added TEXTURE_CUBE

751b16a

Added gl.SAMPLER_CUBE uniform type to p5.Shader.js

29e7a14

davepagurek reviewed Dec 30, 2023

View reviewed changes

Garima3110 added 3 commits December 31, 2023 14:37

Merge remote-tracking branch 'upstream/main' into cubeMap

7981fdc

Minor changes in SAMPLER_CUBE uniform type

e7cd392

Minor updates on caching shaders

f30af0e

davepagurek reviewed Jan 19, 2024

View reviewed changes

Garima3110 added 2 commits January 20, 2024 23:37

Minor fixes

cc77e7e

Merge remote-tracking branch 'upstream/main' into cubeMap

518b0f0

davepagurek reviewed Jan 21, 2024

View reviewed changes

davepagurek reviewed Jan 23, 2024

View reviewed changes

Garima3110 added 4 commits January 23, 2024 10:16

Fragment shader error fixed

c124738

Merge remote-tracking branch 'upstream/main' into cubeMap

38e6e84

Minor updates

a585ef5

some fixes

f118a3b

Merge branch 'processing:main' into cubeMap

2da03d1

Minor changes

5961be8

Some changes with cubemap implementation

4515c09

perminder-17 requested changes Jun 23, 2024

View reviewed changes

perminder-17 reviewed Jun 23, 2024

View reviewed changes

Minor changes

be6d27f

perminder-17 reviewed Jun 24, 2024

View reviewed changes

Garima3110 and others added 2 commits June 24, 2024 22:17

fix

6dc9916

Merge branch 'processing:main' into cubeMap

3133e80

Garima3110 marked this pull request as draft November 2, 2024 09:09


		const vec2 invAtan = vec2(0.1591, 0.3183);

		vec2 SampleSphericalMap(vec3 v)

	for (const key in defaultShaders) {
	defaultShaders[key] = webgl2CompatibilityShader + defaultShaders[key];
	}

	this._defaultLightShader = new p5.Shader(
	this,
	this._webGL2CompatibilityPrefix('vert', 'highp') +
	defaultShaders.lightVert,

		@@ -0,0 +1,13 @@
		// Adapted from: https://learnopengl.com/PBR/IBL/Diffuse-irradiance
		layout (location = 0) in vec3 aPos;

		@@ -0,0 +1,22 @@
		// Adapted from: https://learnopengl.com/PBR/IBL/Diffuse-irradiance
		IN vec3 localPos;


		this.GL.clear(this.GL.COLOR_BUFFER_BIT \| this.GL.DEPTH_BUFFER_BIT);

		cubemapShader.setUniform('view', captureViews[i].mat4);

		@@ -0,0 +1,13 @@
		// Adapted from: https://learnopengl.com/PBR/IBL/Diffuse-irradiance
		layout (location = 0) IN vec3 aPosition;

Uh oh!

Addresses issue #6587 #6665

Are you sure you want to change the base?

Addresses issue #6587 #6665

Uh oh!

Conversation

Garima3110 commented Dec 27, 2023 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

PR Checklist

Uh oh!

davepagurek commented Dec 28, 2023

Uh oh!

davepagurek left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Garima3110 Dec 29, 2023 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Garima3110 commented Dec 29, 2023

Uh oh!

Choose a reason for hiding this comment

Uh oh!

davepagurek Dec 30, 2023 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

davepagurek left a comment

Choose a reason for hiding this comment

Uh oh!

Garima3110 commented Dec 30, 2023

Uh oh!

Garima3110 commented Jan 3, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Garima3110 commented Jan 22, 2024

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Garima3110 commented Jan 26, 2024

Uh oh!

davepagurek commented Jan 28, 2024

Uh oh!

Garima3110 commented Feb 2, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Garima3110 commented Dec 27, 2023 •

edited

Loading

Garima3110 Dec 29, 2023 •

edited

Loading

davepagurek Dec 30, 2023 •

edited

Loading

Garima3110 commented Jan 3, 2024 •

edited

Loading

Garima3110 commented Feb 2, 2024 •

edited

Loading

Garima3110 commented Mar 30, 2024 •

edited

Loading

Garima3110 commented Jun 20, 2024 •

edited

Loading

perminder-17 Jun 23, 2024 •

edited

Loading