lhark/ripple
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Texture and shaders loading, add quad

Browse source
This commit is contained in:
lhark 2017-11-27 00:11:42 -05:00
parent 72524997ef
commit 5108492544
4 changed files with 331 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
FBO.cpp
View file

@ -92,7 +92,7 @@ void FBO::Init( int w, int h )
glBindTexture(m_Target, m_Texture); glBindTexture(m_Target, m_Texture);
glTexParameteri(m_Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(m_Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(m_Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(m_Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(m_Target, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexImage2D(m_Target, 0, GL_RGBA32F, w, h, 0, GL_RGBA, GL_FLOAT, NULL);
// Créer une texture de profondeurs pour les couleurs avec L'ID m_Profondeur: // Créer une texture de profondeurs pour les couleurs avec L'ID m_Profondeur:
glGenTextures(1, &m_Profondeur); glGenTextures(1, &m_Profondeur);

5
constants.h
View file

@ -7,7 +7,7 @@
#define SCENE_EXTENT 100.0f // extent of the entire scene (packets traveling outside are removed) #define SCENE_EXTENT 100.0f // extent of the entire scene (packets traveling outside are removed)
#define MIN_WATER_DEPTH 0.1f // minimum water depth (meters) #define MIN_WATER_DEPTH 0.1f // minimum water depth (meters)
#define MAX_WATER_DEPTH 5.0f // maximum water depth (meters) #define MAX_WATER_DEPTH 5.0f // maximum water depth (meters)
#define WATER_TERRAIN_FILE "TestIsland.bmp"// Contains water depth and land height in different channels #define WATER_TERRAIN_FILE "./textures/TestIsland.bmp"// Contains water depth and land height in different channels
// rendering parameters // rendering parameters
@ -43,3 +43,6 @@
// UI consts // UI consts
#define MAX_PACKET_BUDGET 100000 #define MAX_PACKET_BUDGET 100000
#define MIN_PACKET_BUDGET 1000 #define MIN_PACKET_BUDGET 1000
#define MIN_WAVE_SPEED 0.0
#define MAX_WAVE_SPEED 1.0
#define INIT_WAVE_SPEED 0.07

4
makefile
View file

@ -8,9 +8,9 @@ DEPDIR := $(BUILDDIR)/deps
#EXE := $(BINDIR)/OPHD #EXE := $(BINDIR)/OPHD
EXE := ripple EXE := ripple
CFLAGS := -std=c++11 -g -Wall -Wno-unknown-pragmas -I/usr/include/glm -I/usr/include/eigen3 $(shell pkg-config --cflags glew) CFLAGS := -std=c++11 -g -fopenmp -Wall -Wno-unknown-pragmas -I/usr/include/glm -I/usr/include/eigen3 $(shell pkg-config --cflags glew)
CFLAGS += $(shell pkg-config --cflags sdl2) CFLAGS += $(shell pkg-config --cflags sdl2)
LDFLAGS := -lstdc++ -lm -lglfw -lGLEW -lGL LDFLAGS := -fopenmp -lstdc++ -lm -lglfw -lGLEW -lGL
LDFLAGS += $(shell pkg-config --libs sdl2) LDFLAGS += $(shell pkg-config --libs sdl2)
DEPFLAGS = -MT $@ -MMD -MP -MF $(DEPDIR)/$*.Td DEPFLAGS = -MT $@ -MMD -MP -MF $(DEPDIR)/$*.Td

458
ripple.cpp
View file

@ -7,8 +7,16 @@
#define SOL 1 #define SOL 1
enum {LocAttrib, LocUniform}; /* Shader location type */
// variables pour l'utilisation des nuanceurs // variables pour l'utilisation des nuanceurs
GLuint prog; // votre programme de nuanceurs GLuint prog; // votre programme de nuanceurs
GLuint progRasterizeWaveMeshPosition;
GLuint progAddPacketDisplacement;
GLuint progDisplayPacketOutlined;
GLuint progDisplayMicroMesh;
GLuint progDisplayTerrain;
GLuint progRenderAA;
GLint locVertex = -1; GLint locVertex = -1;
GLint locNormal = -1; GLint locNormal = -1;
GLint locTexCoord = -1; GLint locTexCoord = -1;
@ -17,6 +25,50 @@ GLint locmatrVisu = -1;
GLint locmatrProj = -1; GLint locmatrProj = -1;
GLint locmatrNormale = -1; GLint locmatrNormale = -1;
GLint loclaTexture = -1; GLint loclaTexture = -1;
// Locations for RasterizeWaveMeshPosition shader
GLint locVertexRWMP = -1;
GLint locTexCoordRWMP = -1;
GLint locmatrModelRWMP = -1;
GLint locmatrVisuRWMP = -1;
GLint locmatrProjRWMP = -1;
GLint locmatrNormaleRWMP = -1;
GLint locTexRWMP = -1;
// Locations for AddPacketDisplacement shader
GLuint locVertexADP = -1;
GLuint locTexCoordADP = -1;
GLuint locmatrModelADP = -1;
GLuint locmatrVisuADP = -1;
GLuint locmatrProjADP = -1;
GLuint locTexADP = -1;
// Locations for DisplayPacketOutlined shader
GLuint locVertexDPO = -1;
GLuint locTexCoordDPO = -1;
GLuint locmatrModelDPO = -1;
GLuint locmatrVisuDPO = -1;
GLuint locmatrProjDPO = -1;
GLuint locTexDPO = -1;
// Locations for DisplayMicroMesh shader
GLuint locVertexDMM = -1;
GLuint locTexCoordDMM = -1;
GLuint locmatrModelDMM = -1;
GLuint locmatrVisuDMM = -1;
GLuint locmatrProjDMM = -1;
GLuint locTexDMM = -1;
// Locationss for DisplayTerrain shader
GLuint locVertexDT = -1;
GLuint locTexCoordDT = -1;
GLuint locmatrModelDT = -1;
GLuint locmatrVisuDT = -1;
GLuint locmatrProjDT = -1;
GLuint locTexDT = -1;
// Locations for RenderAA shader
GLuint locVertexRAA = -1;
GLuint locTexCoordRAA = -1;
GLuint locmatrModelRAA = -1;
GLuint locmatrVisuRAA = -1;
GLuint locmatrProjRAA = -1;
GLuint locTexRAA = -1;
GLuint indLightSource; GLuint indLightSource;
GLuint indFrontMaterial; GLuint indFrontMaterial;
GLuint indLightModel; GLuint indLightModel;
@ -29,6 +81,8 @@ GLint locmatrVisuBase = -1;
GLint locmatrProjBase = -1; GLint locmatrProjBase = -1;
GLuint vao[2]; GLuint vao[2];
GLuint vaoQuad;
GLuint vbosQuad[2];
GLuint vbo[5]; GLuint vbo[5];
GLuint ubo[4]; GLuint ubo[4];
@ -62,6 +116,12 @@ FBO *aaFBO;
// Wave Packets // Wave Packets
Packets *packets; Packets *packets;
int packetBudget = MIN_PACKET_BUDGET;
/* Wave packets:
* vec4: xy = position, zw = direction
* vec4: x = amplitude, y = wavelength, z = phase offset, w = enveloppe size
* vec4: for rendering x = center of wave bending circle*/
GLfloat packetData[PACKET_GPU_BUFFER_SIZE * 3 * 4];
//////////////////////////////////////// ////////////////////////////////////////
// déclaration des variables globales // // déclaration des variables globales //
@ -71,7 +131,7 @@ Packets *packets;
int modele = 1; // le modèle à afficher int modele = 1; // le modèle à afficher
// partie 3: texture // partie 3: texture
GLuint textureDE = 0; GLuint texTerrain = 0;
GLuint textureECHIQUIER = 0; GLuint textureECHIQUIER = 0;
// définition des lumières // définition des lumières
@ -165,13 +225,6 @@ void calculerPhysique( )
if ( LightSource[0].spotAngle < 5.0 ) sensAngle = -sensAngle; if ( LightSource[0].spotAngle < 5.0 ) sensAngle = -sensAngle;
if ( LightSource[0].spotAngle > 60.0 ) sensAngle = -sensAngle; if ( LightSource[0].spotAngle > 60.0 ) sensAngle = -sensAngle;
#if 0
static int sensExposant = 1;
LightSource[0].spotExposant += sensExposant * 0.3;
if ( LightSource[0].spotExposant < 1.0 ) sensExposant = -sensExposant;
if ( LightSource[0].spotExposant > 10.0 ) sensExposant = -sensExposant;
#endif
// De temps à autre, alterner entre le modèle d'illumination: Lambert, Gouraud, Phong // De temps à autre, alterner entre le modèle d'illumination: Lambert, Gouraud, Phong
static float type = 0; static float type = 0;
type += 0.005; type += 0.005;
@ -181,33 +234,142 @@ void calculerPhysique( )
verifierAngles(); verifierAngles();
} }
void updatePackets()
{
// Compute wave packets
packets->AdvectWavePackets(INIT_WAVE_SPEED);
// TODO Setup wide projection for InitiateWaveField (RasterizeWaveMeshPosition)
int displayedPackets = 0;
int packetChunk =0;
/* Standard wave packets */
for (int i = 0; i < packets->m_usedPackets; ++i) {
int pk = packets->m_usedPacket[i];
/* Test for 3rd vertex (sliding point) */
if (!packets->m_packet[pk].use3rd) {
/* Position */
packetData[packetChunk++] = packets->m_packet[pk].midPos.x();
packetData[packetChunk++] = packets->m_packet[pk].midPos.y();
/* Direction */
packetData[packetChunk++] = packets->m_packet[pk].travelDir.x();
packetData[packetChunk++] = packets->m_packet[pk].travelDir.y();
/* Att1 */
packetData[packetChunk++] = packets->m_packet[pk].ampOld;
packetData[packetChunk++] = 2.0f * M_PI / packets->m_packet[pk].k;
packetData[packetChunk++] = packets->m_packet[pk].phase;
packetData[packetChunk++] = packets->m_packet[pk].envelope;
/* Att2 */
packetData[packetChunk++] = packets->m_packet[pk].bending;
packetChunk += 3; /* The last 3 elements aren't needed */
displayedPackets++;
if (packetChunk >= PACKET_GPU_BUFFER_SIZE * 3 * 4) {
/* TODO Update VBO */
/* TODO EvaluatePackets(packetChunk) */
packetChunk = 0;
}
}
}
/* Ghost packets */
for (int i = 0; i < packets->m_usedGhosts; ++i) {
int pk = packets->m_usedGhost[i];
/* Position */
packetData[packetChunk++] = packets->m_ghostPacket[pk].pos.x();
packetData[packetChunk++] = packets->m_ghostPacket[pk].pos.y();
/* Direction */
packetData[packetChunk++] = packets->m_ghostPacket[pk].dir.x();
packetData[packetChunk++] = packets->m_ghostPacket[pk].dir.y();
/* Att1 */
packetData[packetChunk++] = packets->m_ghostPacket[pk].ampOld;
packetData[packetChunk++] = 2.0f * M_PI / packets->m_ghostPacket[pk].k;
packetData[packetChunk++] = packets->m_ghostPacket[pk].phase;
packetData[packetChunk++] = packets->m_ghostPacket[pk].envelope;
/* Att2 */
packetData[packetChunk++] = packets->m_ghostPacket[pk].bending;
packetChunk += 3; /* The last 3 elements aren't needed */
displayedPackets++;
if (packetChunk >= PACKET_GPU_BUFFER_SIZE * 3 * 4) {
/* TODO Update VBO */
/* TODO EvaluatePackets(packetChunk) */
packetChunk = 0;
}
}
/* TODO Update VBO */
/* TODO EvaluatePackets(packetChunk) */
/* TODO DisplayScene */
/* TODO Get camera center */
}
void chargerTextures() void chargerTextures()
{ {
unsigned char *pixels; unsigned char *pixels;
GLsizei largeur, hauteur; GLsizei largeur, hauteur;
if ( ( pixels = ChargerImage( "textures/de.bmp", largeur, hauteur ) ) != NULL ) if ( ( pixels = ChargerImage( WATER_TERRAIN_FILE, largeur, hauteur ) ) != NULL )
{ {
glGenTextures( 1, &textureDE ); glGenTextures( 1, &texTerrain );
glBindTexture( GL_TEXTURE_2D, textureDE ); glBindTexture( GL_TEXTURE_2D, texTerrain );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, largeur, hauteur, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glBindTexture( GL_TEXTURE_2D, 0 );
delete[] pixels;
}
if ( ( pixels = ChargerImage( "textures/echiquier.bmp", largeur, hauteur ) ) != NULL )
{
glGenTextures( 1, &textureECHIQUIER );
glBindTexture( GL_TEXTURE_2D, textureECHIQUIER );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, largeur, hauteur, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, largeur, hauteur, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glBindTexture( GL_TEXTURE_2D, 0 ); glBindTexture( GL_TEXTURE_2D, 0 );
delete[] pixels; delete[] pixels;
} }
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
} }
/* Create program and link it
* Input : filenames for vertex, geometry and fragment shader, or NULL*/
GLuint createShader(const GLchar *shaders[3])
{
GLuint prog;
GLenum shaderType[3] = {
GL_VERTEX_SHADER,
GL_GEOMETRY_SHADER,
GL_FRAGMENT_SHADER
};
prog = glCreateProgram();
for (int i = 0; i < 3; ++i) {
if (shaders[i] != NULL) {
printf("Compiling %s ...\n", shaders[i]);
const GLchar *shaderStr = ProgNuanceur::lireNuanceur(shaders[i]);
if (shaderStr == NULL)
break;
GLuint s = glCreateShader(shaderType[i]);
glShaderSource( s, 1, &shaderStr, NULL );
glCompileShader( s );
glAttachShader( prog, s );
ProgNuanceur::afficherLogCompile( s );
delete [] shaderStr;
}
}
glLinkProgram(prog);
ProgNuanceur::afficherLogLink(prog);
return prog;
}
GLuint
getloc(GLuint prog, const GLchar *name, const int type)
{
GLuint loc;
switch (type) {
case LocAttrib:
loc = glGetAttribLocation(prog, name);
break;
case LocUniform:
loc = glGetUniformLocation(prog, name);
break;
}
if (loc == -1)
fprintf(stderr, "Cannot find location for %s\n", name);
return loc;
}
void chargerNuanceurs() void chargerNuanceurs()
{ {
// charger le nuanceur de base // charger le nuanceur de base
@ -237,76 +399,28 @@ void chargerNuanceurs()
ProgNuanceur::afficherLogLink( progBase ); ProgNuanceur::afficherLogLink( progBase );
// demander la "Location" des variables // demander la "Location" des variables
if ( ( locVertexBase = glGetAttribLocation( progBase, "Vertex" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de Vertex" << std::endl; locVertexBase = getloc( progBase, "Vertex", LocAttrib );
if ( ( locColorBase = glGetAttribLocation( progBase, "Color" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de Color" << std::endl; locColorBase = getloc( progBase, "Color", LocAttrib );
if ( ( locmatrModelBase = glGetUniformLocation( progBase, "matrModel" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de matrModel" << std::endl; locmatrModelBase = getloc( progBase, "matrModel", LocUniform );
if ( ( locmatrVisuBase = glGetUniformLocation( progBase, "matrVisu" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de matrVisu" << std::endl; locmatrVisuBase = getloc( progBase, "matrVisu", LocUniform );
if ( ( locmatrProjBase = glGetUniformLocation( progBase, "matrProj" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de matrProj" << std::endl; locmatrProjBase = getloc( progBase, "matrProj", LocUniform );
} }
// charger le nuanceur de ce TP // charger le nuanceur de ce TP
{ {
// créer le programme // créer le programme
prog = glCreateProgram(); const GLchar *shaders[3] = {"nuanceurSommetsSolution.glsl", "nuanceurGeometrieSolution.glsl", "nuanceurFragmentsSolution.glsl"};
prog = createShader(shaders);
// attacher le nuanceur de sommets
#if !defined(SOL)
const GLchar *chainesSommets = ProgNuanceur::lireNuanceur( "nuanceurSommets.glsl" );
#else
const GLchar *chainesSommets = ProgNuanceur::lireNuanceur( "nuanceurSommetsSolution.glsl" );
#endif
if ( chainesSommets != NULL )
{
GLuint nuanceurObj = glCreateShader( GL_VERTEX_SHADER );
glShaderSource( nuanceurObj, 1, &chainesSommets, NULL );
glCompileShader( nuanceurObj );
glAttachShader( prog, nuanceurObj );
ProgNuanceur::afficherLogCompile( nuanceurObj );
delete [] chainesSommets;
}
#if !defined(SOL)
const GLchar *chainesGeometrie = ProgNuanceur::lireNuanceur( "nuanceurGeometrie.glsl" );
#else
const GLchar *chainesGeometrie = ProgNuanceur::lireNuanceur( "nuanceurGeometrieSolution.glsl" );
#endif
if ( chainesGeometrie != NULL )
{
GLuint nuanceurObj = glCreateShader( GL_GEOMETRY_SHADER );
glShaderSource( nuanceurObj, 1, &chainesGeometrie, NULL );
glCompileShader( nuanceurObj );
glAttachShader( prog, nuanceurObj );
ProgNuanceur::afficherLogCompile( nuanceurObj );
delete [] chainesGeometrie;
}
// attacher le nuanceur de fragments
#if !defined(SOL)
const GLchar *chainesFragments = ProgNuanceur::lireNuanceur( "nuanceurFragments.glsl" );
#else
const GLchar *chainesFragments = ProgNuanceur::lireNuanceur( "nuanceurFragmentsSolution.glsl" );
#endif
if ( chainesFragments != NULL )
{
GLuint nuanceurObj = glCreateShader( GL_FRAGMENT_SHADER );
glShaderSource( nuanceurObj, 1, &chainesFragments, NULL );
glCompileShader( nuanceurObj );
glAttachShader( prog, nuanceurObj );
ProgNuanceur::afficherLogCompile( nuanceurObj );
delete [] chainesFragments;
}
// faire l'édition des liens du programme
glLinkProgram( prog );
ProgNuanceur::afficherLogLink( prog );
// demander la "Location" des variables // demander la "Location" des variables
if ( ( locVertex = glGetAttribLocation( prog, "Vertex" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de Vertex" << std::endl; locVertex = getloc( prog, "Vertex", LocAttrib );
if ( ( locNormal = glGetAttribLocation( prog, "Normal" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de Normal (partie 1)" << std::endl; locNormal = getloc( prog, "Normal", LocAttrib );
if ( ( locTexCoord = glGetAttribLocation( prog, "TexCoord" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de TexCoord (partie 3)" << std::endl; locTexCoord = getloc( prog, "TexCoord", LocAttrib );
if ( ( locmatrModel = glGetUniformLocation( prog, "matrModel" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de matrModel" << std::endl; locmatrModel = getloc( prog, "matrModel" , LocUniform);
if ( ( locmatrVisu = glGetUniformLocation( prog, "matrVisu" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de matrVisu" << std::endl; locmatrVisu = getloc( prog, "matrVisu" , LocUniform);
if ( ( locmatrProj = glGetUniformLocation( prog, "matrProj" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de matrProj" << std::endl; locmatrProj = getloc( prog, "matrProj" , LocUniform);
if ( ( locmatrNormale = glGetUniformLocation( prog, "matrNormale" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de matrNormale (partie 1)" << std::endl; locmatrNormale = getloc( prog, "matrNormale" , LocUniform);
if ( ( loclaTexture = glGetUniformLocation( prog, "laTexture" ) ) == -1 ) std::cerr << "!!! pas trouvé la \"Location\" de laTexture (partie 3)" << std::endl; loclaTexture = getloc( prog, "laTexture" , LocUniform);
if ( ( indLightSource = glGetUniformBlockIndex( prog, "LightSourceParameters" ) ) == GL_INVALID_INDEX ) std::cerr << "!!! pas trouvé l'\"index\" de LightSource" << std::endl; if ( ( indLightSource = glGetUniformBlockIndex( prog, "LightSourceParameters" ) ) == GL_INVALID_INDEX ) std::cerr << "!!! pas trouvé l'\"index\" de LightSource" << std::endl;
if ( ( indFrontMaterial = glGetUniformBlockIndex( prog, "MaterialParameters" ) ) == GL_INVALID_INDEX ) std::cerr << "!!! pas trouvé l'\"index\" de FrontMaterial" << std::endl; if ( ( indFrontMaterial = glGetUniformBlockIndex( prog, "MaterialParameters" ) ) == GL_INVALID_INDEX ) std::cerr << "!!! pas trouvé l'\"index\" de FrontMaterial" << std::endl;
if ( ( indLightModel = glGetUniformBlockIndex( prog, "LightModelParameters" ) ) == GL_INVALID_INDEX ) std::cerr << "!!! pas trouvé l'\"index\" de LightModel" << std::endl; if ( ( indLightModel = glGetUniformBlockIndex( prog, "LightModelParameters" ) ) == GL_INVALID_INDEX ) std::cerr << "!!! pas trouvé l'\"index\" de LightModel" << std::endl;
@ -346,8 +460,116 @@ void chargerNuanceurs()
glUniformBlockBinding( prog, indvarsUnif, bindingIndex ); glUniformBlockBinding( prog, indvarsUnif, bindingIndex );
} }
} }
// Load RasterizeWaveMeshPosition shader
{
// créer le programme
const GLchar *shaders[3] = {"rasterizeWaveMeshPosition.vert", NULL, "rasterizeWaveMeshPosition.frag"};
progRasterizeWaveMeshPosition = createShader(shaders);
// demander la "Location" des variables
locVertexRWMP = getloc( progRasterizeWaveMeshPosition, "Vertex" , LocAttrib);
locTexCoordRWMP = getloc( progRasterizeWaveMeshPosition, "TexCoord" , LocAttrib);
locmatrModelRWMP = getloc( progRasterizeWaveMeshPosition, "matrModel" , LocUniform);
locmatrVisuRWMP = getloc( progRasterizeWaveMeshPosition, "matrVisu" , LocUniform);
locmatrProjRWMP = getloc( progRasterizeWaveMeshPosition, "matrProj" , LocUniform);
locTexRWMP = getloc( progRasterizeWaveMeshPosition, "tex" , LocUniform);
} }
// Load AddPacketDisplacement shader
{
// créer le programme
const GLchar *shaders[3] = {"addPacketDisplacement.vert", "addPacketDisplacement.geom", "addPacketDisplacement.frag"};
progAddPacketDisplacement = createShader(shaders);
// demander la "Location" des variables
locVertexADP = getloc( progAddPacketDisplacement, "Vertex" , LocAttrib);
locTexCoordADP = getloc( progAddPacketDisplacement, "TexCoord" , LocAttrib);
locmatrModelADP = getloc( progAddPacketDisplacement, "matrModel" , LocUniform);
locmatrVisuADP = getloc( progAddPacketDisplacement, "matrVisu" , LocUniform);
locmatrProjADP = getloc( progAddPacketDisplacement, "matrProj" , LocUniform);
locTexADP = getloc( progAddPacketDisplacement, "tex" , LocUniform);
}
// Load DisplayPacketOutlined shader
{
const GLchar *shaders[3] = {"displayPacketOutlined.vert", "displayPacketOutlined.geom", "displayPacketOutlined.frag"};
progDisplayPacketOutlined = createShader(shaders);
locVertexDPO = getloc( progDisplayPacketOutlined, "Vertex" , LocAttrib);
locTexCoordDPO = getloc( progDisplayPacketOutlined, "TexCoord" , LocAttrib);
locmatrModelDPO = getloc( progDisplayPacketOutlined, "matrModel" , LocUniform);
locmatrVisuDPO = getloc( progDisplayPacketOutlined, "matrVisu" , LocUniform);
locmatrProjDPO = getloc( progDisplayPacketOutlined, "matrProj" , LocUniform);
locTexDPO = getloc( progDisplayPacketOutlined, "tex" , LocUniform);
}
// Load DisplayMicroMesh shader
{
const GLchar *shaders[3] = {"displayMicroMesh.vert", "displayMicroMesh.geom", "displayMicroMesh.frag"};
progDisplayMicroMesh = createShader(shaders);
locVertexDMM = getloc( progDisplayMicroMesh, "Vertex" , LocAttrib);
locTexCoordDMM = getloc( progDisplayMicroMesh, "TexCoord" , LocAttrib);
locmatrModelDMM = getloc( progDisplayMicroMesh, "matrModel" , LocUniform);
locmatrVisuDMM = getloc( progDisplayMicroMesh, "matrVisu" , LocUniform);
locmatrProjDMM = getloc( progDisplayMicroMesh, "matrProj" , LocUniform);
locTexDMM = getloc( progDisplayMicroMesh, "tex" , LocUniform);
}
// Load DisplayTerrain shader
{
const GLchar *shaders[3] = {"displayTerrain.vert", NULL, "displayTerrain.frag"};
progDisplayTerrain = createShader(shaders);
locVertexDT = getloc( progDisplayTerrain, "Vertex" , LocAttrib);
locTexCoordDT = getloc( progDisplayTerrain, "TexCoord" , LocAttrib);
locmatrModelDT = getloc( progDisplayTerrain, "matrModel" , LocUniform);
locmatrVisuDT = getloc( progDisplayTerrain, "matrVisu" , LocUniform);
locmatrProjDT = getloc( progDisplayTerrain, "matrProj" , LocUniform);
locTexDT = getloc( progDisplayTerrain, "tex" , LocUniform);
}
// Load RenderAA shader
{
const GLchar *shaders[3] = {"displayTerrain.vert", NULL, "displayTerrain.frag"};
progRenderAA = createShader(shaders);
locVertexRAA = getloc( progRenderAA, "Vertex" , LocAttrib);
locTexCoordRAA = getloc( progRenderAA, "TexCoord" , LocAttrib);
locmatrModelRAA = getloc( progRenderAA, "matrModel" , LocUniform);
locmatrVisuRAA = getloc( progRenderAA, "matrVisu" , LocUniform);
locmatrProjRAA = getloc( progRenderAA, "matrProj" , LocUniform);
locTexRAA = getloc( progRenderAA, "tex" , LocUniform);
}
}
// Create a screen space quad
void initQuad()
{
GLfloat vertices[3*2*2] = {
-1.0, -1.0, 1.0, -1.0, -1.0, 1.0,
1.0, -1.0, 1.0, 1.0, -1.0, 1.0
};
GLfloat texcoords[3*2*2] = {
0.0, 1.0, 1.0, 1.0, 0.0, 0.0,
1.0, 1.0, 1.0, 0.0, 0.0, 0.0
};
// allouer les objets OpenGL
glGenVertexArrays( 1, &vaoQuad );
glGenBuffers( 2, vbosQuad );
// initialiser le VAO
glBindVertexArray( vaoQuad );
// charger le VBO pour les vertices
glBindBuffer( GL_ARRAY_BUFFER, vbosQuad[0] );
glBufferData( GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW );
glVertexAttribPointer( locVertexRWMP, 2, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locVertex);
// Charger le VBO pour les coordonnées de texture
glBindBuffer( GL_ARRAY_BUFFER, vbosQuad[1] );
glBufferData( GL_ARRAY_BUFFER, sizeof(texcoords), texcoords, GL_STATIC_DRAW );
glVertexAttribPointer( locTexCoordRWMP, 2, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locTexCoord);
}
// initialisation d'openGL // initialisation d'openGL
void initialiser() void initialiser()
{ {
@ -361,6 +583,9 @@ void initialiser()
heightFBO = new FBO(); heightFBO = new FBO();
aaFBO = new FBO(); aaFBO = new FBO();
// Create Packets
packets = new Packets(packetBudget);
// couleur de l'arrière-plan // couleur de l'arrière-plan
glClearColor( 0.4, 0.2, 0.0, 1.0 ); glClearColor( 0.4, 0.2, 0.0, 1.0 );
@ -375,6 +600,7 @@ void initialiser()
// charger les nuanceurs // charger les nuanceurs
chargerNuanceurs(); chargerNuanceurs();
initQuad();
glUseProgram( prog ); glUseProgram( prog );
// (partie 1) créer le cube // (partie 1) créer le cube
@ -497,6 +723,16 @@ void conclure()
delete aaFBO; delete aaFBO;
} }
void drawQuad()
{
glUseProgram(progRasterizeWaveMeshPosition);
glUniformMatrix4fv( locmatrProjRWMP, 1, GL_FALSE, matrProj );
glUniformMatrix4fv( locmatrVisuRWMP, 1, GL_FALSE, matrVisu );
glUniformMatrix4fv( locmatrModelRWMP, 1, GL_FALSE, matrModel );
glBindVertexArray(vaoQuad);
glDrawArrays(GL_TRIANGLES, 0, 6);
}
void afficherModele() void afficherModele()
{ {
// partie 3: paramètres de texture // partie 3: paramètres de texture
@ -508,7 +744,7 @@ void afficherModele()
break; break;
case 1: case 1:
//std::cout << "Texture DE" << std::endl; //std::cout << "Texture DE" << std::endl;
glBindTexture( GL_TEXTURE_2D, textureDE ); glBindTexture( GL_TEXTURE_2D, texTerrain );
break; break;
case 2: case 2:
//std::cout << "Texture ECHIQUIER" << std::endl; //std::cout << "Texture ECHIQUIER" << std::endl;
@ -530,53 +766,7 @@ void afficherModele()
// (partie 1: ne pas oublier de calculer et donner une matrice pour les transformations des normales) // (partie 1: ne pas oublier de calculer et donner une matrice pour les transformations des normales)
glUniformMatrix3fv( locmatrNormale, 1, GL_TRUE, glm::value_ptr( glm::inverse( glm::mat3( matrVisu.getMatr() * matrModel.getMatr() ) ) ) ); glUniformMatrix3fv( locmatrNormale, 1, GL_TRUE, glm::value_ptr( glm::inverse( glm::mat3( matrVisu.getMatr() * matrModel.getMatr() ) ) ) );
switch ( modele ) drawQuad();
{
default:
case 1:
// afficher le cube
glBindVertexArray( vao[0] );
glBindBuffer( GL_ARRAY_BUFFER, varsUnif.texnumero == 1 ? vbo[2] : vbo[3] );
glVertexAttribPointer( locTexCoord, 2, GL_FLOAT, GL_FALSE, 0, 0 );
glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
glDrawArrays( GL_TRIANGLE_STRIP, 4, 4 );
glDrawArrays( GL_TRIANGLE_STRIP, 8, 4 );
glDrawArrays( GL_TRIANGLE_STRIP, 12, 4 );
glDrawArrays( GL_TRIANGLE_STRIP, 16, 4 );
glDrawArrays( GL_TRIANGLE_STRIP, 20, 4 );
glBindVertexArray( 0 );
break;
case 2:
tore->afficher();
break;
case 3:
sphere->afficher();
break;
case 4:
matrModel.Rotate( -90.0, 1.0, 0.0, 0.0 );
matrModel.Translate( 0.0, 0.0, -0.5 );
matrModel.Scale( 0.5, 0.5, 0.5 );
glUniformMatrix4fv( locmatrModel, 1, GL_FALSE, matrModel );
glUniformMatrix3fv( locmatrNormale, 1, GL_TRUE, glm::value_ptr( glm::inverse( glm::mat3( matrVisu.getMatr() * matrModel.getMatr() ) ) ) );
theiere->afficher( );
break;
case 5:
matrModel.PushMatrix(); {
matrModel.Translate( 0.0, 0.0, -1.5 );
glUniformMatrix4fv( locmatrModel, 1, GL_FALSE, matrModel );
glUniformMatrix3fv( locmatrNormale, 1, GL_TRUE, glm::value_ptr( glm::inverse( glm::mat3( matrVisu.getMatr() * matrModel.getMatr() ) ) ) );
cylindre->afficher();
} matrModel.PopMatrix();
break;
case 6:
matrModel.PushMatrix(); {
matrModel.Translate( 0.0, 0.0, -1.5 );
glUniformMatrix4fv( locmatrModel, 1, GL_FALSE, matrModel );
glUniformMatrix3fv( locmatrNormale, 1, GL_TRUE, glm::value_ptr( glm::inverse( glm::mat3( matrVisu.getMatr() * matrModel.getMatr() ) ) ) );
cone->afficher();
} matrModel.PopMatrix();
break;
}
} matrModel.PopMatrix(); glUniformMatrix4fv( locmatrModel, 1, GL_FALSE, matrModel ); } matrModel.PopMatrix(); glUniformMatrix4fv( locmatrModel, 1, GL_FALSE, matrModel );
} }
@ -644,7 +834,7 @@ void FenetreTP::afficherScene()
} }
glUniformMatrix4fv( locmatrProjBase, 1, GL_FALSE, matrProj ); glUniformMatrix4fv( locmatrProjBase, 1, GL_FALSE, matrProj );
matrVisu.LookAt( 0.0, 0.0, distCam, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0 ); matrVisu.LookAt( 0.0, 3.0, distCam, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0 );
glUniformMatrix4fv( locmatrVisuBase, 1, GL_FALSE, matrVisu ); glUniformMatrix4fv( locmatrVisuBase, 1, GL_FALSE, matrVisu );
matrModel.LoadIdentity(); matrModel.LoadIdentity();