tuto_uniform_buffers.cpp File Reference

alignement des donnees / uniform buffers. More...

#include <cstddef>
#include <cassert>
#include <vector>
#include "window.h"
#include "vec.h"
#include "color.h"
#include "program.h"

Go to the source code of this file.

Classes
struct	glsl::gscalar< T >
struct	glsl::gvec2< T >
struct	glsl::gvec3< T >
struct	glsl::gvec4< T >
struct	glsl::array::gscalar< T >
struct	glsl::array::gvec2< T >
struct	glsl::array::gvec3< T >
struct	glsl::array::gvec4< T >

Typedefs
typedef gscalar< float >	glsl::array::gfloat
typedef gscalar< int >	glsl::array::gint
typedef gscalar< unsigned int >	glsl::array::guint
typedef gscalar< bool >	glsl::array::gbool
typedef gvec2< float >	glsl::array::vec2
typedef gvec2< int >	glsl::array::ivec2
typedef gvec2< unsigned int >	glsl::array::uvec2
typedef gvec2< int >	glsl::array::bvec2
typedef gvec3< float >	glsl::array::vec3
typedef gvec3< int >	glsl::array::ivec3
typedef gvec3< unsigned int >	glsl::array::uvec3
typedef gvec3< int >	glsl::array::bvec3
typedef gvec4< float >	glsl::array::vec4
typedef gvec4< int >	glsl::array::ivec4
typedef gvec4< unsigned int >	glsl::array::uvec4
typedef gvec4< int >	glsl::array::bvec4

Functions
const char *	glsl_string (const GLenum type)
int	print_uniform (const GLuint program)
int	init ()
int	quit ()
int	main (int argc, char **argv)

Variables
GLuint	program

Detailed Description

alignement des donnees / uniform buffers.

Definition in file tuto_uniform_buffers.cpp.

Typedef Documentation

gfloat

typedef gscalar<float> glsl::array::gfloat

Definition at line 111 of file tuto_uniform_buffers.cpp.

gint

typedef gscalar<int> glsl::array::gint

Definition at line 112 of file tuto_uniform_buffers.cpp.

guint

typedef gscalar<unsigned int> glsl::array::guint

Definition at line 113 of file tuto_uniform_buffers.cpp.

gbool

typedef gscalar<bool> glsl::array::gbool

Definition at line 114 of file tuto_uniform_buffers.cpp.

vec2

typedef gvec2<float> glsl::array::vec2

Definition at line 129 of file tuto_uniform_buffers.cpp.

ivec2

typedef gvec2<int> glsl::array::ivec2

Definition at line 130 of file tuto_uniform_buffers.cpp.

uvec2

typedef gvec2<unsigned int> glsl::array::uvec2

Definition at line 131 of file tuto_uniform_buffers.cpp.

bvec2

typedef gvec2<int> glsl::array::bvec2

Definition at line 132 of file tuto_uniform_buffers.cpp.

vec3

typedef gvec3<float> glsl::array::vec3

Definition at line 151 of file tuto_uniform_buffers.cpp.

ivec3

typedef gvec3<int> glsl::array::ivec3

Definition at line 152 of file tuto_uniform_buffers.cpp.

uvec3

typedef gvec3<unsigned int> glsl::array::uvec3

Definition at line 153 of file tuto_uniform_buffers.cpp.

bvec3

typedef gvec3<int> glsl::array::bvec3

Definition at line 154 of file tuto_uniform_buffers.cpp.

vec4

typedef gvec4<float> glsl::array::vec4

Definition at line 170 of file tuto_uniform_buffers.cpp.

ivec4

typedef gvec4<int> glsl::array::ivec4

Definition at line 171 of file tuto_uniform_buffers.cpp.

uvec4

typedef gvec4<unsigned int> glsl::array::uvec4

Definition at line 172 of file tuto_uniform_buffers.cpp.

bvec4

typedef gvec4<int> glsl::array::bvec4

Definition at line 173 of file tuto_uniform_buffers.cpp.

Function Documentation

glsl_string()

const char * glsl_string

(

const GLenum

type

)

Definition at line 180 of file tuto_uniform_buffers.cpp.

{
    switch(type)
    {
        case GL_BOOL:
            return "bool";
        case GL_UNSIGNED_INT:
            return "uint";
        case GL_INT:
            return "int";
        case GL_FLOAT:
            return "float";
        case GL_FLOAT_VEC2:
            return "vec2";
        case GL_FLOAT_VEC3:
            return "vec3";
        case GL_FLOAT_VEC4:
            return "vec4";
        case GL_FLOAT_MAT3:
            return "mat3";
        case GL_FLOAT_MAT4:
            return "mat4";
 
        default:
            return "";
    }
}

print_uniform()

int print_uniform

(

const GLuint

program

)

Definition at line 208 of file tuto_uniform_buffers.cpp.

{
    if(program == 0)
    {
        printf("[error] program 0, no buffers...\n");
        return -1;
    }
    
    // recupere le nombre d'uniform buffers
    GLint buffer_count= 0;
    glGetProgramiv(program, GL_ACTIVE_UNIFORM_BLOCKS, &buffer_count);
    
    for(int i= 0; i < buffer_count; i++)
    {
        // recupere le nom du block et son indice
        char bname[1024]= { 0 };
        glGetActiveUniformBlockName(program, i, sizeof(bname), nullptr, bname);
        
        GLint binding= 0;
        glGetActiveUniformBlockiv(program, i, GL_UNIFORM_BLOCK_BINDING, &binding);
        
        printf("  uniform '%s' binding %d\n", bname, binding);
        
        GLint variable_count= 0;
        glGetActiveUniformBlockiv(program, i, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &variable_count);
        
        std::vector<GLint> variables(variable_count);
        glGetActiveUniformBlockiv(program, i, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, variables.data());
        for(int k= 0; k < variable_count; k++)
        {
            // recupere chaque info... une variable a la fois, 
            GLint glsl_type= 0;
            glGetActiveUniformsiv(program, 1, (GLuint *) &variables[k], GL_UNIFORM_TYPE, &glsl_type);
            GLint offset= 0;
            glGetActiveUniformsiv(program, 1, (GLuint *) &variables[k], GL_UNIFORM_OFFSET, &offset);
            
            GLint array_size= 0;
            glGetActiveUniformsiv(program, 1, (GLuint *) &variables[k], GL_UNIFORM_SIZE, &array_size);
            GLint array_stride= 0;
            glGetActiveUniformsiv(program, 1, (GLuint *) &variables[k], GL_UNIFORM_ARRAY_STRIDE, &array_stride);
            
            GLint matrix_stride= 0;
            glGetActiveUniformsiv(program, 1, (GLuint *) &variables[k], GL_UNIFORM_MATRIX_STRIDE, &matrix_stride);
            GLint matrix_row_major= 0;
            glGetActiveUniformsiv(program, 1, (GLuint *) &variables[k], GL_UNIFORM_IS_ROW_MAJOR, &matrix_row_major);
            
            // nom de la variable
            char vname[1024]= { 0 };
            glGetActiveUniformName(program, variables[k], sizeof(vname), nullptr, vname);
            
            printf("    '%s %s': offset %d", glsl_string(glsl_type), vname, offset);
            if(array_size > 1)
                printf(", array size %d, stride %d", array_size, array_stride);
            
            // organisation des matrices
            if(glsl_type == GL_FLOAT_MAT4 || glsl_type == GL_FLOAT_MAT3)
                printf(", %s, matrix stride %d", matrix_row_major ? "row major" : "column major", matrix_stride);
            
            printf("\n");
        }
        
        GLint buffer_size= 0;
        glGetActiveUniformBlockiv(program, i, GL_UNIFORM_BLOCK_DATA_SIZE, &buffer_size);
        printf("  buffer size %d\n\n", buffer_size);
    }
    
    return 0;
}

init()

int init

(

)

Definition at line 280 of file tuto_uniform_buffers.cpp.

{
    // compile le shader program, le program est selectionne
    program= read_program("gkit2_tutos/uniform.glsl");
    program_print_errors(program);
    
    // affiche l'organisation memoire des uniforms
    print_uniform(program);
    
    struct buffer
    {
        glsl::vec2 a;
        glsl::vec3 b;
        glsl::vec4 c;
        glsl::array::vec2 d[3];
 
        //~ vec2 a;     // align 4
        //~ float pad0;
        //~ float pad1;
        //~ vec3 b;     // align 16
        //~ float pad2;
        //~ vec4 c;     // align 16
        //~ struct { vec2 v; float pad0; float pad1; } d[3];    // d[i].v align 16
        
        //~ vec2 a;
        //~ vec3 b;
        //~ vec4 c;
        //~ vec2 d[3];
    };
    
    printf("a %ld\n",   offsetof(buffer, a));
    printf("a.x %ld\n", offsetof(buffer, a.x));
    printf("a.y %ld\n", offsetof(buffer, a.y));
    
    printf("b %ld\n",   offsetof(buffer, b));
    printf("b.x %ld\n", offsetof(buffer, b.x));
    printf("b.y %ld\n", offsetof(buffer, b.y));
    printf("b.z %ld\n", offsetof(buffer, b.z));
    
    printf("c %ld\n",   offsetof(buffer, c));
    printf("c.x %ld\n", offsetof(buffer, c.x));
    printf("c.y %ld\n", offsetof(buffer, c.y));
    printf("c.z %ld\n", offsetof(buffer, c.z));
    printf("c.w %ld\n", offsetof(buffer, c.w));
    
    printf("d %ld\n",    offsetof(buffer, d));
    printf("d[0] %ld\n", offsetof(buffer, d[0]));
    printf("d[1] %ld\n", offsetof(buffer, d[1]));
    printf("d[2] %ld\n", offsetof(buffer, d[2]));
    
    buffer B;
    B.a= vec2(1, 2);
    B.d[0]= vec2(3, 4);
    B.d[1]= B.d[0];
    
    //~ vec2 d0= B.d[0];
    vec2 d0= B.d[1];
    printf("%f %f\n", d0.x, d0.y);
    return 0;
}

quit()

int quit

(

)

Definition at line 341 of file tuto_uniform_buffers.cpp.

{
    release_program(program);
    return 0;
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 348 of file tuto_uniform_buffers.cpp.

{
    // etape 1 : creer la fenetre
    Window window= create_window(1024, 640);
    if(window == nullptr)
        return 1;
 
    // etape 2 : creer un contexte opengl pour pouvoir dessiner
    Context context= create_context(window);
    if(context == nullptr)
        return 1;
 
    // etape 3 : creation des objets
    if(init() < 0)
    {
        printf("[error] init failed.\n");
        return 1;
    }
 
    // etape 5 : nettoyage
    quit();
    release_context(context);
    release_window(window);
    return 0;
}

Variable Documentation

program

GLuint program

Definition at line 278 of file tuto_uniform_buffers.cpp.