Member Avatar for dark_sider_1

Hi there,

I'm sorry if this is a vague question, but I've just been assigned to create a color animation project with GLSL, and I've never really used it before. The criteria for the assignment is that the animation should depend on object coordinates, vary over time
and should use shaders and GLSL. Basically, we make an object and the colors change on its surface. In no way am I asking on what the code is like or anything, but do you have any suggestions on where to look to start researching on how to do it? Or theoretical steps to designing this program? I don't even really know much of where to start with this. :(

Thanks for your help!

  • 4 Contributors
  • 6 Replies
  • 292 Views
  • 5 Days Discussion Span
  • Latest Post Latest Post by dark_sider_1

Dani AI

Generated

A short, practical plan that fits your assignment (depends on object coordinates, varies with time, uses GLSL), plus a tiny example to get you started.

As pointed out, the vertex shader prepares per-vertex data and the fragment shader decides final pixel color. For a color animation tied to object coordinates: pass the object/model-space position from the vertex shader to the fragment shader, provide a time uniform updated every frame from the CPU, and compute color procedurally in the fragment shader (no texture required unless you want complex noise or precomputed patterns). The posts from and are good starting reading for syntax and basics; the following fills in the next design steps.

Steps to implement

  1. Send vertex positions (object-space) to the GPU.
  2. Vertex shader forwards the object-space position to the fragment shader.
  3. Each frame, update a float uTime uniform from your application.
  4. Fragment shader computes color = f(objectPos, uTime) using sin, fract, smoothstep, or noise. Tune frequency/phase to taste.

Example (minimal GLSL):

#version 330 core
layout(location=0) in vec3 aPos;
uniform mat4 uMVP;
out vec3 vObjPos;
void main() {
  vObjPos = aPos;               // model/object-space position
  gl_Position = uMVP * vec4(aPos,1.0);
}
#version 330 core
in vec3 vObjPos;
uniform float uTime;
out vec4 fragColor;
void main() {
  float freq = 2.0;
  vec3 col = 0.5 + 0.5 * sin(vObjPos * freq + vec3(0.0,2.0,4.0) + uTime);
  fragColor = vec4(col, 1.0);
}

Practical tips and gotchas

  • If colors are static, confirm you update the uTime uniform each frame and use the right program before glUniform.
  • Choose coordinate space deliberately: object-space gives consistent patterns on the mesh even if the object moves; world-space or screen-space behave differently.
  • Built-in GLSL noise is unreliable across drivers — use a small noise function or a noise texture if needed.
  • For performance, move cheap ops to the vertex shader when per-pixel detail isn’t required; keep high-frequency detail in the fragment shader.

This approach meets the criteria: color depends on object coordinates, varies with time, and uses shaders — a clean foundation to experiment from.

Recommended Answers

All 6 Replies

Member Avatar for Lerner

I've never used GLSL but a simple search using Google came up with the 3 websites I use when using plain old OpenGL. Seems as good a place as any.

Member Avatar for mike_2000_17

You also should take a look at Shader Designer. This is an IDE for GLSL, I've used it in the past when I played around with shaders, it's pretty nice and easy. I think it also provides base codes to start from.

Member Avatar for dark_sider_1

Awesome, thanks so much for the links and suggestions! What kind of design am I looking for? I first use a shader to create a texture, correct? And then I have it change colors based on a certain time? How would I deal with coordinates?

Member Avatar for mike_2000_17

I first use a shader to create a texture, correct?

No. Shaders are used to transform texture(s), at least, fragment shaders do that. Shaders are basically small programs that run on the GPU. A vertex shader is a small program that runs for each vertex (point in a 3D mesh) that you render, and its job is to apply whatever transformations are necessary to prepare it to be rendered on the screen (these transformations include projecting it into a point on the screen, and other things like computing its texture coordinates, applying a bump-map to it, or even animating the vertex). After vertices are projected to a place on the screen, the OpenGL pipeline generates a number of pixels on those surfaces that should appear on the screen. The fragment shader is a small program that takes each pixel (or fragment) and performs a final transformation of the values associated to the pixel, that can include applying lighting, blending the pixel color coming from different textures, and possibly generating colors too, even animating them, and I think that's what you are asked to do.

And then I have it change colors based on a certain time?

Yes, shaders have a number of inputs, some that are fixed by OpenGL, and some that you can customize. You can use Uniforms (see ) which are like constant parameters, and Attibutes (see ) which are per-vertex values. The inputs that are fixed by OpenGL include the coordinate of the pixel on the screen and its depth, the color value, the texture coordinates, the textures themselves, and some other things. The job of the fragment shader is to take all or any of that and produce a color value to be put on the screen, and you can produce that color value any way you like, including as a function of time, including a blend of textures, etc.

How would I deal with coordinates?

You get them as inputs to the shader program. OpenGL takes care of it for you, all you have to worry about is how to use the coordinates to affect the pixel color, if that's something you want to do.

Member Avatar for dark_sider_1

Great, thank you for all of your help, mike_2000_17! Let's hope I can get this project figured out...

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.