2 posts - 2 participants

Read full topic

#version 330 core
out vec4 aColor;
void main(){
aColor = vec4(1.0, 0.0, 0.0, 1.0);
}

there are no errors in program compiling but on running the “app.exe” i am getting this error

ERROR::SHADER::COMPILATION_FAILED
ERROR: 0:1: ‘’ : illegal character (0x1)
ERROR: 0:1: ‘’ : illegal non-ASCII character (0xb6)
ERROR: 0:1: ‘’ : illegal non-ASCII character (0xc4)
ERROR: 0:1: ‘’ : illegal character (0x2)
WARNING: 0:1: ‘’ : #version directive missing
ERROR: 0:1: ‘PZ’ : syntax error syntax error

This is my loadShader program:

std::string loadShader(const std::string& path){

std::string result;

std::string line;

std::ifstream myFile(path.c_str());

if (myFile.is_open()) {

    while (std::getline(myFile, line)) {

        result += line + "\\n";

    }

    myFile.close();

} else {

    std::cerr << "Could not read file " << path << ". File does not exist.\\n";

}

return result;

};

this is working fine for vert.glsl .

i also tried to load vert.glsl from file and fragemt shader using

“#version 330 core\n”

    "out vec4 aColor;\\n"

    "void main()\\n"

    "{\\n"

    "    aColor = vec4(1.0f, 0.0, 0.0, 1.0);\\n"

    "}\\0";

this combo is working file .

help me where i am wrong in loading fragment shader from frag.glsl .

4 posts - 4 participants

Read full topic

I have installed opengl with arch linus’s packages via AUR and pacman repos but still get linker errors trying to compile some examples like below:

$ clang -v dials.c 
clang version 22.1.2
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
Found candidate GCC installation: /usr/bin/../lib/gcc/x86_64-pc-linux-gnu/15.2.1
Found candidate GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1
Selected GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1
Candidate multilib: .;@m64
Candidate multilib: 32;@m32
Selected multilib: .;@m64
Found HIP installation: /opt/rocm, version 7.2.53211
 "/usr/bin/clang-22" -cc1 -triple x86_64-pc-linux-gnu -emit-obj -dumpdir a- -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name dials.c -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/alek/Downloads/examples/examples -v -fcoverage-compilation-dir=/home/alek/Downloads/examples/examples -resource-dir /usr/lib/clang/22 -internal-isystem /usr/lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../x86_64-pc-linux-gnu/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -ferror-limit 19 -fmessage-length=190 -stack-protector 2 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcolor-diagnostics -faddrsig -fdwarf2-cfi-asm -o /tmp/dials-08e501.o -x c dials.c
clang -cc1 version 22.1.2 based upon LLVM 22.1.2 default target x86_64-pc-linux-gnu
ignoring nonexistent directory "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../x86_64-pc-linux-gnu/include"
ignoring nonexistent directory "/include"
#include "..." search starts here:
#include <...> search starts here:
 /usr/lib/clang/22/include
 /usr/local/include
 /usr/include
End of search list.
 "/usr/bin/ld" --hash-style=gnu --build-id --eh-frame-hdr -m elf_x86_64 -pie -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o a.out /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib64/Scrt1.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib64/crti.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/crtbeginS.o -L/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1 -L/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib64 -L/lib/../lib64 -L/usr/lib64 -L/lib -L/usr/lib /tmp/dials-08e501.o -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/crtendS.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib64/crtn.o
/usr/bin/ld: /tmp/dials-08e501.o: in function `drawCircle':
dials.c:(.text+0x15): undefined reference to `glPushMatrix'
/usr/bin/ld: dials.c:(.text+0x27): undefined reference to `glTranslatef'
/usr/bin/ld: dials.c:(.text+0x31): undefined reference to `glBegin'
/usr/bin/ld: dials.c:(.text+0x3c): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x72): undefined reference to `cos'
/usr/bin/ld: dials.c:(.text+0x9f): undefined reference to `sin'
/usr/bin/ld: dials.c:(.text+0xb9): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0xe1): undefined reference to `glEnd'
/usr/bin/ld: dials.c:(.text+0xf4): undefined reference to `glColor3f'
/usr/bin/ld: dials.c:(.text+0xfe): undefined reference to `glBegin'
/usr/bin/ld: dials.c:(.text+0x109): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x135): undefined reference to `cos'
/usr/bin/ld: dials.c:(.text+0x176): undefined reference to `sin'
/usr/bin/ld: dials.c:(.text+0x190): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x195): undefined reference to `glEnd'
/usr/bin/ld: dials.c:(.text+0x19a): undefined reference to `glPopMatrix'
/usr/bin/ld: /tmp/dials-08e501.o: in function `displayDials':
dials.c:(.text+0x1be): undefined reference to `glClear'
/usr/bin/ld: dials.c:(.text+0x1e3): undefined reference to `glColor3f'
/usr/bin/ld: dials.c:(.text+0x232): undefined reference to `glutSwapBuffers'
/usr/bin/ld: /tmp/dials-08e501.o: in function `displayButtons':
dials.c:(.text+0x24e): undefined reference to `glClear'
/usr/bin/ld: dials.c:(.text+0x258): undefined reference to `glBegin'
/usr/bin/ld: dials.c:(.text+0x2bd): undefined reference to `glColor3f'
/usr/bin/ld: dials.c:(.text+0x2d2): undefined reference to `glColor3f'
/usr/bin/ld: dials.c:(.text+0x301): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x330): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x35f): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x38e): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x3aa): undefined reference to `glEnd'
/usr/bin/ld: dials.c:(.text+0x3af): undefined reference to `glutSwapBuffers'
/usr/bin/ld: /tmp/dials-08e501.o: in function `reshape':
dials.c:(.text+0x3d9): undefined reference to `glViewport'
/usr/bin/ld: dials.c:(.text+0x3e3): undefined reference to `glMatrixMode'
/usr/bin/ld: dials.c:(.text+0x3e8): undefined reference to `glLoadIdentity'
/usr/bin/ld: dials.c:(.text+0x3fd): undefined reference to `gluOrtho2D'
/usr/bin/ld: dials.c:(.text+0x402): undefined reference to `glutGetWindow'
/usr/bin/ld: dials.c:(.text+0x422): undefined reference to `glScalef'
/usr/bin/ld: dials.c:(.text+0x436): undefined reference to `glTranslatef'
/usr/bin/ld: dials.c:(.text+0x440): undefined reference to `glMatrixMode'
/usr/bin/ld: /tmp/dials-08e501.o: in function `dodial':
dials.c:(.text+0x483): undefined reference to `glutSetWindow'
/usr/bin/ld: dials.c:(.text+0x488): undefined reference to `glutPostRedisplay'
/usr/bin/ld: /tmp/dials-08e501.o: in function `dobutton':
dials.c:(.text+0x4df): undefined reference to `glutSetWindow'
/usr/bin/ld: dials.c:(.text+0x4e4): undefined reference to `glutPostRedisplay'
/usr/bin/ld: /tmp/dials-08e501.o: in function `main':
dials.c:(.text+0x51c): undefined reference to `glutInit'
/usr/bin/ld: dials.c:(.text+0x526): undefined reference to `glutDeviceGet'
/usr/bin/ld: dials.c:(.text+0x561): undefined reference to `glutDeviceGet'
/usr/bin/ld: dials.c:(.text+0x5a4): undefined reference to `glutInitDisplayMode'
/usr/bin/ld: dials.c:(.text+0x5cb): undefined reference to `glutInitWindowSize'
/usr/bin/ld: dials.c:(.text+0x5d7): undefined reference to `glutCreateWindow'
/usr/bin/ld: dials.c:(.text+0x602): undefined reference to `glClearColor'
/usr/bin/ld: dials.c:(.text+0x60f): undefined reference to `glLineWidth'
/usr/bin/ld: dials.c:(.text+0x61f): undefined reference to `glutDialsFunc'
/usr/bin/ld: dials.c:(.text+0x62f): undefined reference to `glutButtonBoxFunc'
/usr/bin/ld: dials.c:(.text+0x63b): undefined reference to `glutDisplayFunc'
/usr/bin/ld: dials.c:(.text+0x64b): undefined reference to `glutReshapeFunc'
/usr/bin/ld: dials.c:(.text+0x657): undefined reference to `glutInitWindowSize'
/usr/bin/ld: dials.c:(.text+0x663): undefined reference to `glutCreateWindow'
/usr/bin/ld: dials.c:(.text+0x67e): undefined reference to `glClearColor'
/usr/bin/ld: dials.c:(.text+0x68a): undefined reference to `glutDisplayFunc'
/usr/bin/ld: dials.c:(.text+0x693): undefined reference to `glutReshapeFunc'
/usr/bin/ld: dials.c:(.text+0x69c): undefined reference to `glutDialsFunc'
/usr/bin/ld: dials.c:(.text+0x6a5): undefined reference to `glutButtonBoxFunc'
/usr/bin/ld: dials.c:(.text+0x6aa): undefined reference to `glutMainLoop'
clang: error: linker command failed with exit code 1 (use -v to see invocation)

4 posts - 3 participants

Read full topic

Usage: glslangValidator [option]... [file]...

Where: each 'file' ends in
    .conf to provide an optional config file that replaces the default configuration
          (see -c option below for generating a template)
    .vert for a vertex shader
    .tesc for a tessellation control shader
    .tese for a tessellation evaluation shader
    .geom for a geometry shader
    .frag for a fragment shader
    .comp for a compute shader

Compilation warnings and errors will be printed to stdout.

To get other information, use one of the following options:
(Each option must be specified separately, but can go anywhere in the command line.)
  -c  configuration dump; use to create default configuration file (redirect to a .conf file)
  -i  intermediate tree (glslang AST) is printed out
  -l  link validation of all input files
  -m  memory leak mode
  -q  dump reflection query database
  -r  relaxed semantic error-checking mode
  -s  silent mode
  -t  multi-threaded mode
  -v  print version strings
  -w  suppress warnings (except as required by #extension : warn)

3 posts - 1 participant

Read full topic

Here’s the main part where I hypothesize it lies:

unsigned int vertexShader;

if(compileVertexShader(&vertexShader, vertexShaderSource) == FAIL)
{
    return FAIL;
}

unsigned int fragmentShader;

if(compileFragmentShader(&fragmentShader, fragmentShaderSource) == FAIL)
{
    return FAIL;
}

unsigned int shaderProgram;
shaderProgram = glCreateProgram();

glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);

if(checkShaderProgramSuccess(shaderProgram) == FAIL)
{
    return FAIL;
}

glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);

unsigned int VBO;
unsigned int VAO;
unsigned int EBO;

glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);

glBindVertexArray(VAO);

glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(rectangle.vertices), rectangle.vertices, GL_STATIC_DRAW);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(rectangle.indices), rectangle.indices, GL_STATIC_DRAW);

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);

glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);

while(!glfwWindowShouldClose(window))
{
    windowRender(window, shaderProgram, VBO, EBO);

    glfwPollEvents();
}

printf("Program closing due to user input. The program ran successfully without error.\n");

cleanup();

return SUCCESS;

And here’s the entire codebase

main.c

#include "main.h"

#include "window.h"
#include "display.h"
#include "shaders.h"

// gcc Assets/Code/main.c Assets/Code/window.c Assets/Code/display.c Assets/Code/shaders.c -lGLEW -lGL -lglfw -o "Game" -Wall

const char* vertexShaderSource = "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "void main()\n"
    "{\n"
    "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
    "}\0";

const char* fragmentShaderSource = "#version 330 core\n"
    "out vec4 FragColor;\n"
    "void main()\n"
    "{\n"
    "FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
    "}\0";

GLFWwindow* window;

float test_rectangle_vertices[] = {
        0.5f,  0.5f, 0.0f,  // top right
        0.5f, -0.5f, 0.0f,  // bottom right
        -0.5f, -0.5f, 0.0f,  // bottom left
        -0.5f,  0.5f, 0.0f   // top left
    };

unsigned int test_rectangle_indices[] = {
    0, 1, 3,
    1, 2, 3
};

void cleanup()
{
    if(window)
    {
        glfwDestroyWindow(window);
    }

    glfwTerminate();
}

void print_glfw_error()
{
    const char* error_ptr;
    glfwGetError(&error_ptr);

    printf("%s\n", error_ptr);
}

void print_glew_error(GLenum error)
{
    printf("%s\n", glewGetErrorString(error));
}

bool initialize_glew()
{
    // GLAD is not very glad, GLEW is what makes me glad

    GLenum glewinit_return_value = glewInit();

    if(glewinit_return_value != GLEW_OK)
    {
        print_glew_error(glewinit_return_value);
        handle_error(true, true); // clean up, and the error was fatal

        return FAIL;
    }

    return SUCCESS;
}

void handle_error(bool is_cleanup, bool is_fatal)
{
    if(is_fatal)
    {
        printf("Fatal error. Program aborted.\n");
    }

    if(is_cleanup)
    {
        cleanup();
    }
}

void createShape(Shape* rectangle, float* shape_vertices, unsigned int*  shape_indices)
{
    printf("Creating shape...\n");

    rectangle->vertices = shape_vertices;
    rectangle->indices = shape_indices;

    printf("Shape created.\n");
}

int main()
{
    if(!glfwInit())
    {
        print_glfw_error();
        handle_error(false, true); // do not clean up, and the error was fatal
        return FAIL;
    }

    window = createWindow();

    if(window == NULL)
    {
        return FAIL;
    }

    if(initialize_glew() == FAIL)
    {
        return FAIL;
    }

    glViewport(0, 0, 1920, 1080);

    Shape rectangle;

    createShape(&rectangle, test_rectangle_vertices, test_rectangle_indices);

    unsigned int vertexShader;

    if(compileVertexShader(&vertexShader, vertexShaderSource) == FAIL)
    {
        return FAIL;
    }

    unsigned int fragmentShader;

    if(compileFragmentShader(&fragmentShader, fragmentShaderSource) == FAIL)
    {
        return FAIL;
    }

    unsigned int shaderProgram;
    shaderProgram = glCreateProgram();

    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);

    if(checkShaderProgramSuccess(shaderProgram) == FAIL)
    {
        return FAIL;
    }

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    unsigned int VBO;
    unsigned int VAO;
    unsigned int EBO;

    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);

    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(rectangle.vertices), rectangle.vertices, GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(rectangle.indices), rectangle.indices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    while(!glfwWindowShouldClose(window))
    {
        windowRender(window, shaderProgram, VBO, EBO);

        glfwPollEvents();
    }

    printf("Program closing due to user input. The program ran successfully without error.\n");

    cleanup();

    return SUCCESS;
}

display.c

#include "main.h"

// Rectangle's gone. This is depressing.

void windowRender(GLFWwindow* window, unsigned int shaderProgram, unsigned int VAO, unsigned int EBO)
{
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(shaderProgram);
    glBindVertexArray(VAO);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

    glfwSwapBuffers(window);
}

#include "main.h"

// Please stop

bool compileVertexShader(unsigned int* vertexShaderInput, const char* vertexShaderSourceInput)
{
    *vertexShaderInput = glCreateShader(GL_VERTEX_SHADER);

    glShaderSource(*vertexShaderInput, 1, &vertexShaderSourceInput, NULL);
    glCompileShader(*vertexShaderInput);

    int is_successful;
    char infoLog[512];

    glGetShaderiv(*vertexShaderInput, GL_COMPILE_STATUS, &is_successful);

    if(!is_successful)
    {
        glGetShaderInfoLog(*vertexShaderInput, 512, NULL, infoLog);
        printf("Vertex shader compilation failed. Error log is as follows:\n%s", infoLog);

        handle_error(true, true); // clean up, and the error was fatal

        return FAIL;
    }

    return SUCCESS;
}

bool compileFragmentShader(unsigned int* fragmentShaderInput, const char* fragmentShaderSourceInput)
{
    *fragmentShaderInput = glCreateShader(GL_FRAGMENT_SHADER);

    glShaderSource(*fragmentShaderInput, 1, &fragmentShaderSourceInput, NULL);
    glCompileShader(*fragmentShaderInput);

    int is_successful;
    char infoLog[512];

    glGetShaderiv(*fragmentShaderInput, GL_COMPILE_STATUS, &is_successful);

    if(!is_successful)
    {
        glGetShaderInfoLog(*fragmentShaderInput, 512, NULL, infoLog);
        printf("Fragment shader compilation failed. Error log is as follows:\n%s", infoLog);

        handle_error(true, true); // clean up, and the error was fatal

        return FAIL;
    }

    return SUCCESS;
}

bool checkShaderProgramSuccess(unsigned int shaderProgram)
{
    int is_successful;
    char infoLog[512];

    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &is_successful);

    if(!is_successful)
    {
        glGetShaderInfoLog(shaderProgram, 512, NULL, infoLog);
        printf("Shader program compilation failed. Error log is as follows:\n%s", infoLog);

        handle_error(true, true); // clean up, and the error was fatal

        return FAIL;
    }

    return SUCCESS;
}

window.c

#include "main.h"

// Hours that the rectangle has been gone. It's just black. Darkness.

GLFWwindow* createWindow()
{
    GLFWwindow* window = glfwCreateWindow(1920, 1080, "Badpa", NULL, NULL);

    if(!window)
    {
        print_glfw_error();
        handle_error(true, true); // clean up, and the error was fatal

        return NULL;
    }

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    glfwMakeContextCurrent(window);

    return window;
}

main.h

#pragma once

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#define SUCCESS 0
#define FAIL 1

void cleanup();
void handle_error(bool is_cleanup, bool is_fatal);
void print_glfw_error();
void print_glew_error(GLenum error);
bool initialize_glew();

typedef struct{
    float* vertices;
    unsigned int* indices;
} Shape;

window.h

#pragma once

GLFWwindow* createWindow();

shaders.h

#pragma once

bool compileVertexShader(unsigned int* vertexShaderInput, const char* vertexShaderSourceInput);
bool compileFragmentShader(unsigned int* fragmentShaderInput, const char* fragmentShaderSourceInput);
bool checkShaderProgramSuccess(unsigned int shaderProgram);

display.h

#pragma once

bool windowRender(GLFWwindow* window, unsigned int shaderProgram, unsigned int VAO, unsigned int EBO);

2 posts - 1 participant

Read full topic

Source code for the java software is at SusuJava (FLOSS Java sim) now uses Khronos' GLES2 (includes JNI for SDL2) - #2 by SwuduSusuwu , but guess this “occlusion mode” is not java-specific

1 post - 1 participant

Read full topic

For example, a 4x multisample pixel with stencil values like this could be resolved into a single value 1|2|4.

1|2  4
 0   1

Is this a supported feature?

2 posts - 1 participant

Read full topic

The stencil buffer is cleared like this:

glStencilMask(0xFF);
glClearNamedFramebufferfi(fbo, GL_DEPTH_STENCIL, 0, 1.0f, 0);
glStencilMask(0x1);

I prepare to draw objects like this:

glEnable(GL_STENCIL_TEST);
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
glStencilFunc(GL_ALWAYS, 1, 0xFF);
glStencilMask(0x1);

Now I get ready to draw the full-screen pass for directional lights:

glEnable(GL_STENCIL_TEST);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilFunc(GL_EQUAL, 0, 0xFF);// Background pixels get drawn to
//glStencilFunc(GL_EQUAL, 1, 0xFF);// Nothing gets drawn
glStencilMask(0);

If I use glStencilFunc(GL_EQUAL, 0, 0xFF) then the full-screen pass draws to the background pixels (where nothing has been drawn).

This indicates that the FBO is correctly set up with an active stencil buffer attached.

However, calling glStencilFunc(GL_EQUAL, 1, 0xFF) does not draw lighting on my foreground pixels (where objects have been drawn). I just get a black screen instead.

What am I doing wrong?

7 posts - 2 participants

Read full topic

I am trying to get Reverse Z working for my application but am not quite getting there. I managed to get the scene rendering again (except the skybox but I think that’s just a shader issue) but all my models are inside out and the front objects are being rendered behind the back objects. My setup is +Z forward and matrices should be column major.

I can’t quite figure it out!

I wonder if anyone would be kind enough to take a glance at some of my matrices? And setup?

I change the OpenGL stuff like this at app startup.

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_GREATER);
glClearDepth(0.0f);
glDepthRange(1.0, 0.0);

And then my perspective matrix is changed to this.

void dMat4::SetIdentity() {
    for (int i = 0; i < 16; i++) {
        data[i] = (i % 5 == 0) ? 1.0 : 0.0;
    }
}

void dMat4::SetPerspective(double fov, double aspect, double near, double far) {

    auto tanHalfFov = std::tan(fov * 0.5);

    SetIdentity();

    data[0] = 1.0 / (aspect * tanHalfFov);
    data[5] = 1.0 / tanHalfFov;

    data[10] = 0.0;
    data[11] = 1.0;

    data[14] = near;
    data[15] = 0.0;
}

I also have an GL_DEPTH_COMPONENT32 depth buffer.

Does my perspective matrix look okay? Thanks for any insight you might have.

10 posts - 2 participants

Read full topic

I feel like having a texture lookup that uses texcoords resulting from another texture lookup is something to be avoided when possible.

I think it might come from here?

6 posts - 2 participants

Read full topic

This code produces a green screen:

if (textureSamples(ColorBuffer) == 2) outColor = vec4(0,1,0,1);

Is this “1x” texture consuming the same memory and bandwidth as a 2x multisample texture? The spec makes it sounds as if 1x is supported:

samples specifies the number of samples to be used for the texture and must be greater than zero and less than or equal to the value of GL_MAX_SAMPLES.
glTexStorage2DMultisample - OpenGL 4 Reference Pages

4 posts - 2 participants

Read full topic

Ideally I want to depth cull the fragments to stop the fragment shader doing the work. The issue is I also need to use discard and other operations (like image[Load|Store]()) in the the fragment shader. I have added layout (depth_unchanged) out float gl_FragDepth; to the GLSL and never write to gl_FragDepth. But I can see that the fragment shader is still being run when it should be depth culled.

Do I need to set anything else to enable conservative depth?

Is there other operations that will disable the conservative depth that I need to be aware of?
I did fine a Vulkan reference to if the shader also writes to storage resources!

I have been testing this code against both Windows AMD and nVidia GPUs. Both showing the same behaviour. So I assume I have missed something.

Thanks.

5 posts - 3 participants

Read full topic

I’m working on a tiled GPU-based map reprojection pipeline in OpenGL (on NVIDIA). The driver frequently reports:

Pixel-path performance warning: Pixel transfer is synchronized with 3D rendering.

My pipeline streams and processes imagery in tiles. At a high level:

• Upload tile data into a texture (currently PBO + glTexSubImage2D).
• Reproject by rendering a quad into an FBO (color attachment is an GL_RGBA8 texture).
• Read back the FBO result and save it as JPEG.

The tiles that are produced and written to disk are 1024×1024. I use a ring of buffers and glFenceSync/polling so that uploads/readbacks are queued and later harvested without intentional blocking (map/copy + JPEG encode runs on a worker thread).

The warning appears in runs where the time is dominated by pixel transfers: both texture uploads and readbacks. I don’t want to assume it is only a readback issue; it seems plausible that either glTexSubImage2D (upload) or glReadPixels (readback), or their interaction/ordering, can trigger synchronization with 3D rendering. The warning always occurs on one of those calls, or on both. I see ~3,263 warnings for 3,072 output tiles (each output tile may require loading 0 to 64 input tiles). So the warning does not occur every time, and I can observe it either on glTexSubImage2D or on glReadPixels.

I also tried an alternative readback path (compute shader copies the FBO texture into a persistently mapped SSBO, then fence + memcpy + JPEG), but it did not show a clear performance improvement in quick tests (even a slight performance regression).

Question: what is the recommended NVIDIA/OpenGL approach to avoid or minimize these pixel-path synchronizations in a streaming pipeline that performs both frequent texture uploads and readbacks? Are there known best practices for buffer usage, formats/packing, synchronization/barriers, or pipeline structure that typically help prevent the driver from synchronizing pixel transfers with rendering?

Thank you in advance!

2 posts - 2 participants

Read full topic

glGetTextureHandleARB()

This one is the first arb function that appears in the program lifetime.
I’ve been trying to solve this problem since yesterday and I made sure that:
My opengl context is set properly,
Glew is initialized properly,
Before calling that function, the pointer to that function is valid,
It seems like I have bindless textures available:

[coolfede97@coolfede97 ~]$ glxinfo | grep -i "GL_ARB_bindless_texture"

    GL_ARB_bindless_texture, GL_ARB_blend_func_extended, 
    GL_ARB_bindless_texture, GL_ARB_blend_func_extended, 

The texture I pass as argument to that function is valid

I’ve got a intel gpu:

[coolfede97@coolfede97 ~]$ lspci | grep -i --color 'vga\|3d\|2d'   
00:02.0 VGA compatible controller: Intel Corporation Iris Plus Graphics G1 (Ice Lake) (rev 07)

and I use mesa:

[coolfede97@coolfede97 ~]$ pacman -Q mesa
mesa 1:25.3.3-2

I tried debugging with gdb, and it seems like the seg fault occurs when a function with an invalid pointer is called (which is strange since

 if (glGexTexutreHandleARB == nullptr) 

returns false).

Here is the gdb output:

[New Thread 0x7fffcffff6c0 (LWP 9743)]
[New Thread 0x7fffcf7fe6c0 (LWP 9744)]
Buffer of textures 2D: 1
Texture2D at path: /home/coolfede97/coding/RuamEngine/RuamEngine/assets/sprites/defaultSprite.png was loaded succesfully
About to call glGetTextureHandleARB

Thread 1 "RuamEngine" received signal SIGSEGV, Segmentation fault.
0x0000000000000000 in ?? ()
(gdb) bt
#0  0x0000000000000000 in ?? ()
#1  0x00007fffe1339ed1 in ?? () from /usr/lib/libgallium-25.3.3-arch1.2.so
#2  0x000055555558b35f in RuamEngine::Renderer::RegisterTexture (
    texture=std::shared_ptr<RuamEngine::Texture> (use count 2, weak count 0) = {...})
    at /home/coolfede97/coding/RuamEngine/RuamEngine/RuamCore/Rendering/Renderer.cpp:224
#3  0x0000555555593d5e in RuamEngine::ResourceManager::RegisterTextureInRenderer (
    texture=std::shared_ptr<RuamEngine::Texture> (use count 2, weak count 0) = {...})
    at /home/coolfede97/coding/RuamEngine/RuamEngine/RuamCore/Rendering/ResourceManager.cpp:161
#4  RuamEngine::ResourceManager::LoadTexture<RuamEngine::Texture2D> (relativePath="assets/sprites/defaultSprite.png")
    at /home/coolfede97/coding/RuamEngine/RuamEngine/RuamCore/Rendering/ResourceManager.h:35
#5  0x0000555555590dde in RuamEngine::ResourceManager::Init () at /usr/include/c++/15.2.1/bits/basic_string.tcc:248
#6  0x000055555558c6a5 in RuamEngine::Renderer::Init ()
    at /home/coolfede97/coding/RuamEngine/RuamEngine/RuamCore/Rendering/Renderer.cpp:72

3 posts - 2 participants

Read full topic

I work actually about a triangle mesh compressor that give only a little more than 6 bits per triangle
(only the topologic part, not already the geometric part)

Think you than this style of triangle compression can efficicently to be used for to speed the input of larges triangles meshes
(this give very superiors results than BELR that use about 20+ bits per triangle and seem to approch the level of Zipper that uses about 5 bpt on average, at about 6 bpt with my scheme)

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <map>
#include <algorithm>
#include <string>
#include <bitset>
#include <cstddef>

// Fonction pour lire un fichier .obj et extraire les faces
void readObjFile(const std::string &filename, std::vector<std::vector<int>> &faces) {
    std::ifstream file(filename);
    std::string line;

    while (std::getline(file, line)) {
        if (line.substr(0, 2) == "f ") {
            std::istringstream iss(line.substr(2));
            std::vector<int> face;
            int vertex;
            while (iss >> vertex) {
                face.push_back(vertex - 1); // Convertir en indice 0-based
            }
            faces.push_back(face);
        }
    }
}

// Fonction pour générer les tables L et R
void generateTables(const std::vector<std::vector<int>> &faces, std::vector<int> &L, std::vector<int> &R) {
    int num_corners = faces.size() * 3;
    L.resize(num_corners, -1);
    R.resize(num_corners, -1);

    std::map<std::pair<int, int>, std::pair<int, int>> edge_to_corners;

    // Initialiser edge_to_corners
    for (int i = 0; i < faces.size(); ++i) {
        for (int j = 0; j < 3; ++j) {
            int v1 = faces[i][j];
            int v2 = faces[i][(j + 1) % 3];
            edge_to_corners[{v1, v2}] = {i * 3 + j, i * 3 + ((j + 1) % 3)};
            edge_to_corners[{v2, v1}] = {i * 3 + ((j + 1) % 3), i * 3 + j};
        }
    }

    // Remplir la table R (cycle autour du sommet)
    for (int i = 0; i < faces.size(); ++i) {
        for (int j = 0; j < 3; ++j) {
            int corner_index = i * 3 + j;
            int next_corner_index = i * 3 + ((j + 1) % 3);
            R[corner_index] = next_corner_index;
        }
    }

    // Remplir la table L (corner opposé)
    for (int i = 0; i < faces.size(); ++i) {
        for (int j = 0; j < 3; ++j) {
            int v1 = faces[i][j];
            int v2 = faces[i][(j + 1) % 3];
            int corner_index = i * 3 + j;
            auto it = edge_to_corners.find({v2, v1});
            if (it != edge_to_corners.end() && it->second.first != corner_index) {
                L[corner_index] = it->second.first; // Corner opposé
            }
        }
    }
}

// Fonction pour compter les occurrences des incréments
std::map<int, int> countIncrementOccurrences(const std::vector<int> &L, const std::vector<int> &R) {
    std::map<int, int> totalCount;

    for (int i = 0; i < L.size(); ++i) {
        int incrementL = L[i] - i;
        totalCount[incrementL]++;

        int incrementR = R[i] - i;
        totalCount[incrementR]++;
    }

    return totalCount;
}

// Fonction pour créer un codage sur 2 bits pour les incréments fréquents
void create2BitEncoding(const std::map<int, int> &totalCount, std::map<int, std::string> &compactEncoding, std::vector<int> &frequentIncrements) {
    // Convertir les occurrences en un vecteur de paires pour le tri
    std::vector<std::pair<int, int>> sortedIncrements(totalCount.begin(), totalCount.end());
    std::sort(sortedIncrements.begin(), sortedIncrements.end(), [](const std::pair<int, int> &a, const std::pair<int, int> &b) { return a.second > b.second; });

    // Attribuer les codes sur 2 bits aux 3 incréments les plus fréquents
    compactEncoding[sortedIncrements[0].first] = "00";  // Le plus fréquent
    compactEncoding[sortedIncrements[1].first] = "01";  // Deuxième plus fréquent
    compactEncoding[sortedIncrements[2].first] = "10";  // Troisième plus fréquent
    frequentIncrements.push_back(sortedIncrements[0].first);
    frequentIncrements.push_back(sortedIncrements[1].first);
    frequentIncrements.push_back(sortedIncrements[2].first);
}

// Fonction pour encoder un tableau avec codage sur 2 bits
std::string encodeTable2Bit(const std::vector<int> &table, const std::map<int, std::string> &compactEncoding, std::vector<int> &exceptionIndices, std::vector<int> &exceptions) {
    std::string encoded;
    std::map<int, int> exceptionIndexMap;
    int currentExceptionIndex = 0;

    for (int i = 0; i < table.size(); ++i) {
        int increment = table[i] - i;
        if (compactEncoding.find(increment) != compactEncoding.end()) {
            encoded += compactEncoding.at(increment);
        } else {
            // Ajouter l'incrément à la liste des exceptions s'il n'y est pas déjà
            if (exceptionIndexMap.find(increment) == exceptionIndexMap.end()) {
                exceptionIndexMap[increment] = currentExceptionIndex++;
                exceptions.push_back(increment);
            }
            // Utiliser un code spécial pour indiquer une exception (par exemple, "11")
            encoded += "11";
            exceptionIndices.push_back(exceptionIndexMap[increment]);
        }
    }
    return encoded;
}

// Fonction pour décoder une chaîne binaire avec codage sur 2 bits
std::vector<int> decodeTable2Bit(const std::string &encoded, const std::map<std::string, int> &compactDecoding, const std::vector<int> &exceptionIndices, const std::vector<int> &exceptions) {
    std::vector<int> decoded;
    int currentIndex = 0;
    int exceptionPos = 0;

    for (size_t pos = 0; pos < encoded.size(); pos += 2) {
        if (pos + 2 > encoded.size()) {
            break; // Éviter de dépasser la taille de la chaîne
        }
        std::string code = encoded.substr(pos, 2);
        if (code == "11") {
            // Cas exceptionnel : utiliser l'index de l'exception
            if (exceptionPos < exceptionIndices.size() && exceptionIndices[exceptionPos] < exceptions.size()) {
                int increment = exceptions[exceptionIndices[exceptionPos]];
                decoded.push_back(currentIndex + increment);
                exceptionPos++;
            } else {
                std::cerr << "Erreur: Index d'exception hors limites" << std::endl;
            }
        } else {
            // Cas normal : utiliser le dictionnaire de décodage
            if (compactDecoding.find(code) != compactDecoding.end()) {
                int increment = compactDecoding.at(code);
                decoded.push_back(currentIndex + increment);
            } else {
                std::cerr << "Erreur: Code non reconnu: " << code << std::endl;
            }
        }
        currentIndex++;
    }
    return decoded;
}

// Fonction pour afficher les détails du codage
void printEncodingDetails(const std::vector<int> &table, const std::map<int, std::string> &compactEncoding, const std::vector<int> &exceptionIndices, const std::vector<int> &exceptions, const std::string &tableName) {
    std::cout << "\nDétails du codage sur 2 bits pour " << tableName << " : " << std::endl;
    int exceptionPos = 0;
    for (int i = 0; i < table.size(); ++i) {
        int increment = table[i] - i;
        if (compactEncoding.find(increment) != compactEncoding.end()) {
            std::cout << "Indice " << i << " : c" << table[i] << " (c" << (increment >= 0 ? "+" : "") << increment << ") -> "
                      << compactEncoding.at(increment) << std::endl;
        } else {
            if (exceptionPos < exceptionIndices.size()) {
                std::cout << "Indice " << i << " : c" << table[i] << " (c" << (increment >= 0 ? "+" : "") << increment << ") -> "
                          << "11 (exception index: " << exceptionIndices[exceptionPos] << ")" << std::endl;
                exceptionPos++;
            } else {
                std::cerr << "Erreur: Pas assez d'indices d'exceptions" << std::endl;
            }
        }
    }
}

// Fonction pour afficher les statistiques de compression
void printCompressionStats(const std::string &encoded, const std::vector<int> &table, const std::string &tableName) {
    int originalSizeBits = table.size() * 32; // Chaque int occupe 32 bits
    float compressionRate = (float)encoded.size() / originalSizeBits * 100;

    std::cout << "\nChaîne binaire encodée pour " << tableName << " : " << encoded << std::endl;
    std::cout << "Longueur de la chaîne binaire : " << encoded.size() << " bits (au lieu de " << originalSizeBits << " bits)" << std::endl;
    std::cout << "Taux de compression par rapport aux indices non compressés : " << compressionRate << "%" << std::endl;
}

// Fonction pour afficher la table des exceptions
void printExceptionTable(const std::vector<int> &exceptions) {
    std::cout << "\nTable des exceptions : " << std::endl;
    for (size_t i = 0; i < exceptions.size(); ++i) {
        std::cout << "Index " << i << " : c" << (exceptions[i] >= 0 ? "+" : "") << exceptions[i] << std::endl;
    }
}

int main(int argc, char* argv[]) {
    if (argc != 2) {
        std::cerr << "Usage: " << argv[0] << " <fichier.obj>" << std::endl;
        return 1;
    }

    std::string filename = argv[1];
    std::vector<std::vector<int>> faces;
    readObjFile(filename, faces);

    std::vector<int> L, R;
    generateTables(faces, L, R);

    // Compter les occurrences des incréments
    std::map<int, int> totalCount = countIncrementOccurrences(L, R);

    // Afficher les occurrences des incréments
    std::cout << "Occurrences des incréments (trié par fréquence) :" << std::endl;
    std::vector<std::pair<int, int>> sortedIncrements(totalCount.begin(), totalCount.end());
    std::sort(sortedIncrements.begin(), sortedIncrements.end(), [](const std::pair<int, int> &a, const std::pair<int, int> &b) { return a.second > b.second; });
    for (const auto &entry : sortedIncrements) {
        std::cout << "c" << (entry.first >= 0 ? "+" : "") << entry.first << " : " << entry.second << " fois" << std::endl;
    }

    // Créer un codage sur 2 bits pour les incréments fréquents
    std::map<int, std::string> compactEncoding;
    std::vector<int> frequentIncrements;
    create2BitEncoding(totalCount, compactEncoding, frequentIncrements);

    // Affichage du dictionnaire de codage sur 2 bits
    std::cout << "\nDictionnaire de codage sur 2 bits : " << std::endl;
    for (const auto &entry : compactEncoding) {
        std::cout << "c" << (entry.first >= 0 ? "+" : "") << entry.first << " -> " << entry.second << std::endl;
    }

    // Encodage et affichage des détails pour L[]
    std::vector<int> exceptionIndicesL, exceptionsL;
    std::string encodedL = encodeTable2Bit(L, compactEncoding, exceptionIndicesL, exceptionsL);
    printEncodingDetails(L, compactEncoding, exceptionIndicesL, exceptionsL, "L[]");
    printCompressionStats(encodedL, L, "L[]");

    // Encodage et affichage des détails pour R[]
    std::vector<int> exceptionIndicesR, exceptionsR;
    std::string encodedR = encodeTable2Bit(R, compactEncoding, exceptionIndicesR, exceptionsR);
    printEncodingDetails(R, compactEncoding, exceptionIndicesR, exceptionsR, "R[]");
    printCompressionStats(encodedR, R, "R[]");

    // Fusionner les exceptions de L[] et R[]
    std::vector<int> allExceptions = exceptionsL;
    for (int exception : exceptionsR) {
        if (std::find(allExceptions.begin(), allExceptions.end(), exception) == allExceptions.end()) {
            allExceptions.push_back(exception);
        }
    }

    // Afficher la table des exceptions unifiée
    printExceptionTable(allExceptions);

    // Taux de compression global
    int totalEncodedBits = encodedL.size() + encodedR.size();
    int totalOriginalBits = L.size() * 32 + R.size() * 32; // 32 bits par int
    float globalCompressionRate = (float)totalEncodedBits / totalOriginalBits * 100;

    std::cout << "\nCompression globale : " << totalEncodedBits << " bits (au lieu de " << totalOriginalBits << " bits)" << std::endl;
    std::cout << "Taux de compression global par rapport aux indices non compressés : " << globalCompressionRate << "%" << std::endl;

    // Comparaison avec une représentation naïve (3 ints × nombre de triangles)
    int naiveSizeBits = (L.size() / 3) * 96; // 3 ints × 32 bits × nombre de triangles
    float naiveCompressionRate = (float)totalEncodedBits / naiveSizeBits * 100;

    std::cout << "\nComparaison avec une représentation naïve (3 ints × nombre de triangles) : " << std::endl;
    std::cout << "Taille naïve : " << naiveSizeBits << " bits" << std::endl;
    std::cout << "Taux de compression par rapport à la représentation naïve : " << naiveCompressionRate << "%" << std::endl;

    // Créer les dictionnaires de décodage
    std::map<std::string, int> compactDecoding;
    for (const auto &entry : compactEncoding) {
        compactDecoding[entry.second] = entry.first;
    }

    // Décodage pour vérifier la cohérence
    std::vector<int> decodedL = decodeTable2Bit(encodedL, compactDecoding, exceptionIndicesL, allExceptions);
    std::vector<int> decodedR = decodeTable2Bit(encodedR, compactDecoding, exceptionIndicesR, allExceptions);

    // Vérification que les tableaux décodés correspondent aux originaux
    bool correctL = (L == decodedL);
    bool correctR = (R == decodedR);
    std::cout << "\nVérification du décodage : " << (correctL && correctR ? "Succès ✅" : "Échec ❌") << std::endl;

    return 0;
}

This give this for a basic cube for example

annoo@yannoo-ThinkCentre-M710q:~/Dev/LR2$ ./lr2 cube.obj
Occurrences des incréments (trié par fréquence) :
c+1 : 45 fois
c-2 : 15 fois
c+10 : 4 fois
c+18 : 2 fois
c+13 : 1 fois
c+14 : 1 fois
c+15 : 1 fois
c+21 : 1 fois
c+23 : 1 fois
c+26 : 1 fois

Dictionnaire de codage sur 2 bits : 
c-2 -> 01
c+1 -> 00
c+10 -> 10

Détails du codage sur 2 bits pour L[] : 
Indice 0 : c13 (c+13) -> 11 (exception index: 0)
Indice 1 : c19 (c+18) -> 11 (exception index: 1)
Indice 2 : c3 (c+1) -> 00
Indice 3 : c4 (c+1) -> 00
Indice 4 : c25 (c+21) -> 11 (exception index: 2)
Indice 5 : c31 (c+26) -> 11 (exception index: 3)
Indice 6 : c16 (c+10) -> 10
Indice 7 : c22 (c+15) -> 11 (exception index: 4)
Indice 8 : c9 (c+1) -> 00
Indice 9 : c10 (c+1) -> 00
Indice 10 : c28 (c+18) -> 11 (exception index: 1)
Indice 11 : c34 (c+23) -> 11 (exception index: 5)
Indice 12 : c13 (c+1) -> 00
Indice 13 : c23 (c+10) -> 10
Indice 14 : c15 (c+1) -> 00
Indice 15 : c16 (c+1) -> 00
Indice 16 : c17 (c+1) -> 00
Indice 17 : c31 (c+14) -> 11 (exception index: 6)
Indice 18 : c19 (c+1) -> 00
Indice 19 : c29 (c+10) -> 10
Indice 20 : c21 (c+1) -> 00
Indice 21 : c22 (c+1) -> 00
Indice 22 : c23 (c+1) -> 00
Indice 23 : c21 (c-2) -> 01
Indice 24 : c25 (c+1) -> 00
Indice 25 : c35 (c+10) -> 10
Indice 26 : c27 (c+1) -> 00
Indice 27 : c28 (c+1) -> 00
Indice 28 : c29 (c+1) -> 00
Indice 29 : c27 (c-2) -> 01
Indice 30 : c31 (c+1) -> 00
Indice 31 : c32 (c+1) -> 00
Indice 32 : c33 (c+1) -> 00
Indice 33 : c34 (c+1) -> 00
Indice 34 : c35 (c+1) -> 00
Indice 35 : c33 (c-2) -> 01

Chaîne binaire encodée pour L[] : 111100001111101100001111001000000011001000000001001000000001000000000001
Longueur de la chaîne binaire : 72 bits (au lieu de 1152 bits)
Taux de compression par rapport aux indices non compressés : 6.25%

Détails du codage sur 2 bits pour R[] : 
Indice 0 : c1 (c+1) -> 00
Indice 1 : c2 (c+1) -> 00
Indice 2 : c0 (c-2) -> 01
Indice 3 : c4 (c+1) -> 00
Indice 4 : c5 (c+1) -> 00
Indice 5 : c3 (c-2) -> 01
Indice 6 : c7 (c+1) -> 00
Indice 7 : c8 (c+1) -> 00
Indice 8 : c6 (c-2) -> 01
Indice 9 : c10 (c+1) -> 00
Indice 10 : c11 (c+1) -> 00
Indice 11 : c9 (c-2) -> 01
Indice 12 : c13 (c+1) -> 00
Indice 13 : c14 (c+1) -> 00
Indice 14 : c12 (c-2) -> 01
Indice 15 : c16 (c+1) -> 00
Indice 16 : c17 (c+1) -> 00
Indice 17 : c15 (c-2) -> 01
Indice 18 : c19 (c+1) -> 00
Indice 19 : c20 (c+1) -> 00
Indice 20 : c18 (c-2) -> 01
Indice 21 : c22 (c+1) -> 00
Indice 22 : c23 (c+1) -> 00
Indice 23 : c21 (c-2) -> 01
Indice 24 : c25 (c+1) -> 00
Indice 25 : c26 (c+1) -> 00
Indice 26 : c24 (c-2) -> 01
Indice 27 : c28 (c+1) -> 00
Indice 28 : c29 (c+1) -> 00
Indice 29 : c27 (c-2) -> 01
Indice 30 : c31 (c+1) -> 00
Indice 31 : c32 (c+1) -> 00
Indice 32 : c30 (c-2) -> 01
Indice 33 : c34 (c+1) -> 00
Indice 34 : c35 (c+1) -> 00
Indice 35 : c33 (c-2) -> 01

Chaîne binaire encodée pour R[] : 000001000001000001000001000001000001000001000001000001000001000001000001
Longueur de la chaîne binaire : 72 bits (au lieu de 1152 bits)
Taux de compression par rapport aux indices non compressés : 6.25%

Table des exceptions : 
Index 0 : c+13
Index 1 : c+18
Index 2 : c+21
Index 3 : c+26
Index 4 : c+15
Index 5 : c+23
Index 6 : c+14

Compression globale : 144 bits (au lieu de 2304 bits)
Taux de compression global par rapport aux indices non compressés : 6.25%

Comparaison avec une représentation naïve (3 ints × nombre de triangles) : 
Taille naïve : 1152 bits
Taux de compression par rapport à la représentation naïve : 12.5%

Vérification du décodage : Succès ✅

Here, the file Cube.obj used

v -1.0 -1.0 -1.0
v  1.0 -1.0 -1.0
v  1.0  1.0 -1.0
v -1.0  1.0 -1.0
v -1.0 -1.0  1.0
v  1.0 -1.0  1.0
v  1.0  1.0  1.0
v -1.0  1.0  1.0

f 1 2 3
f 1 3 4
f 5 6 7
f 5 7 8
f 1 2 6
f 1 6 5
f 2 3 7
f 2 7 6
f 3 4 8
f 3 8 7
f 4 1 5
f 4 5 8

3 posts - 1 participant

Read full topic

This image is supposed to be a tv on a stand.

What I am doing is both bloom and shadows, so I need 3 framebuffers to do this. I haven’t got the shadow maps to work yet but I want to get my objects to show up properly first. I have a point light in a room, so I guess cube maps are used for this.

this is the setup for the framebuffers:

	GLuint hdrFBO;
	glGenFramebuffers(1, &hdrFBO);
	glBindFramebuffer(GL_FRAMEBUFFER, hdrFBO);

	// Color buffers (HDR + Bright)
	GLuint colorBuffers[2];
	glGenTextures(2, colorBuffers);

	for (int i = 0; i < 2; ++i)
	{
		glBindTexture(GL_TEXTURE_2D, colorBuffers[i]);
		glTexImage2D(
			GL_TEXTURE_2D,
			0,
			GL_RGBA16F,
			gWindowWidth,
			gWindowHeight,
			0,
			GL_RGBA,
			GL_FLOAT,
			nullptr
		);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

		glFramebufferTexture2D(
			GL_FRAMEBUFFER,
			GL_COLOR_ATTACHMENT0 + i,
			GL_TEXTURE_2D,
			colorBuffers[i],
			0
		);
	}

	// Depth buffer
	GLuint rboDepth;
	glGenRenderbuffers(1, &rboDepth);
	glBindRenderbuffer(GL_RENDERBUFFER, rboDepth);
	glRenderbufferStorage(
		GL_RENDERBUFFER,
		GL_DEPTH_COMPONENT24,
		gWindowWidth,
		gWindowHeight
	);
	glFramebufferRenderbuffer(
		GL_FRAMEBUFFER,
		GL_DEPTH_ATTACHMENT,
		GL_RENDERBUFFER,
		rboDepth
	);

	// Tell OpenGL we have two color outputs
	GLuint attachments[2] = {
		GL_COLOR_ATTACHMENT0,
		GL_COLOR_ATTACHMENT1
	};
	glDrawBuffers(2, attachments);

	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
		std::cout << "HDR FBO broken\n";
	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	// Sanity check
	



	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	
	// ------------------------------------------------------------
// PING-PONG FRAMEBUFFERS (bloom blur)
// ------------------------------------------------------------
	GLuint pingpongFBO[2];
	GLuint pingpongColorBuffers[2];
	glGenFramebuffers(2, pingpongFBO);
	glGenTextures(2, pingpongColorBuffers);

	for (int i = 0; i < 2; ++i)
	{
		glBindFramebuffer(GL_FRAMEBUFFER, pingpongFBO[i]);

		glBindTexture(GL_TEXTURE_2D, pingpongColorBuffers[i]);
		glTexImage2D(
			GL_TEXTURE_2D,
			0,
			GL_RGBA16F,
			gWindowWidth,
			gWindowHeight,
			0,
			GL_RGBA,
			GL_FLOAT,
			nullptr
		);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

		glFramebufferTexture2D(
			GL_FRAMEBUFFER,
			GL_COLOR_ATTACHMENT0,
			GL_TEXTURE_2D,
			pingpongColorBuffers[i],
			0
		);

		if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
			std::cout << "Pingpong FBO broken\n";
	}

	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	
	// ------------------------------------------------------------
// DEPTH CUBEMAP (point light shadows)
// ------------------------------------------------------------
	const unsigned int SHADOW_WIDTH = 1024;
	const unsigned int SHADOW_HEIGHT = 1024;

	// Depth cubemap texture
	GLuint depthCubemap;
	glGenTextures(1, &depthCubemap);
	glBindTexture(GL_TEXTURE_CUBE_MAP, depthCubemap);

	for (unsigned int i = 0; i < 6; ++i)
	{
		glTexImage2D(
			GL_TEXTURE_CUBE_MAP_POSITIVE_X + i,
			0,
			GL_DEPTH_COMPONENT,
			SHADOW_WIDTH,
			SHADOW_HEIGHT,
			0,
			GL_DEPTH_COMPONENT,
			GL_FLOAT,
			nullptr
		);
	}

	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

	// Shadow FBO
	GLuint depthCubemapFBO;
	glGenFramebuffers(1, &depthCubemapFBO);
	glBindFramebuffer(GL_FRAMEBUFFER, depthCubemapFBO);
	glFramebufferTexture(
		GL_FRAMEBUFFER,
		GL_DEPTH_ATTACHMENT,
		depthCubemap,
		0
	);

	glDrawBuffer(GL_NONE);
	glReadBuffer(GL_NONE);

	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
		std::cout << "Depth cubemap FBO broken\n";

	glBindFramebuffer(GL_FRAMEBUFFER, 0);

This is the rendering code up to when I redraw my objects:

glBindFramebuffer(GL_FRAMEBUFFER, depthCubemapFBO);
glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
glClearDepth(1.0);
glClear(GL_DEPTH_BUFFER_BIT);

sceneShader.use();

for (int i = 0; i < 6; i++)
{
	sceneShader.setUniform(
		"shadowMatrices[" + std::to_string(i) + "]",
		shadowTransforms[i]
	);
}

sceneShader.setUniform("lightPos", lightPos);
sceneShader.setUniform("farPlane", wid);			
sceneShader.setUniformI("isFan", 0);

model = glm::translate(glm::mat4(1), glm::vec3(-5.894, 1.123, 5.775)) * glm::rotate(glm::mat4(1), glm::radians(135.0f), glm::vec3(0, 1, 0)) * glm::rotate(glm::mat4(1), glm::radians(270.0f), glm::vec3(1, 0, 0));
sceneShader.setUniform("model", model);

// then I render my objects with this shader

//glBindFramebuffer(GL_FRAMEBUFFER, 0);

glBindFramebuffer(GL_FRAMEBUFFER, hdrFBO);
glViewport(0, 0, gWindowWidth, gWindowHeight);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glDepthMask(GL_TRUE);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_CUBE_MAP, depthCubemap);

model = glm::rotate(glm::mat4(1), glm::radians(180.0f), glm::vec3(0, 1, 0)) * glm::rotate(glm::mat4(1), glm::radians(270.0f), glm::vec3(1, 0, 0)) * glm::scale(glm::mat4(1), glm::vec3(1.5, 1.5, 1.5));

glm::mat4 vp1 = MyCam.getVP();

glm::vec3 viewPos = MyCam.campos;		

roomShader.use();
roomShader.setUniform("vp", vp1);
roomShader.setUniform("model", model);
roomShader.setUniform("lightPos", lightPos);
roomShader.setUniform("viewPos", viewPos);
roomShader.setUniform("farPlane", wid);
roomShader.setUniformSampler("Texture1", 0);
roomShader.setUniformSampler("Texture2", 1);
roomShader.setUniformSampler("depthCubemap", 2);

carpetTex.bind(1);
sceneTex.bind(0);
room.Draw();
carpetTex.unbind(1);
sceneTex.unbind(0);

glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);

1 post - 1 participant

Read full topic

I want to display tetrahedrons volumes with OpenGL

I think use this function for to implement it

void glTetra3fv( float *v0, float *v1, float *v2, float *v3 ) 
{
    glBegin(GL_TRIANGLES);

        glVertex3fv(v0);   // face A (face entry)
        glVertex3fv(v1);
        glVertex3fv(v2);
 
        glVertex3fv(v3);   // face B
        glVertex3fv(v0);
        glVertex3fv(v1);

        glVertex3fv(v3);   // face C
        glVertex3fv(v1);
        glVertex3fv(v2);
 
        glVertex3fv(v3);   // face D
        glVertex3fv(v2);
        glVertex3fv(v0);

    glEnd();
}

Think you that it is better to use the glBegin() / glEnd() calls inside or outside this function ?

This is for to call this fonction something like this :
(4 tetrahedrons = three tetrahedrons glued to one first)

// glBegin(GL_TRIANGLES);

    glTetra3fv( &v1 , &v2 , &v3 , &v4 );
    glTetra3fv( &v1 , &v2 , &v4 , &v5 );
    glTetra3fv( &v2 , &v3 , &v4 , &v6 );
    glTetra3fv( &v3 , &v1 , &v4 , &v7 );

// glEnd();

or a very little more complex code like this for other example :
(one internal black tetrahedron glued by red, green, blue and gray tetrahedrons on his faces)

// glBegin(GL_TRIANGLES);

    // a black tetrahedron in the interior
    glColor3fv( 0.0f, 0.0f, 0.0f );
    glTetra3fv( &v1 , &v2 , &v3 , &v4 );

    // a red tetrahedron glued to the 1th extern face of this tetrahedron
    glColor3fv(1.0f,0.0f,0.0f);
    glTetra3fv( &v1 , &v2 , &v4 , &v5 );

    // a green tetrahedron glued to the 2th extern face of this tetrahedron
    glColor3fv(0.0f,1.0f,0.0f);
    glTetra3fv( &v2 , &v3 , &v4 , &v6 );

    // a blue tetrahedron glued to the 3th extern face of this tetrahedron
    glColor3fv(0.0f,0.0f,1.0f);
    glTetra3fv( &v3 , &v1 , &v4 , &v7 );

    // a gray tetrahedron glued to the entry face of this tetrahedron
    glColor3fv( 0.5f, 0.5f, 0.5f );
    glTetra3fv( &v1 , &v2 , &v3 , &v8 );

// glEnd();

2 posts - 1 participant

Read full topic

This is a Christmas tree that I am trying to render. It is 4.9 units high it has 1008 Christmas lights and the star to illuminate it. I am just trying to use these lights to make the tree look like it is lit up by them and not anything else.

This is the fragment shader that i am using to render it.

#version 430 core

layout(std430, binding = 0) buffer Centers {
    vec3 centers[];
};

uniform vec3 viewPos;
uniform vec3 starCent;

flat in uint mNum;
in vec3 Pos;
in vec3 Norm;

out vec4 FragColor;

vec3 CalcPointLight(vec3 lightPos, vec3 normal, vec3 fragPos, vec3 viewDir)
{
    vec3 lightColor = vec3(1, 1, 1);

    float constant = .75;
    float linear = 5.2;
    float quadratic = 10.1;

    vec3 lightDir = normalize(lightPos - fragPos);

    // Diffuse
    float diff = max(dot(normal, lightDir), 0.0);

    // Specular
    vec3 halfwayDir = normalize(lightDir + viewDir);
    float spec = pow(max(dot(normal, halfwayDir), 0.0), 32.0);

    // Distance attenuation
    float distance = length(lightPos - fragPos);
    float attenuation = 1.0 / (
        constant +
        linear * distance +
        quadratic * distance * distance
    );

    vec3 ambient  = 0.05 * lightColor;
    vec3 diffuse  = diff * lightColor * 2;
    vec3 specular = spec * lightColor;

    return (ambient + diffuse) * attenuation * .4;
}

vec3 CalcPointLight1(vec3 lightPos, vec3 normal, vec3 fragPos, vec3 viewDir)
{
    vec3 lightColor = vec3(1, 1, 0);

    float constant = .75;
    float linear = 2;
    float quadratic = 2;

    vec3 lightDir = normalize(lightPos - fragPos);

    // Diffuse
    float diff = max(dot(normal, lightDir), 0.0);

    // Specular
    vec3 halfwayDir = normalize(lightDir + viewDir);
    float spec = pow(max(dot(normal, halfwayDir), 0.0), 32.0);

    // Distance attenuation
    float distance = length(lightPos - fragPos);
    float attenuation = 1.0 / (
        constant +
        linear * distance +
        quadratic * distance * distance
    );

    vec3 ambient  = 0.05 * lightColor;
    vec3 diffuse  = diff * lightColor;
    vec3 specular = spec * lightColor;

    return (ambient + diffuse) * attenuation * 6;
}

void main(){
	vec3 norm = normalize(Norm);
    vec3 viewDir = normalize(viewPos - Pos);
    vec3 result = vec3(0.0);

	for (int i=0;i<1008;i++){
		vec3 center = centers[i];    
        result += CalcPointLight(center, norm, Pos, viewDir);
    }

    result += CalcPointLight1(starCent, norm, Pos, viewDir);

    vec3 albedo; 
	if (mNum == 0){
		albedo = vec3(0.18039215686274509803921568627451, 0.11764705882352941176470588235294, 0.05882352941176470588235294117647);
	}else{
		albedo = vec3(0.09411764705882352941176470588235, 0.21960784313725490196078431372549, 0.12549019607843137254901960784314);
	}
    FragColor = vec4(result * albedo, 1.0);
}

5 posts - 2 participants

Read full topic

This is my code:

unsigned int hdrFBO;
glGenFramebuffers(1, &hdrFBO);
glBindFramebuffer(GL_FRAMEBUFFER, hdrFBO);
unsigned int colorBuffers[2];
glGenTextures(2, colorBuffers);
for (unsigned int i = 0; i < 2; i++)
{
	glBindTexture(GL_TEXTURE_2D, colorBuffers[i]);
	glTexImage2D(
		GL_TEXTURE_2D, 0, GL_RGBA16F, gWindowWidth, gWindowHeight, 0, GL_RGBA, GL_FLOAT, NULL
	);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	// attach texture to framebuffer
	glFramebufferTexture2D(
		GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, colorBuffers[i], 0
	);
}
GLuint rboDepth;
glGenRenderbuffers(1, &rboDepth);
glBindRenderbuffer(GL_RENDERBUFFER, rboDepth);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24,
	gWindowWidth, gWindowHeight);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
	GL_RENDERBUFFER, rboDepth);

unsigned int attachments[2] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
glDrawBuffers(2, attachments);

unsigned int pingpongFBO[2];
unsigned int pingpongBuffer[2];
glGenFramebuffers(2, pingpongFBO);
glGenTextures(2, pingpongBuffer);
for (unsigned int i = 0; i < 2; i++)
{
	glBindFramebuffer(GL_FRAMEBUFFER, pingpongFBO[i]);
	glBindTexture(GL_TEXTURE_2D, pingpongBuffer[i]);
	glTexImage2D(
		GL_TEXTURE_2D, 0, GL_RGBA16F, gWindowWidth, gWindowHeight, 0, GL_RGBA, GL_FLOAT, NULL
	);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glFramebufferTexture2D(
		GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, pingpongBuffer[i], 0
	);
}

glm::mat4 projection = glm::perspective(glm::radians(45.0f), 1.7777777777f, 0.5f, 200.0f);

double lastTime = glfwGetTime();
double deltaTime;

while (!glfwWindowShouldClose(gWindow))
{
	double currentTime = glfwGetTime();
	deltaTime = currentTime - lastTime;
	lastTime = currentTime;

	glfwPollEvents();
	update(deltaTime);

	glm::mat4 view = MyCam.getViewMatrix();
	glm::mat4 model = glm::rotate(glm::mat4(1), glm::radians(270.0f), glm::vec3(1, 0, 0));

	glm::mat4 mvp = projection * view * model;

	glBindFramebuffer(GL_FRAMEBUFFER, hdrFBO);
	glViewport(0, 0, gWindowWidth, gWindowHeight);

	glClearColor(0, 0, 0, 1);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	

	treeShader.use();
	treeShader.setUniform("mvp", mvp);
	
	//tree.Draw();

	lightShader.use();
	lightShader.setUniform("mvp", mvp);

	lights.Draw();

	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	bool horizontal = true;
	bool first_iteration = true;
	int amount = 10;

	shaderBlur.use();

	for (int i = 0; i < amount; i++)
	{
		glBindFramebuffer(GL_FRAMEBUFFER, pingpongFBO[horizontal]);

		shaderBlur.setUniformI("horizontal", horizontal);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(
			GL_TEXTURE_2D,
			first_iteration ? colorBuffers[1] : pingpongBuffer[!horizontal]
		);
		shaderBlur.setUniformSampler("image", 0);

		glBindVertexArray(lVAO);
		glDrawArrays(GL_TRIANGLES, 0, 6);

		horizontal = !horizontal;
		if (first_iteration)
			first_iteration = false;
	}

	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	blendShader.use();

	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, colorBuffers[0]); // scene

	glActiveTexture(GL_TEXTURE1);
	glBindTexture(GL_TEXTURE_2D, pingpongBuffer[!horizontal]); // bloom

	blendShader.setUniformSampler("scene", 0);
	blendShader.setUniformSampler("bloomBlur", 1);

	glBindVertexArray(lVAO);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	glBindVertexArray(0);

	glfwSwapBuffers(gWindow);

These are my fragment shaders:

#version 430 core //lights

layout (location = 0) out vec4 FragColor;
layout (location = 1) out vec4 BrightColor;

void main()
{
    vec3 emissiveColor = vec3(1, 1, 1);
    float emissiveStrength = .75;

    vec3 color = vec3(20, 20, 20);

    vec3 emissive = emissiveColor * emissiveStrength;
    color += emissive;

    FragColor = vec4(color, 1.0);

    float brightness = dot(emissive, vec3(0.2126, 0.7152, 0.0722));
    if (brightness > 1.0)
        BrightColor = vec4(emissive, 1.0);
    else
        BrightColor = vec4(0.0);
}

#version 430 core //blur
out vec4 FragColor;
  
in vec2 TexCoords;

uniform sampler2D image;
  
uniform bool horizontal;
uniform float weight[5] = float[] (0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216);

void main()
{             
    vec2 tex_offset = 1.0 / textureSize(image, 0); // gets size of single texel
    vec3 result = texture(image, TexCoords).rgb * weight[0]; // current fragment's contribution
    if(horizontal)
    {
        for(int i = 1; i < 5; ++i)
        {
            result += texture(image, TexCoords + vec2(tex_offset.x * i, 0.0)).rgb * weight[i];
            result += texture(image, TexCoords - vec2(tex_offset.x * i, 0.0)).rgb * weight[i];
        }
    }
    else
    {
        for(int i = 1; i < 5; ++i)
        {
            result += texture(image, TexCoords + vec2(0.0, tex_offset.y * i)).rgb * weight[i];
            result += texture(image, TexCoords - vec2(0.0, tex_offset.y * i)).rgb * weight[i];
        }
    }
    FragColor = vec4(result, 1.0);
}

#version 430 core //blend
out vec4 FragColor;
  
in vec2 TexCoords;

uniform sampler2D scene;
uniform sampler2D bloomBlur;

void main()
{   
    float exposure = .5;
    const float gamma = 2.2;
    vec3 hdrColor = texture(scene, TexCoords).rgb;      
    vec3 bloomColor = texture(bloomBlur, TexCoords).rgb;
    hdrColor += bloomColor; // additive blending
    // tone mapping
    vec3 result = vec3(1.0) - exp(-hdrColor * exposure);
    // also gamma correct while we're at it       
    result = pow(result, vec3(1.0 / gamma));
    //FragColor = vec4(result, 1.0);
    FragColor = vec4(bloomColor, 1);
}  

2 posts - 1 participant

Read full topic

I’ve been working on a PBR shader the last few months and have gotten a good ways with it I think. I’m just not sure if I have actually got a robust solution, and I’m getting PBR working with my terrain system and feel like the screenshot below is just a little to “blue” from IBL. You can see the left of the terrain has a blue tint compared to the right. I tend to believe that the camera is facing the directional light there… I don’t know. It just feels washed out to me, but might be correct.

Here’s the same PBR lighting on the helmet model (different shader code but same lighting functions)

Hoping some of you guys might have some tips or may see something not right in the code.

Here’s the full vert and frag code for the terrain.

//Vertex Shader
#version 450
#extension GL_ARB_separate_shader_objects : enable
#extension GL_ARB_shader_draw_parameters : enable
#extension GL_ARB_bindless_texture : enable


#define BUFFER_BINDING_CAMERA_SSBO 0
#define BUFFER_BINDING_ENTITY_SSBO 1
#define BUFFER_BINDING_MESH_SSBO 2
#define BUFFER_BINDING_MATERIAL_SSBO 3
#define BUFFER_BINDING_FRAMEBUFFER_SSBO 4
#define BUFFER_BINDING_LIGHTS_SSBO 5
#define BUFFER_BINDING_INSTANCE_SSBO 6
#define BUFFER_BINDING_VOXEL_OBJECT_SSBO 7
#define BUFFER_BINDING_PROBE_SSBO 8

//Shader master starts from 8.  This needs to be manually changed if more enigne values are added here.

layout(location = 0) uniform int CameraID;
#ifdef DOUBLE_FLOAT
//layout(location = 1) uniform dvec3 WorldOffset;
#endif

struct Camera {
    mat4 view;
	mat4 projection;
};

layout(std430, binding = BUFFER_BINDING_CAMERA_SSBO) buffer CameraBuffer {
    Camera cameras[];
};

mat4 CameraMatrix;
mat4 CameraInverseMatrix;

vec3 ExtractCameraPosition(in int CameraID) {
	Camera cam = cameras[CameraID];
	CameraInverseMatrix = inverse(cam.view);
	return CameraInverseMatrix[3].xyz;
}
vec3 CameraPosition = ExtractCameraPosition(CameraID);


//Shoud only be used in a vertex shader due to : uint id = gl_BaseInstanceARB + gl_InstanceID;

struct Mesh {
	uint entityID;
	uint materialID;
};

layout(std430, binding = BUFFER_BINDING_MESH_SSBO) readonly buffer MeshBuffer {
    Mesh instanceInfo[];
};

uint EntityID;
uint MaterialID;

uint ExtractInstanceInfo() {
	uint id = gl_BaseInstanceARB + gl_InstanceID;
	EntityID = instanceInfo[id].entityID;
	MaterialID = instanceInfo[id].materialID;
	
	return id;
}
uint MeshID = ExtractInstanceInfo();

//Entities
//Structs are auto padded to 16 bytes
struct Entity {
	mat4 matrix;
	mat4 normal_matrix;
	vec4 color;
};

layout(std430, binding = BUFFER_BINDING_ENTITY_SSBO) readonly buffer EntityBuffer {
    Entity entities[];
};
layout(location = 0) in vec3 in_vPosition;
layout(location = 1) in vec3 in_vNormal;
layout(location = 2) in vec3 in_vTangent;
layout(location = 3) in vec3 in_vBitangent;
layout(location = 4) in vec4 in_vCoords;
layout(location = 5) in vec3 in_vColor;
#define TEXTURE_DIFFUSE 0
#define TEXTURE_NORMAL 1
#define TEXTURE_TANGENT 2
#define TEXTURE_BITANGENT 3
#define TEXTURE_AO 4
#define TEXTURE_SLOT_ALBEDO 0
#define TEXTURE_SLOT_NORMAL 1
#define TEXTURE_SLOT_METALLIC_ROUGHNESS_AO 2
#define TEXTURE_SLOT_EMISSIVE 3
#define TEXTURE_SLOT_DISPLACMENT 4

struct Material {
	vec4 diffuseColor;
	float roughness;
	float metallic;
	float displacment_strength;
	uvec2 textureHandle[16];
};

layout(std430, binding = 3) readonly buffer MaterialBlock { Material materials[]; };

layout(location = 0) out vec3 out_vNormal;
layout(location = 1) out vec4 out_vCoords;
layout(location = 2) out vec4 out_vColor;
layout(location = 3) flat out uint out_MaterialIndex;
layout(location = 4) flat out uint out_EntityIndex;
layout(location = 5) flat out uint out_MeshIndex;
layout(location = 6) out vec3 out_WorldPosition;
layout(location = 7) out vec3 out_CameraPosition;
layout(location = 8) out mat3 out_TBN;


void main() {
	Entity entity = entities[EntityID];
	Material material = materials[MaterialID];
	
	vec3 vertex_position = in_vPosition;
	
	//mat4 model_matrix = entity.matrix;
	
	Camera camera = cameras[CameraID];
	mat4 proj_matrix = camera.projection;
	mat4 view_matrix = camera.view;
	
	//Can we calculate the normal_matrix once per model?
	//-mat3 normal_matrix = transpose(inverse(mat3(entity.matrix)));
	mat3 normal_matrix = mat3(entity.matrix);
	vec3 T = normalize(vec3(normal_matrix * vec3(1,0,0)));
	vec3 B = normalize(vec3(normal_matrix * vec3(0,0,1)));
	vec3 N = normalize(vec3(normal_matrix * vec3(0,1,0)));
	out_TBN = mat3(T, B, N);
	
	out_CameraPosition = inverse(view_matrix)[3].xyz;
	out_WorldPosition = vec3(entity.matrix * vec4(vertex_position, 1.0f));
	out_EntityIndex = EntityID;
	//out_EntityColor = entity.color;
	out_MeshIndex = MeshID;
	out_MaterialIndex = MaterialID;
	out_vNormal = N;
	out_vColor = vec4(in_vColor, 1.0f);
	out_vCoords = in_vCoords;
    gl_Position = proj_matrix * view_matrix * vec4(out_WorldPosition, 1.0f);
}

//Fragment Shader
#version 460
#extension GL_ARB_separate_shader_objects : enable
#extension GL_ARB_bindless_texture : enable

layout(location = 0) in vec3 in_vNormal;
layout(location = 1) in vec4 in_vCoords;
layout(location = 2) in vec4 in_vColor;
layout(location = 3) flat in uint in_MaterialIndex;
layout(location = 4) flat in uint in_EntityIndex;
layout(location = 5) flat in uint in_MeshIndex;
layout(location = 6) in vec3 in_WorldPosition;
layout(location = 7) in vec3 in_CameraPosition;
layout(location = 8) in mat3 in_TBN;

#define TEXTURE_DIFFUSE 0
#define TEXTURE_NORMAL 1
#define TEXTURE_TANGENT 2
#define TEXTURE_BITANGENT 3
#define TEXTURE_AO 4
#define TEXTURE_SLOT_ALBEDO 0
#define TEXTURE_SLOT_NORMAL 1
#define TEXTURE_SLOT_METALLIC_ROUGHNESS_AO 2
#define TEXTURE_SLOT_EMISSIVE 3
#define TEXTURE_SLOT_DISPLACMENT 4


struct Material {
	vec4 diffuseColor;
	float roughness;
	float metallic;
	float displacment_strength;
	uvec2 textureHandle[16];
};

layout(std430, binding = 3) readonly buffer MaterialBlock { Material materials[]; };

struct VoxelTerrainLayer {
	uint material_index;
	float min_height;
	float max_height;
	float min_slope;
	float max_slope;
	float min_angle;
	float max_angle;
	float transition;
};




float MacroVariation( in Material material , in int texture_slot , in vec2 coords , in float strength ) {
	return mix( ( 1.0f - strength ) , 1.0f , ( ( texture( sampler2D( material.textureHandle[ texture_slot ] ) , ( coords * 0.2134f ) ).x + 0.5f ) * ( ( texture( sampler2D( material.textureHandle[ texture_slot ] ) , ( coords * 0.05341f ) ).x + 0.5f ) * ( texture( sampler2D( material.textureHandle[ texture_slot ] ) , ( coords * 0.002f ) ).x + 0.5f ) ) ) );
}




vec4 SampleDiffuse( Material material , in vec2 coords ) {
	return ( material.diffuseColor * ( texture( sampler2D( material.textureHandle[ 0 ] ) , coords ) * MacroVariation( material , 0 , coords , 1.0f ) ) );
}




vec3 SampleNormal( in Material material , in vec2 coords ) {
	vec4 node22_pixel = texture( sampler2D( material.textureHandle[ 1 ] ) , coords );
	return vec3( ( ( node22_pixel.x * 2.0f ) - 1.0f ) , ( ( node22_pixel.z * 2.0f ) - 1.0f ) , ( ( node22_pixel.y * 2.0f ) - 1.0f ) );
}




void SampleLayer( in VoxelTerrainLayer layer , in vec2 coords , in float slope , out vec3 normal , out vec4 color , out float blend ) {
	normal = SampleNormal(materials[ layer.material_index ] , coords);
	blend = smoothstep( ( layer.max_slope + 0.001f ) , layer.min_slope , slope );
	if ( blend > 0.0f ) {
		color = ( materials[ layer.material_index ].diffuseColor * SampleDiffuse(materials[ layer.material_index ] , coords) );
		
	}
}


#define BUFFER_BINDING_CAMERA_SSBO 0
#define BUFFER_BINDING_ENTITY_SSBO 1
#define BUFFER_BINDING_MESH_SSBO 2
#define BUFFER_BINDING_MATERIAL_SSBO 3
#define BUFFER_BINDING_FRAMEBUFFER_SSBO 4
#define BUFFER_BINDING_LIGHTS_SSBO 5
#define BUFFER_BINDING_INSTANCE_SSBO 6
#define BUFFER_BINDING_VOXEL_OBJECT_SSBO 7
#define BUFFER_BINDING_PROBE_SSBO 8

//Shader master starts from 8.  This needs to be manually changed if more enigne values are added here.


layout(location = 0) uniform int CameraID;
#ifdef DOUBLE_FLOAT
layout(location = 1) uniform dvec3 WorldOffset;
#endif


struct Camera {
    mat4 view;
	mat4 projection;
};

layout(std430, binding = BUFFER_BINDING_CAMERA_SSBO) buffer CameraBuffer {
    Camera cameras[];
};

mat4 CameraMatrix;
mat4 CameraInverseMatrix;

vec3 ExtractCameraPosition(in int CameraID) {
	Camera cam = cameras[CameraID];
	CameraInverseMatrix = inverse(cam.view);
	return CameraInverseMatrix[3].xyz;
}
vec3 CameraPosition = ExtractCameraPosition(CameraID);


vec2 DistanceCoords( in vec2 coords , in vec3 world_position , in float uv_scale , in float step_size ) {
	return ( coords / ( uv_scale * ( floor( ( distance(world_position, CameraPosition) / step_size ) ) + 1.0f ) ) );
}



uniform float object_size = 1.0f;
uniform int total_material_layers = 0;

void VoxelTerrainInput( out float size , out float height , out float detail , out float noise , out float ao , out vec3 normal , out vec3 tangent , out vec3 bi_tangent , out vec2 object_uv , out vec2 tile_uv , out int layer_count , out uint layers ) {
	size = object_size;
	vec4 node23_tex_sample = texture( sampler2D( materials[ in_MaterialIndex ].textureHandle[ TEXTURE_DIFFUSE ] ) , ( in_WorldPosition.xz / object_size ) );
	height = node23_tex_sample.x;
	detail = node23_tex_sample.y;
	noise = node23_tex_sample.z;
	ao = node23_tex_sample.w;
	normal = SampleNormal(materials[ in_MaterialIndex ] , ( in_WorldPosition.xz / object_size ));
	tangent = texture( sampler2D( materials[ in_MaterialIndex ].textureHandle[ TEXTURE_TANGENT ] ) , ( in_WorldPosition.xz / object_size ) ).xyz;
	bi_tangent = texture( sampler2D( materials[ in_MaterialIndex ].textureHandle[ TEXTURE_BITANGENT ] ) , ( in_WorldPosition.xz / object_size ) ).xyz;
	object_uv = ( in_WorldPosition.xz / object_size );
	tile_uv = in_WorldPosition.xz;
	layer_count = total_material_layers;
}



float GetSlope( in vec3 normal , in vec3 up ) {
	return clamp(dot( normal , up ), 0.0f, 1.0f);
}



const int node38_array_size = 32;
layout(std140, binding = 8) uniform material_layers_block {
	VoxelTerrainLayer material_layers[32];
};
out vec4 FragColor;

void main() {
	float node29_size;
	float node29_height;
	float node29_detail;
	float node29_noise;
	float node29_ao;
	vec3 node29_normal;
	vec3 node29_tangent;
	vec3 node29_bi_tangent;
	vec2 node29_object_uv;
	vec2 node29_tile_uv;
	int node29_layer_count;
	uint node29_layers;
	VoxelTerrainInput( node29_size , node29_height , node29_detail , node29_noise , node29_ao , node29_normal , node29_tangent , node29_bi_tangent , node29_object_uv , node29_tile_uv , node29_layer_count , node29_layers );
	vec4 node13_variable = vec4( 1.0f, 1.0f, 1.0f, 0.0f );
	
	vec3 node6_normal;
	vec4 node6_color;
	float node6_blend;
	
	for( int node35_index = 0; node35_index < node29_layer_count; node35_index++ ) {
		SampleLayer( material_layers[node35_index] , DistanceCoords( node29_tile_uv , in_WorldPosition , 1.0f , 32.0f ) , GetSlope(node29_normal , vec3( 0.0f, 1.0f, 0.0f )) , node6_normal , node6_color , node6_blend );
		if ( node35_index == 0 ) {
			node6_blend = 1.0f;
			
		}
		node13_variable = mix( node13_variable , node6_color , node6_blend );
	}
	
	FragColor = node13_variable;
}

4 posts - 2 participants

Read full topic

1. draw quad with texture
2. clip quad to circle with shader and scissor state
   as clip break the batching-drawCall, when there are many this textured circle, there are many drawCall.
   is there any way to batching all of these drawCall?
   Thanks!

2 posts - 2 participants

Read full topic

7 posts - 3 participants

Read full topic

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

So in result I need something like:

glBlendFunc(GL_MAX_ALPHA, GL_ONE_MINUS_MAX_ALPHA);

As far as I understand this can be done with framebuffer ping-pong in shaders and manual color calculation. But in my case there might be many screen space objects, so it will affect performance.
Any advices?

1 post - 1 participant

Read full topic

I’m clipping some entities in the scene by setting gl_ClipDistance, I have some doubts about giving caps to entities and I hope you can give me good hints about that: thank you all in advance!

CONTEXT
I used what I think to be the standard approach to create single coloured cappings:

1. Draw all the entities only in stencil with front face clipping, increasing stencil
2. Draw all the entities only in stencil with back face clipping, decreasing stencil
3. Draw a mesh (color mask on, depth test on [GL_LESS]) representing the clipping plane: the stencil allows only the cap to be drawn

I wanted to take a step further, by giving each entities its own capping color;
my main issue is that entities in my scene can be nested, and I could just came up with the following approach:

1. for each entity in scene
2.     Draw the given entity only in stencil with front face clipping, increasing stencil
3.     Draw the given entity only in stencil with back face clipping, decreasing stencil
4.     Draw the clipping plane (color mask on, depth test on [GL_LESS]) using the entity color 
5.     Next

This approach works (at least, I’m getting the expected results), but I was wondering if something better could be achieved; namely, I change face clipping twice on a per entity basis, as well as stencil operation and depth testing, whilst in the single colour approach I could change all the settings on a per scene draw basis.
I tried some depth-based approaches, but I couldn’t manage to produce a proper result.

SIMPLE USE CASE
A simple situation that I tried to analize is the following, where my attempts with depth failed due to the face pointed at by the green arrow

EXPECTED RESULT
This is the expected result, that I can get with the previously described approach

QUESTION
Is performing two stencil passes and a color draw call for each entity a good enough approach, or is there a better algorithm to achieve the wanted result?
Thank anyone who can share their thoughts on this matter!

2 posts - 2 participants

Read full topic

You can see that the second texture is on the first (black) texture and it’s only happen when I use texture and not color to draw and sometimes they appear sometimes don’t.

my shaders:

#shader vertex
#version 330 core
uniform mat4 u_view;
uniform mat4 u_model;
uniform mat4 u_proj;
layout (location = 0) in vec4 position;
layout (location = 1) in vec4 color;
layout (location = 2) in float texID;
layout (location = 3) in vec2 texCoord;

out float v_texID;
out vec2 v_texCoord;
out vec4 v_color;
  void main()
  {
      mat4 mat = u_proj*u_view*u_model;
      gl_Position = mat*position;
      v_color = color;
      v_texID = texID;
      v_texCoord = texCoord;
  }
  
  #shader fragment
  uniform sampler2D u_textures[8];
  in float v_texID;
  in vec2 v_texCoord;
  in vec4 v_color;
  out vec4 FragColor;
  
  void main()
  {
      vec4 color = v_color;
      if (v_texID>=0.0) FragColor =  texture2D(u_textures[int(v_texID)], v_texCoord)*color;
      else FragColor = color;
  }

my vertex datas :

    Vertex2D v[] = {
        0.f,0.f,0.f, 1.f,1.f,1.f,1.f, 0.f, 0.f,0.f,
        100.f,0.f,0.f, 1.f,1.f,1.f,1.f, 0.f, 1.f,0.f,
        0.f,100.f,0.f, 1.f,1.f,1.f,1.f, 0.f, 0.f,1.f,
        100.f,100.f,0.f, 1.f,1.f,1.f,1.f, 0.f, 1.f,1.f,

        150.f,0.f,0.f, 1.f,1.f,1.f,1.f, 1.f, 0.f,0.f,
        250.f,0.f,0.f, 1.f,1.f,1.f,1.f, 1.f, 1.f,0.f,
        150.f,100.f,0.f, 1.f,1.f,1.f,1.f, 1.f, 0.f,1.f,
        250.f,100.f,0.f, 1.f,1.f,1.f,1.f, 1.f, 1.f,1.f
    };
    unsigned i[] = {0,1,2,1,2,3, 4,5,6,5,6,7};

texID is just for texture slot.

2 posts - 2 participants

Read full topic