উদাহরণ সহ GLSL ব্যবস্থাপনা

GLSL (OpenGL Shading Language) হল OpenGL-এর জন্য একটি প্রোগ্রামিং ভাষা যা GPU তে গ্রাফিক্স রেন্ডারিং শেডার (যেমন, ভেরটেক্স শেডার, ফ্র্যাগমেন্ট শেডার) লেখার জন্য ব্যবহৃত হয়। GLSL-এর মাধ্যমে আপনি vertex data, textures, lighting, shading, এবং special effects ইত্যাদির জন্য GPU-তে কাস্টম প্রোগ্রাম লিখতে পারেন।

JOGL (Java OpenGL) ব্যবহার করে আপনি Java অ্যাপ্লিকেশনে GLSL শেডার ব্যবহার করতে পারেন। GLSL শেডারকে vertex shader এবং fragment shader সহ shader program হিসেবে সেটআপ করা হয় এবং পরে OpenGL pipeline এ ব্যবহৃত হয়।

এখানে, আমরা GLSL ব্যবস্থাপনার একটি উদাহরণ দেখব যেখানে vertex shader এবং fragment shader ব্যবহার করে একটি কাস্টম শেডার প্রোগ্রাম তৈরি করা হবে।

GLSL ব্যবস্থাপনার উদাহরণ

Step 1: GLSL Shader কোড

Vertex Shader:

#version 130

in vec4 position; // Vertex position
in vec3 color; // Vertex color
out vec3 fragColor; // Color output to fragment shader

void main() {
    gl_Position = position; // Set the position of the vertex
    fragColor = color; // Pass the color to the fragment shader
}

এখানে:

• position: Vertex এর স্থান (x, y, z) সংজ্ঞায়িত করে।
• color: Vertex এর রঙ।
• fragColor: Fragment Shader এ রঙ পাঠাতে ব্যবহৃত হয়।

Fragment Shader:

#version 130

in vec3 fragColor; // Color received from vertex shader
out vec4 finalColor; // Final color output

void main() {
    finalColor = vec4(fragColor, 1.0); // Set the final color to fragment
}

এখানে:

• fragColor: Vertex Shader থেকে প্রাপ্ত রঙ।
• finalColor: ফ্র্যাগমেন্ট রেন্ডারিং এর জন্য অবজেক্টের চূড়ান্ত রঙ।

Step 2: JOGL কোডে GLSL শেডার ব্যবহৃত করা

JOGL এর মাধ্যমে vertex shader এবং fragment shader কে একটি shader program হিসাবে একত্রিত করা হয় এবং OpenGL pipeline এ রেন্ডারিং করতে ব্যবহৃত হয়।

import javax.media.opengl.*;
import javax.media.opengl.glu.GLU;
import javax.media.opengl.awt.GLCanvas;
import com.jogamp.opengl.util.FPSAnimator;
import com.jogamp.newt.event.*;

public class GLSLExample implements GLEventListener {

    private int shaderProgram;
    private int vertexShader;
    private int fragmentShader;

    @Override
    public void init(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();
        GLU glu = new GLU();

        // Initialize shaders
        vertexShader = createShader(gl, GL.GL_VERTEX_SHADER, "#version 130\nin vec4 position; in vec3 color; out vec3 fragColor; void main() { gl_Position = position; fragColor = color; }");
        fragmentShader = createShader(gl, GL.GL_FRAGMENT_SHADER, "#version 130\nin vec3 fragColor; out vec4 finalColor; void main() { finalColor = vec4(fragColor, 1.0); }");

        shaderProgram = gl.glCreateProgram();
        gl.glAttachShader(shaderProgram, vertexShader);
        gl.glAttachShader(shaderProgram, fragmentShader);
        gl.glLinkProgram(shaderProgram);
        gl.glUseProgram(shaderProgram);

        gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);  // Set background color
    }

    private int createShader(GL gl, int type, String shaderSource) {
        int shader = gl.glCreateShader(type);
        gl.glShaderSource(shader, 1, new String[]{shaderSource}, null);
        gl.glCompileShader(shader);
        return shader;
    }

    @Override
    public void display(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();
        gl.glClear(GL.GL_COLOR_BUFFER_BIT);

        // Define a simple square
        float[] vertices = {
            -0.5f,  0.5f, 0.0f,   1.0f, 0.0f, 0.0f,  // Top-left, Red
             0.5f,  0.5f, 0.0f,   0.0f, 1.0f, 0.0f,  // Top-right, Green
             0.5f, -0.5f, 0.0f,   0.0f, 0.0f, 1.0f,  // Bottom-right, Blue
            -0.5f, -0.5f, 0.0f,   1.0f, 1.0f, 0.0f   // Bottom-left, Yellow
        };

        // Set up the vertex buffer
        int vbo[] = new int[1];
        gl.glGenBuffers(1, vbo, 0);
        gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vbo[0]);
        gl.glBufferData(GL.GL_ARRAY_BUFFER, vertices.length * 4, java.nio.FloatBuffer.wrap(vertices), GL.GL_STATIC_DRAW);

        // Get location of attributes in the shader
        int positionAttrib = gl.glGetAttribLocation(shaderProgram, "position");
        int colorAttrib = gl.glGetAttribLocation(shaderProgram, "color");

        // Enable the attributes
        gl.glVertexAttribPointer(positionAttrib, 3, GL.GL_FLOAT, false, 6 * 4, 0);
        gl.glEnableVertexAttribArray(positionAttrib);
        gl.glVertexAttribPointer(colorAttrib, 3, GL.GL_FLOAT, false, 6 * 4, 3 * 4);
        gl.glEnableVertexAttribArray(colorAttrib);

        // Draw the square
        gl.glDrawArrays(GL.GL_QUADS, 0, 4);

        // Disable the attributes
        gl.glDisableVertexAttribArray(positionAttrib);
        gl.glDisableVertexAttribArray(colorAttrib);
    }

    @Override
    public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
        GL gl = drawable.getGL();
        gl.glViewport(x, y, width, height);
    }

    @Override
    public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {
        // Handle display changes if necessary
    }

    public static void main(String[] args) {
        // Set up the OpenGL canvas and window
        GLCanvas canvas = new GLCanvas();
        canvas.addGLEventListener(new GLSLExample());
        FPSAnimator animator = new FPSAnimator(canvas, 60);
        animator.start();
    }
}

এই কোডের মূল উপাদানগুলি:

1. createShader(): Vertex এবং Fragment shaders তৈরি করার জন্য ব্যবহৃত একটি পদ্ধতি। এতে GL.glCreateShader() ব্যবহার করে একটি শেডার তৈরি করা হয় এবং GL.glShaderSource() ব্যবহার করে শেডারের সোর্স কোড দেওয়া হয়।
2. Shader Program: Shader program তৈরি করা হয়েছে যেখানে Vertex Shader এবং Fragment Shader একত্রে সংযুক্ত করা হয়েছে।
3. Vertex Buffer: gl.glGenBuffers() এবং gl.glBufferData() ব্যবহার করে শেডার কোডে ডেটা পাঠানোর জন্য Vertex Buffer Object (VBO) তৈরি করা হয়েছে।
4. Attribute Locations: শেডারে position এবং color এর অ্যাট্রিবিউটগুলো পেয়ে, glVertexAttribPointer() ব্যবহার করে এগুলোর মান সেট করা হয়েছে।
5. Rendering: gl.glDrawArrays() ব্যবহার করে 2D গ্রাফিক্স রেন্ডারিং করা হয়েছে।

সারাংশ

GLSL (OpenGL Shading Language) OpenGL রেন্ডারিং পাইপলাইনে কাস্টম শেডার কোড লিখতে ব্যবহৃত হয়। JOGL এর মাধ্যমে Java অ্যাপ্লিকেশন থেকে OpenGL শেডার ব্যবহার করা যায়। উপরে দেওয়া উদাহরণে আমরা vertex shader এবং fragment shader ব্যবহার করে একটি সাদা স্কয়ার রেন্ডার করেছি, যেখানে প্রতিটি ভেরটেক্সে বিভিন্ন রঙ প্রয়োগ করা হয়েছে। GLSL ব্যবস্থাপনা কাস্টম গ্রাফিক্স এবং শেডিং প্রক্রিয়া উন্নত করতে সক্ষম, বিশেষ করে 3D গ্রাফিক্স এবং গেম ডেভেলপমেন্টে।