glsl

I'd like to get a list of all the uniforms & attribs used by a shader program object. glGetAttribLocation() & glGetUniformLocation() can be used to map a string to a location, but what I would really like is the list of strings without having to parse the glsl code. Note: In OpenGL 2.0 glGetObjectParameteriv() is replaced by glGetProgramiv() . And the enum is GL_ACTIVE_UNIFORMS & GL_ACTIVE_ATTRIBUTES . NeARAZ Variables shared between both examples: GLint i; GLint count; GLint size; // size of the variable GLenum type; // type of the variable (float, vec3 or mat4, etc) const GLsizei bufSize =

I see a lot of different fragment shaders, #version 130 out vec4 flatColor; void main(void) { flatColor = vec4(0.0,1.0,0.0,0.5); } And they all use a different variable for the "out color" (in this case flatColor ). So how does OpenGL know what you're trying to do? I'm guessing this works because flatColor is the only variable defined as out , but you're allowed to add more out variables aren't you? Or would that just crash? Actually, as a test, I just ran this: #version 330 in vec2 TexCoord0; uniform sampler2D TexSampler; out vec4 x; out vec4 y; void main() { y = texture2D(TexSampler,

I have a PlaneGeometry and I'm randomly animating the vertices in order to create random spikes. I use this FragmentShader : void main() { vec3 light = vec3(cos(time),sin(time),1.0); light = normalize(light); float dProd = max(0.0, dot(vNormal, light)); gl_FragColor = vec4(dProd,dProd,dProd,1.0); } I expected to have some faces of each spike colored in black, but instead I got a solid color. I placed a Sphere on my plane and applied the same shader: When I turn the wireframe OFF : Not sure I understand what's happening on the plane?! I thought that since each spike has different normals, they

I have written a C++ program where I draw a teapot and apply lighting. It is itself simple, but I also use shaders. Simple I'm new with GLSL I just tried a simple fragment shader, but the screen output is inexplicable. In this file I initialize glew in the init method, where I also compile the vertex and fragment shader. They're in the "vertex_shader" and "fragment_shader" files. The thing you may not recognize is what's Light and Material. They're just some structs containing all info about the lights. I've tested these struct so I'm sure the work as expected. When I declare material

I'm trying to implement DepthBuffer-like functionality using OpenGL ES on Android. In other words I'm trying to get the 3D point on surface that is rendered on point [x, y] on the user device. In order to make that I need to be able to read the distance of the fragment at that given point. Answer in different circumstances: When using normal OpenGL you could achieve this by creating FrameBuffer and then attach either RenderBuffer or Texture with depth component to it. Both of those approaches use glReadPixels , with internal format of GL_DEPTH_COMPONENT to retrieve the data from the buffer

I'm creating a glow effect for car stop lights and found a shader that makes it possible to always face the camera: uniform vec3 viewVector; uniform float c; uniform float p; varying float intensity; void main() { vec3 vNormal = normalize( normalMatrix * normal ); vec3 vNormel = normalize( normalMatrix * -viewVector ); intensity = pow( c - dot(vNormal, vNormel), p ); gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 ); } This solution is quite simple and almost works. It reacts to camera movement and it would be great. BUT this element is a child of a car. The car itself

I have been trying to get a 16bit float (half-floating point) as an attribute into my GLSL vertex shader. It won't let me compile saying: error C7506: OpenGL does not define the global type half but my #version is 410 and so it should support half? Am I missing something obvious? solidpixel OpenGL and OpenGL ES define two concurrent types of precision. Storage precision in buffers Minimum computational precision used in shaders. Storage precision is defined by your vertex attribute upload, such as GL_FLOAT or GL_HALF_FLOAT . This will be the precision used to store the data in memory. Usage