glsl

I am trying to understand the dFdx and dFdy functions in GLSL. I understand the following: The derivative is the rate of change The partial derivative of a function with two parameters is when you differentiate the function while keeping one of the parameters constant. dFdx and dFdy find the rate that a value changes between the current fragment and a neighboring fragment. I don't understand what the rate of change is referring to. Is it the rate of change of fragment coordinates? Could it possibly be that you can find the rate of change of an arbitrary variable between two invokations of the

I'm working on a shader manager architecture and I have several questions for more advanced people. My current choice oppose two designs which are: 1. Per material shader program => Create one shader program per material used in the program. Potential cons: Considering every object might have its own material, it involves a lot of glUseProgram calls. Implies the creation of a lot of shaderprogram objects. More complex architecture that #2. Pros: Shader code can be generated specifically for each "options" used in the material. If i'm not wrong, uniforms have to be set only one time (when the

I've been knocking around Shadertoy - https://www.shadertoy.com/ - recently, in an effort to learn more about OpenGL and GLSL in particular. From what I understand so far, the OpenGL user first has to prepare all the geometry to be used and configure the OpenGL server (number of lights allowed, texture storage, etc). Once that's done, the user then has to provide at least one vertex shader program, and one fragment shader program before an OpenGL program compiles. However, when I look at the code samples on Shadertoy, I only ever see one shader program, and most of the geometry used appears to

I'm coding a small rendering engine with GLSL shaders: Each Mesh (well, submesh) has a number of vertex streams (eg. position,normal,texture,tangent,etc) into one big VBO and a MaterialID. Each Material has a set of textures and properties (eg. specular-color, diffuse-color, color-texture, normal-map,etc) Then I have a GLSL shader, with it's uniforms and attributes. Let's say: uniform vec3 DiffuseColor; uniform sampler2D NormalMapTexture; attribute vec3 Position; attribute vec2 TexCoord; I'm a little bit stuck in trying to design a way for the GLSL shader to define the stream mappings

I'm looking for some kind of tool to work with GLSL. I want to experiment with shaders in the WebGL application, so what I'm looking for is something like RenderMonkey. As far as I know - RenderMonkey is not supported anymore, so there must be some other tool that took it's place. The best would be if I could do both the "effect composing" like RM and the raw GLSL code development. George Profenza Looking forward to see some nice answers. In the meantime, I recommend having a play with ShaderToy and FractalLab It's not a full IDE, but the WebGL inspector browser extension by benvanik seems

I've seen this pseudo-random number generator for use in shaders referred to here and there around the web : float rand(vec2 co){ return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); } It's variously called "canonical", or "a one-liner I found on the web somewhere". What's the origin of this function? Are the constant values as arbitrary as they seem or is there some art to their selection? Is there any discussion of the merits of this function? EDIT: The oldest reference to this function that I've come across is this archive from Feb '08 , the original page now being gone from

this is my opengl-es 2.0 code : { for (surfnum=0;surfnum<surftotal;surfnum++){ for (i=0;i<triNum[surfnum];i++){ GLfloat *Vertices[] = { triArray[surfnum][i].normpt1, triArray[surfnum][i].normpt2,triArray[surfnum][i].normpt3}; glGenBuffers(1, &ui32Vbo); glBindBuffer(GL_ARRAY_BUFFER, ui32Vbo); unsigned int uiSize = 3 * (sizeof(GLfloat) * 1); glBufferData(GL_ARRAY_BUFFER, uiSize,*Vertices, GL_STATIC_DRAW); } } } for(int i = 0; i < 80000; ++i) { glClear(GL_COLOR_BUFFER_BIT); int i32Location = glGetUniformLocation(uiProgramObject, "projmatrix"); glUniformMatrix4fv( i32Location, 1, GL_FALSE,

I have a 360 texture in Equirectangular Projection. With what GLSL shader can I convert it into a azimuthal equidistant projection ? See also: http://earth.nullschool.net/#current/wind/isobaric/500hPa/azimuthal_equidistant=24.64,98.15,169 I would do it in Fragment shader. bind Equirectangular texture as 2D texture bind projection shader draw Quad covering the screen or target texture store or use the result. In Vertex shader I would: Just pass the vertex coordinates as varying to fragment shader (no point using matrices here you can directly use x,y coordinates in range <-1,+1> ) In fragment