glsl | GLSL parser for Rust | Parser library

Consider the simple shader below (header over to shadertoy.com/new and paste the code to try it out).

Basically, I'm trying to figure out if it is possible to tweak the dot() version to get the exact same result for these two function calls:

In the attempt to get diffuse lighting correct, I read several articles and tried to apply them as close as possible.

However, even if the transform of normal vectors seems close to be right, the lighting still slides slightly over the object (which should not be the case for a fixed light).

Note 1: I added bands based on the dot product to make the problem more apparent.
Note 2: This is not Sauron eye.

In the image two problems are apparent:

1. The normal is affected by the projection matrix: when the viewport is horizontal, the normals display an elliptic shading (as in the image). When the viewport is vertical (height>width), the ellipse is vertical.
2. The shading move over the surface when the camera is rotated around the object.This is not much visible with normal lighting, but get apparent when projecting patterns from the light source.

Code and attempts:

Unfortunately, a minimal working example get soon very large, so I will only post relevant code. If this is not enough, as me and I will try to publish somewhere the code.

In the drawing function, I have the following matrix creation:

Let's first acknowledge that OpenGL is deprecated by Apple, that the last supported version is 4.1 and that that's a shame but hey, we've got to move forward somehow and Vulkan is the way :trollface: Now that that's out of our systems, let's have a look at this weird bug I found. And let me be clear that I am running this on an Apple Silicon M1, late 2020 MacBook Pro with macOS 11.6. Let's proceed.

I've been following LearnOpenGL and I have published my WiP right here to track my progress. All good until I got to textures. Using one texture was easy enough so I went straight into using more than one, and that's when I got into trouble. As I understand it, the workflow is more or less

• load pixel data in a byte array called textureData, plus extra info
• glGenTextures(1, &textureID)
• glBindTexture(GL_TEXTURE_2D, textureID)
• set parameters at will
• glTexImage2D(GL_TEXTURE_2D, ... , textureData)
• glGenerateMipmap(GL_TEXTURE_2D) (although this may be optional)

which is what I do around here, and then

• glUniform1i(glGetUniformLocation(ID, "textureSampler"), textureID)
• rinse and repeat for the other texture

and then, in the drawing loop, I should have the following:

• glUseProgram(shaderID)
• glActiveTexture(GL_TEXTURE0)
• glBindTexture(GL_TEXTURE_2D, textureID)
• glActiveTexture(GL_TEXTURE1)
• glBindTexture(GL_TEXTURE_2D, otherTextureID)

I then prepare my fancy fragment shader as follows:

Does the attribindex in glVertexAttribFormat correspond with the layout location in my GLSL vertex shader?

i.e. if I write

I have started building a mandelbrot viewer application with WebGL2 and JavaScript and am trying to implement series approximation at a basic level. I'm currently getting weird/distored/incomplete images depending on the number of iterations and the reference point I'm using (currently just the center of the viewport in the complex plane).

I don't have a heavy math background so it's entirely possible (apparent) that I've screwed up my calculations somewhere. I know there are separate concerns with choosing reference points, the number of iterations that can be done with the coefficients without distorting the image, etc., but I'm just trying to see the basic concept working. Currently I am only skipping 1 iteration with a reference point near the origin (-0.5, 0.0), and I don't think the result is supposed to be this distorted.

If someone is able to see and explain to me where the logic in the code has gone wrong to produce this result I would greatly appreciate it. I'll try to include all of the relevant code, including the fragment shader and JavaScript code so you should have all the information needed.

fragment.glsl

I have read and pieced multiple projects together in order to create an x11 window with open gl working, with the preinstalled GL/gl.h and GL/glx.h. The problem I get is that the triangles I want to draw to the screen does not show. What I think is that I have not setup any projecting parameters etc, or that the triangles doesn't get drawn to the space I want to draw to.

I do get a window and I am able to setup xevents that triggers after I have subscribed with eventmasks. Pressing 'esc' key will trigger an event which will in the end call Shutdown() and break the loop, free up x11 and gl stuff, and lastly exit the program. So the only thing that doesn't work is the drawing to screen stuff which basically is the main point of my program.

How can I resolve this?

main.cpp:

As I understand it (correct me if I'm wrong) I can share data between a compute shader and a vertex shader by binding both to the same buffer.

The vertex program is able to display my particles which are drawn as points but they are not being updated by the compute shader. I assume that I've simply missed something obvious but I can't for the life of me see it.

Fragment Shader:

I'm trying to create an underwater filter by utilizing shaders in SparkAR. My filter looks like intended in SparkAR, but not at all when tested in Instagram. Here is a comparison, SparkAR on the left, Instagram on the right:

I thought it had something to do with the resolution, so I tried everything there already: upscaling, calculating the UVs by using getModelViewProjectionMatrix() instead of getRenderTargetSize(), etc.

Nothing worked, so I hope someone here has experienced something similar and can help me out!

Here is the shader code used:

I have the following challenge. I am doing a series of experiments in graphics where I need to author sdf functions. These functions must exist in glsl and c++ simultaneously for different purposes. Said otherwise, in both glsl and c++ there must be a function SdfFunction that computes the exact same SDF.

Current possible approaches:

• Author the function twice by hand. This super slow and very prone to error.
• Make a parser script that must be run to convert glsl code into C++ or vice versa. This suffers from only working at build time and needing an additional programming language (to make it portable).
• Have the C++ code itself parse the files. Then compile a dynamic loaded library and link at runtime to the generated files. I have no idea how to actually do this one and it sounds very messy.

Do I have an alternative?