shader_kit.cpp File Reference

shader_kit light, bac a sable fragment shader, cf shader_toy More...

#include <cstdio>
#include <cstring>
#include <chrono>
#include "glcore.h"
#include "window.h"
#include "files.h"
#include "program.h"
#include "uniforms.h"
#include "texture.h"
#include "mesh.h"
#include "wavefront.h"
#include "vec.h"
#include "mat.h"
#include "orbiter.h"
#include "text.h"
#include "widgets.h"

Go to the source code of this file.

Functions
void	reload_program ()
const char *	option_find (std::vector< const char * > &options, const char *ext)
int	init (std::vector< const char * > &options)
int	quit ()
int	draw (void)
int	main (int argc, char **argv)

Variables
const char *	program_filename
GLuint	program
std::string	program_log
int	program_area
bool	program_failed
const char *	mesh_filename
Mesh	mesh
Point	mesh_pmin
Point	mesh_pmax
int	vertex_count
GLuint	vao
bool	wireframe = false
std::vector< const char * >	texture_filenames
std::vector< GLuint >	textures
Orbiter	camera
Widgets	widgets
size_t	last_load = 0

Detailed Description

shader_kit light, bac a sable fragment shader, cf shader_toy

Definition in file shader_kit.cpp.

Function Documentation

init()

int init

(

std::vector< const char * > &

options

)

compile les shaders et construit le programme + les buffers + le vertex array. renvoie -1 en cas d'erreur.

Definition at line 92 of file shader_kit.cpp.

{
    widgets= create_widgets();
    camera= Orbiter();
    
    program= 0;
    const char *option;
    option= option_find(options, ".glsl");
    if(option != nullptr)
    {
        program_filename= option;
        reload_program();
    }
    
    vao= 0;
    mesh_pmin= Point(normalize(Vector(-1, -1, 0)) * 2.5f);
    mesh_pmax= Point(normalize(Vector( 1,  1, 0)) * 2.5f);
    
    option= option_find(options, ".obj");
    if(option != nullptr)
    {
        mesh= read_mesh(option);
        if(mesh.vertex_count() > 0)
        {
            mesh_filename= option;
            
            vao= mesh.create_buffers(mesh.has_texcoord(), mesh.has_normal(), mesh.has_color(), mesh.has_material_index());
            vertex_count= mesh.vertex_count();
            
            mesh.bounds(mesh_pmin, mesh_pmax);
            camera.lookat(mesh_pmin, mesh_pmax);
        }
        
        // ou generer une erreur ? 
    }
    
    if(vao == 0)
    {
        glGenVertexArrays(1, &vao);
        vertex_count= 3;
    }
    
    // charge les textures, si necessaire
    for(int i= 0; i < int(options.size()); i++)
    {
        if(options[i] == nullptr)
            continue;
        
        GLuint texture= read_texture(0, options[i]);
        if(texture > 0)
        {
            texture_filenames.push_back(options[i]);
            textures.push_back(texture);
        }
    }
    
    // nettoyage
    glUseProgram(0);
    glBindTexture(GL_TEXTURE_2D, 0);
    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    
    // etat openGL par defaut
    glClearColor(0.2f, 0.2f, 0.2f, 1.f);
    glClearDepth(1.f);
    
    glCullFace(GL_BACK);
    glFrontFace(GL_CCW);
    //~ glEnable(GL_CULL_FACE); // n'affiche que les faces correctement orientees...
    glDisable(GL_CULL_FACE);    // les faces mal orientees sont affichees avec des hachures oranges...
    
    glDepthFunc(GL_LESS);
    glEnable(GL_DEPTH_TEST);
    
    return 0;    
}