// The MAIN function, from here we start our application and run our Game loop
int main()
{
// Init GLFW
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", nullptr, nullptr); // Windowed
glfwMakeContextCurrent(window);
// Set the required callback functions
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
// Options
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// Initialize GLEW to setup the OpenGL Function pointers
glewExperimental = GL_TRUE;
glewInit();
// Define the viewport dimensions
glViewport(0, 0, SCR_WIDTH*2, SCR_HEIGHT*2);
// Setup some OpenGL options
glEnable(GL_DEPTH_TEST);
// Setup and compile our shaders
Shader shader("shaders/advanced_lighting.vs", "shaders/advanced_lighting.frag");
GLfloat planeVertices[] = {
// Positions // Normals // Texture Coords
8.0f, -0.5f, 8.0f, 0.0f, 1.0f, 0.0f, 5.0f, 0.0f,
-8.0f, -0.5f, 8.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
-8.0f, -0.5f, -8.0f, 0.0f, 1.0f, 0.0f, 0.0f, 5.0f,
8.0f, -0.5f, 8.0f, 0.0f, 1.0f, 0.0f, 5.0f, 0.0f,
-8.0f, -0.5f, -8.0f, 0.0f, 1.0f, 0.0f, 0.0f, 5.0f,
8.0f, -0.5f, -8.0f, 0.0f, 1.0f, 0.0f, 5.0f, 5.0f
};
// Setup plane VAO
GLuint planeVAO, planeVBO;
glGenVertexArrays(1, &planeVAO);
glGenBuffers(1, &planeVBO);
glBindVertexArray(planeVAO);
glBindBuffer(GL_ARRAY_BUFFER, planeVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), &planeVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
glBindVertexArray(0);
// Light source
glm::vec3 lightPos(0.0f, 0.0f, 0.0f);
// Load textures
GLuint floorTexture = loadTexture("resources/textures/wood.png");
/*-------------------Load models--------------------*/
Model ourModel("resources/objects/nanosuit/nanosuit.obj");
Shader model_shader("shaders/model_shader.vs", "shaders/model_shader.frag");
/*--------------------------------------------------*/
// Game loop
while(!glfwWindowShouldClose(window))
{
// Set frame time
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// Check and call events
glfwPollEvents();
Do_Movement();
// Clear the colorbuffer
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Draw objects
shader.Use();
glm::mat4 view = camera.GetViewMatrix();
glm::mat4 projection = glm::perspective(camera.Zoom, (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
glUniformMatrix4fv(glGetUniformLocation(shader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(shader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
// Set light uniforms
glUniform3fv(glGetUniformLocation(shader.Program, "lightPos"), 1, &lightPos[0]);
glUniform3fv(glGetUniformLocation(shader.Program, "viewPos"), 1, &camera.Position[0]);
glUniform1i(glGetUniformLocation(shader.Program, "blinn"), blinn);
// Floor
glBindVertexArray(planeVAO);
glBindTexture(GL_TEXTURE_2D, floorTexture);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
model_shader.Use();
// Transformation matrices
glUniformMatrix4fv(glGetUniformLocation(model_shader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
glUniformMatrix4fv(glGetUniformLocation(model_shader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
// Draw the loaded model
glm::mat4 model;
//model = glm::translate(model, glm::vec3(0.0f, -1.75f, 0.0f)); // Translate it down a bit so it's at the center of the scene
//model = glm::scale(model, glm::vec3(0.2f, 0.2f, 0.2f)); // It's a bit too big for our scene, so scale it down
glUniformMatrix4fv(glGetUniformLocation(model_shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));
ourModel.Draw(model_shader);
//std::cout << (blinn ? "true" : "false") << std::endl;
// Swap the buffers
glfwSwapBuffers(window);
}
glfwTerminate();
return 0;
}
/*!****************************************************************************
@Function InitView
@Return bool true if no error occured
@Description Code in InitView() will be called by PVRShell upon
initialization or after a change in the rendering context.
Used to initialize variables that are dependant on the rendering
context (e.g. textures, vertex buffers, etc.)
******************************************************************************/
bool OGLES2StencilBuffer::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
m_Cylinder.LoadVbos();
m_Sphere.LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Set the sampler2D uniforms to corresponding texture units
glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sTexture"), 0);
// Is the screen rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
// Set stencil clear value
glClearStencil(0);
return true;
}
void Uniform::set1i(GLint x)
{
glUniform1i(uniformLocation, x);
}
void templateAppDraw(void) {
glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
gfx->set_matrix_mode(MODELVIEW_MATRIX);
gfx->load_identity();
if (view_delta->x || view_delta->y) {
if (view_delta->y) next_rotz -= view_delta->y;
if (view_delta->x) {
next_rotx -= view_delta->x;
next_rotx = CLAMP(next_rotx, 0.0f, 90.0f);
}
view_delta->x =
view_delta->y = 0.0f;
}
rotx = rotx * 0.9f + next_rotx * 0.1f;
rotz = rotz * 0.9f + next_rotz * 0.1f;
eye->x = center->x +
distance *
cosf(rotx * DEG_TO_RAD) *
sinf(rotz * DEG_TO_RAD);
eye->y = center->y -
distance *
cosf(rotx * DEG_TO_RAD) *
cosf(rotz * DEG_TO_RAD);
eye->z = center->z +
distance *
sinf(rotx * DEG_TO_RAD);
rotx = rotx * 0.9f + next_rotx * 0.1f;
rotz = rotz * 0.9f + next_rotz * 0.1f;
center = maze->location;
gfx->look_at(eye,
center,
up);
if (double_tap) {
/* Variable to hold the 3D location on the far plane of the frustum. */
vec3 location;
/* This function converts a 2D point from the screen coordinates
* to a 3D point in space. The return value is true or false, depending on
* whether or not the query is successful. It's a GFX helper, but built
* basically the same way as the standard gluUnproject
* (http://www.opengl.org/sdk/docs/man/xhtml/gluUnproject.xml)
* function.
*/
if (gfx->unproject(view_location->x,
/* The origin of the OpenGLES color buffer is down
* left, but its location for iOS and Android is up
* left. To handle this situation, simply use the
* viewport matrix height data (viewport_matrix[3])
* to readjust the Y location of the picking point
* onscreen.
*/
viewport_matrix[3] - view_location->y,
/* This parameter represents the depth that you want
* to query, with 1 representing the far clipping
* plane and 0 representing the near clipping plane.
* In this case, you are only interested in the far
* clipping plane value, which explains the value 1.
*/
1.0f,
gfx->get_modelview_matrix(),
gfx->get_projection_matrix(),
viewport_matrix,
location)) {
/* Now that you have the XYZ location on the far plane, you can
* create the collision ray. Begin by creating the starting point,
* which is basically the current camera eye position.
*/
btVector3 ray_from(eye->x,
eye->y,
eye->z),
/* Translate the resulting location of GFX::unproject based on the
* current eye location to make sure that the coordinate system
* will fit with what the player currently sees onscreen.
*/
ray_to(location->x + eye->x,
location->y + eye->y,
location->z + eye->z);
/* Create the collision ray. */
btCollisionWorld::ClosestRayResultCallback collision_ray(ray_from,
ray_to);
/* Launch the ray in space. */
dynamicsworld->rayTest(ray_from,
ray_to,
collision_ray);
/* Check if the collision ray gets a hit, and check if the
* collision object involved is the maze btRigidBody.
*/
if (collision_ray.hasHit() &&
collision_ray.m_collisionObject == maze->btrigidbody) {
collision_ray.m_hitNormalWorld.normalize();
/* Check if the normal Z is pointing upward to make sure
* the hit is on the floor of the maze.
*/
if (collision_ray.m_hitNormalWorld.z() == 1.0f) {
/* Since you got a valid hit, it is time to create the
* pathfinding query to send to Detour. First, assign
* the current player location as the starting point of
* the query.
*/
navigationpath_player.start_location = player->location;
/* Then simply use the collision ray hit position XYZ as
* the end point of the path query.
*/
navigationpath_player.end_location->x = collision_ray.m_hitPointWorld.x();
navigationpath_player.end_location->y = collision_ray.m_hitPointWorld.y();
navigationpath_player.end_location->z = collision_ray.m_hitPointWorld.z();
/* The query is ready to be sent to Detour, so send it over.
* If Detour was able to find a path, the function will
* return 1 and will store the way points information
* inside the navigationpathdata_player variable; othewise
* the function will return 0.
*/
if (navigation->get_path(&navigationpath_player,
&navigationpathdata_player)) {
player_next_point = 1;
/* Loop while you've got some way points. Please note
* that by default, the function will assign the number
* of path_point_count to be the way points returned by
* Detour. However, the function implementation added
* another point which is the exact same end location
* that you specified in your query. The reason is
* that, most of the time, the ending point not exactly
* on the mavigation mesh, so the library will return
* the closest pont. Depending on what you want to
* achieve, you may or may not want to use this extra
* way point. But for this tutorial, you are going to
* take it into consideration.
*/
for (int i=0; i!=navigationpathdata_player.path_point_count + 1; ++i)
console_print("%d: %f %f %f\n",
i,
navigationpathdata_player.path_point_array[i]->x,
navigationpathdata_player.path_point_array[i]->y,
navigationpathdata_player.path_point_array[i]->z);
printf("\n");
}
}
}
}
double_tap = 0;
}
if (navigationpathdata_player.path_point_count) {
move_entity(player, // The player OBJMESH pointer.
&navigationpathdata_player, // The player navigation path
// structure.
&player_next_point, // The way point the player is
// moving towards.
3.0f); // The speed to use as factor
// to the linear velocity of
// the btRigidBody.
}
program->draw();
glUniform1i(program->get_uniform_location(TM_Diffuse_String), TM_Diffuse);
for (auto objmesh=obj->objmesh.begin();
objmesh!=obj->objmesh.end(); ++objmesh) {
gfx->push_matrix();
mat4 mat;
objmesh->btrigidbody->getWorldTransform().getOpenGLMatrix(mat.m());
objmesh->location = vec3(mat[3], true);
gfx->multiply_matrix(mat);
glUniformMatrix4fv(program->get_uniform_location((char *)"MODELVIEWPROJECTIONMATRIX"),
1,
GL_FALSE,
gfx->get_modelview_projection_matrix().m());
objmesh->draw();
gfx->pop_matrix();
}
navigation->draw(gfx);
dynamicsworld->stepSimulation(1.0f / 60.0f);
}
void outPut::drawTerrain(bool reinit)
{
static bool lastwfStatus(!_reg.WIREFRAME);
if(lastwfStatus != _reg.WIREFRAME)
{
if(_reg.WIREFRAME)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glLineWidth(1);
}
else
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}}
lastwfStatus = _reg.WIREFRAME;
static bool init(true);
static VA terrain;
static GLuint buf_pos, buf_norm, buf_cost, buf_index;
unsigned int nbVertices = _dimensions.x*_dimensions.y;
unsigned int nbIndex = (_dimensions.x-1)*(_dimensions.y-1)*6;
//nbIndex = nbVertices;
/*Chaque vertex est associé à une maille qui 'coûte' 6 indices en mémoire :
_
|\| -> deux triangles, avec 3 indices par triangle. On enlève une ligne et une colonne parce que ceux sur les côtés n'entrainent pas une maille.
+-
*/
if(init || reinit)
{
gen_verticesMap();
drawNormals(true);
glDeleteBuffers(1,&buf_pos);
glDeleteBuffers(1,&buf_norm);
glDeleteBuffers(1,&buf_cost);
glDeleteBuffers(1,&buf_index);
delete terrain.verticesA;
delete terrain.normalsA;
delete terrain.costsA;
delete terrain.indexA;
terrain.verticesA = new float[nbVertices*P_SIZE];
terrain.normalsA = new float[nbVertices*N_SIZE];
terrain.costsA = new int[nbVertices*C_SIZE];
terrain.indexA = new unsigned int[nbIndex];
///Remplissage des tableaux de sommets et de coûts
for(unsigned int i = 0; i < _dimensions.x; i++)
{
for(unsigned int j = 0; j < _dimensions.y; j++)
{
coords3d<float> vertex(0,0,0), normal(0,0,0);
vertex = getVertex<float>(i,j);
normal = _scene3d.normalMap[i][j];
int vertexPos = (i*_dimensions.y+j);
terrain.verticesA[vertexPos*P_SIZE] = vertex.x;
terrain.verticesA[vertexPos*P_SIZE+1] = vertex.y;
terrain.verticesA[vertexPos*P_SIZE+2] = vertex.z;
terrain.normalsA[vertexPos*P_SIZE] = normal.x;
terrain.normalsA[vertexPos*P_SIZE+1] = normal.y;
terrain.normalsA[vertexPos*P_SIZE+2] = normal.z;
terrain.costsA[vertexPos*C_SIZE] = -1;
}
}
///Remplissage de l'index
for(unsigned int i = 0; i < _dimensions.x-1; i++)
{
for(unsigned int j = 0; j < _dimensions.y-1; j++)
{
terrain.indexA[((i*(_dimensions.y-1))+j)*6] = i*_dimensions.y+j;
terrain.indexA[((i*(_dimensions.y-1))+j)*6+2] = i*_dimensions.y+j+1;
terrain.indexA[((i*(_dimensions.y-1))+j)*6+1] = (i+1)*_dimensions.y+j;
terrain.indexA[((i*(_dimensions.y-1))+j)*6+3] = i*_dimensions.y+j+1;
terrain.indexA[((i*(_dimensions.y-1))+j)*6+4] = (i+1)*_dimensions.y+j;
terrain.indexA[((i*(_dimensions.y-1))+j)*6+5] = (i+1)*_dimensions.y+j+1;
//cout << "\nindice max : " << ((i*(_dimensions.y-1))+j)*6+5 << " / " << nbIndex;
}
}
/* creation de nos VBO+IBO */
glGenBuffers(1, &buf_pos);
glGenBuffers(1, &buf_cost);
glGenBuffers(1, &buf_norm);
glGenBuffers(1, &buf_index);
/* construction du VBO de positions */
glBindBuffer(GL_ARRAY_BUFFER, buf_pos);
glBufferData(GL_ARRAY_BUFFER, (nbVertices*P_SIZE*sizeof *terrain.verticesA),
NULL, GL_STREAM_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*P_SIZE*sizeof
*terrain.verticesA), terrain.verticesA);
/* construction du VBO de normales */
glBindBuffer(GL_ARRAY_BUFFER, buf_norm);
glBufferData(GL_ARRAY_BUFFER, (nbVertices*N_SIZE*sizeof *terrain.normalsA),
NULL, GL_STREAM_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*N_SIZE*sizeof
*terrain.normalsA), terrain.normalsA);
/* construction du VBO de coûts */
glBindBuffer(GL_ARRAY_BUFFER, buf_cost);
glBufferData(GL_ARRAY_BUFFER, (nbVertices*C_SIZE*sizeof *terrain.costsA),
NULL, GL_STREAM_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*C_SIZE*sizeof
*terrain.costsA), terrain.costsA);
/* construction du IBO */
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf_index);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, nbIndex * sizeof *terrain.indexA,
NULL, GL_STREAM_DRAW);
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, nbIndex * sizeof
*terrain.indexA, terrain.indexA);
//On debind les VBO+IBO
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
_maxValue = 1;
// cout<<"\n(re)initialisation de l'affichage du terrain reussie\n";
init = false;
_valueChanges.clear();
}
drawAxis();
glBindBuffer(GL_ARRAY_BUFFER, buf_cost);
for(unsigned int i = 0; i < _valueChanges.size(); ++i)
{
int newCost = _valueChanges[i].value;
//newCost = 2;
//std::cout << newCost << "/" << _maxValue << std::endl;
glBufferSubData(GL_ARRAY_BUFFER, (_valueChanges[i].x*_dimensions.y + _valueChanges[i].y)*(sizeof newCost)*C_SIZE, (sizeof
newCost), &newCost);
//terrain.costsA[_valueChanges[i].x*_dimensions.y + _valueChanges[i].y] = newCost;
}
/*
glBufferSubData(GL_ARRAY_BUFFER, 0, (nbVertices*C_SIZE*sizeof
*terrain.costsA), terrain.costsA);*/
catchError("application de changements de couleur");
_valueChanges.clear();
glEnable(GL_DEPTH_TEST);
if(_reg.DRAW_NORMALS)
drawNormals();
glUseProgram(_sLight.getProgramID());
//Envoi des uniforms
glUniform1i(uid_maxCost, _maxValue);
catchError("Envoi de la valeur max");
glUniform3f(uid_defaultColor, _reg.UNIFORM_COLOR[0],_reg.UNIFORM_COLOR[1],_reg.UNIFORM_COLOR[2]);
/* specification du buffer des positions de sommets */
glEnableVertexAttribArray(aID_position);
glBindBuffer(GL_ARRAY_BUFFER, buf_pos);
glVertexAttribPointer(aID_position, P_SIZE , GL_FLOAT, 0, 0, BUFFER_OFFSET(0) );
/* specification du buffer des normales de sommets */
glEnableVertexAttribArray(aID_normal);
glBindBuffer(GL_ARRAY_BUFFER, buf_norm);
glVertexAttribPointer(aID_normal, N_SIZE , GL_FLOAT, 0, 0, BUFFER_OFFSET(0) );
/* specification du buffer des coûts de sommets */
glEnableVertexAttribArray(aID_cost);
glBindBuffer(GL_ARRAY_BUFFER, buf_cost);
glVertexAttribIPointer(aID_cost, C_SIZE, GL_INT, 0, BUFFER_OFFSET(0));
/*Spécification de l'index*/
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf_index);
glEnableClientState(GL_VERTEX_ARRAY);
glDrawElements(GL_TRIANGLES, nbIndex, GL_UNSIGNED_INT, BUFFER_OFFSET(0));
glDisableVertexAttribArray(aID_position);
glDisableVertexAttribArray(aID_normal);
glDisableVertexAttribArray(aID_cost);
//On debind les VBO+IBO
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDisableVertexAttribArray(aID_position);
glDisableVertexAttribArray(aID_normal);
glDisableVertexAttribArray(aID_cost);
glUseProgram(0);
}
void myinit(void)
{
// Load shaders and use the resulting shader program
GLuint program = InitShader( "vshader.glsl", "fshader.glsl" );
glUseProgram(program);
// Generate vertex arrays for geometric shapes
generateCube(program, &cubeData);
generateSphere(program, &sphereData);
generateCone(program, &coneData);
generateCylinder(program, &cylData);
uModelView = glGetUniformLocation( program, "ModelView" );
uProjection = glGetUniformLocation( program, "Projection" );
uView = glGetUniformLocation( program, "View" );
glClearColor( 0.1, 0.1, 0.2, 1.0 ); // dark blue background
uAmbient = glGetUniformLocation( program, "AmbientProduct" );
uDiffuse = glGetUniformLocation( program, "DiffuseProduct" );
uSpecular = glGetUniformLocation( program, "SpecularProduct" );
uLightPos = glGetUniformLocation( program, "LightPosition" );
uShininess = glGetUniformLocation( program, "Shininess" );
uTex = glGetUniformLocation( program, "Tex" );
uEnableTex = glGetUniformLocation( program, "EnableTex" );
glUniform4f(uAmbient, 0.2f, 0.2f, 0.2f, 1.0f);
glUniform4f(uDiffuse, 0.6f, 0.6f, 0.6f, 1.0f);
glUniform4f(uSpecular, 0.2f, 0.2f, 0.2f, 1.0f);
glUniform4f(uLightPos, 15.0f, 15.0f, 30.0f, 0.0f);
glUniform1f(uShininess, 100.0f);
glEnable(GL_DEPTH_TEST);
TgaImage coolImage;
if (!coolImage.loadTGA("challenge.tga"))
{
printf("Error loading image file\n");
exit(1);
}
TgaImage earthImage;
if (!earthImage.loadTGA("earth.tga"))
{
printf("Error loading image file\n");
exit(1);
}
glGenTextures( 1, &texture_cube );
glBindTexture( GL_TEXTURE_2D, texture_cube );
glTexImage2D(GL_TEXTURE_2D, 0, 4, coolImage.width, coolImage.height, 0,
(coolImage.byteCount == 3) ? GL_BGR : GL_BGRA,
GL_UNSIGNED_BYTE, coolImage.data );
glGenerateMipmap(GL_TEXTURE_2D);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glGenTextures( 1, &texture_earth );
glBindTexture( GL_TEXTURE_2D, texture_earth );
glTexImage2D(GL_TEXTURE_2D, 0, 4, earthImage.width, earthImage.height, 0,
(earthImage.byteCount == 3) ? GL_BGR : GL_BGRA,
GL_UNSIGNED_BYTE, earthImage.data );
glGenerateMipmap(GL_TEXTURE_2D);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
//glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
//glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
// Set texture sampler variable to texture unit 0
// (set in glActiveTexture(GL_TEXTURE0))
glUniform1i( uTex, 0);
Arcball = new BallData ;
Ball_Init(Arcball);
Ball_Place(Arcball,qOne,0.75);
}
// ---------------------------------------------------------------- display ---
void display( void )
{
static int frame=0, time, timebase=0;
static int count = 0;
static GLuint texture = 0;
if( !texture )
{
texture = glGetUniformLocation( shader, "texture" );
}
if( count == 0 && frame == 0 )
{
printf(
"Computing FPS with text generation and rendering at each frame...\n" );
printf(
"Number of glyphs: %d\n", (int)wcslen(text)*line_count );
}
frame++;
time = glutGet( GLUT_ELAPSED_TIME );
if( time-timebase > (2500) )
{
printf( "FPS : %.2f (%d frames in %.2f second, %.1f glyph/second)\n",
frame*1000.0/(time-timebase), frame, (time-timebase)/1000.0,
frame*1000.0/(time-timebase) * wcslen(text)*line_count );
timebase = time;
frame = 0;
++count;
if( count == 5 )
{
printf( "\nComputing FPS with text rendering at each frame...\n" );
printf( "Number of glyphs: %d\n", (int)wcslen(text)*line_count );
}
if( count > 9 )
{
exit( EXIT_SUCCESS );
}
}
if( count < 5 )
{
size_t i;
vec4 color = {{0,0,0,1}};
vec2 pen = {{0,0}};
vertex_buffer_clear( buffer );
pen.y = -font->descender;
for( i=0; i<line_count; ++i )
{
pen.x = 10.0;
add_text( buffer, font, text, &color, &pen );
pen.y += font->height - font->linegap;
}
}
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glBindTexture( GL_TEXTURE_2D, atlas->id );
glUseProgram( shader );
glUniform1i(texture, 0);
vertex_buffer_render( buffer, GL_TRIANGLES );
glUseProgram( 0 );
glutSwapBuffers( );
}
// The MAIN function, from here we start the application and run the game loop
int main()
{
// Init GLFW
glfwInit();
// Set all the required options for GLFW
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// Create a GLFWwindow object that we can use for GLFW's functions
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr);
glfwMakeContextCurrent(window);
// Set the required callback functions
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
// GLFW Options
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions
glewExperimental = GL_TRUE;
// Initialize GLEW to setup the OpenGL Function pointers
glewInit();
// Define the viewport dimensions
glViewport(0, 0, WIDTH, HEIGHT);
// OpenGL options
glEnable(GL_DEPTH_TEST);
// Build and compile our shader program
Shader lightingShader("light_casters.vs", "light_casters.frag");
Shader lampShader("lamp.vs", "lamp.frag");
// Set up vertex data (and buffer(s)) and attribute pointers
GLfloat vertices[] = {
// Positions // Normals // Texture Coords
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f
};
// Positions all containers
glm::vec3 cubePositions[] = {
glm::vec3( 0.0f, 0.0f, 0.0f),
glm::vec3( 2.0f, 5.0f, -15.0f),
glm::vec3(-1.5f, -2.2f, -2.5f),
glm::vec3(-3.8f, -2.0f, -12.3f),
glm::vec3( 2.4f, -0.4f, -3.5f),
glm::vec3(-1.7f, 3.0f, -7.5f),
glm::vec3( 1.3f, -2.0f, -2.5f),
glm::vec3( 1.5f, 2.0f, -2.5f),
glm::vec3( 1.5f, 0.2f, -1.5f),
glm::vec3(-1.3f, 1.0f, -1.5f)
};
// First, set the container's VAO (and VBO)
GLuint VBO, containerVAO;
glGenVertexArrays(1, &containerVAO);
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindVertexArray(containerVAO);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glBindVertexArray(0);
// Then, we set the light's VAO (VBO stays the same. After all, the vertices are the same for the light object (also a 3D cube))
GLuint lightVAO;
glGenVertexArrays(1, &lightVAO);
glBindVertexArray(lightVAO);
// We only need to bind to the VBO (to link it with glVertexAttribPointer), no need to fill it; the VBO's data already contains all we need.
glBindBuffer(GL_ARRAY_BUFFER, VBO);
// Set the vertex attributes (only position data for the lamp))
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); // Note that we skip over the other data in our buffer object (we don't need the normals/textures, only positions).
glEnableVertexAttribArray(0);
glBindVertexArray(0);
// Load textures
GLuint diffuseMap, specularMap, emissionMap;
glGenTextures(1, &diffuseMap);
glGenTextures(1, &specularMap);
glGenTextures(1, &emissionMap);
int width, height;
unsigned char* image;
// Diffuse map
image = SOIL_load_image(FileSystem::getPath("resources/textures/container2.png").c_str(), &width, &height, 0, SOIL_LOAD_RGB);
glBindTexture(GL_TEXTURE_2D, diffuseMap);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
SOIL_free_image_data(image);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);
// Specular map
image = SOIL_load_image(FileSystem::getPath("resources/textures/container2_specular.png").c_str(), &width, &height, 0, SOIL_LOAD_RGB);
glBindTexture(GL_TEXTURE_2D, specularMap);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
SOIL_free_image_data(image);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
// Set texture units
lightingShader.Use();
glUniform1i(glGetUniformLocation(lightingShader.Program, "material.diffuse"), 0);
glUniform1i(glGetUniformLocation(lightingShader.Program, "material.specular"), 1);
// Game loop
while (!glfwWindowShouldClose(window))
{
// Calculate deltatime of current frame
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions
glfwPollEvents();
do_movement();
// Clear the colorbuffer
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Use cooresponding shader when setting uniforms/drawing objects
lightingShader.Use();
GLint lightPosLoc = glGetUniformLocation(lightingShader.Program, "light.position");
GLint lightSpotdirLoc = glGetUniformLocation(lightingShader.Program, "light.direction");
GLint lightSpotCutOffLoc = glGetUniformLocation(lightingShader.Program, "light.cutOff");
GLint lightSpotOuterCutOffLoc = glGetUniformLocation(lightingShader.Program, "light.outerCutOff");
GLint viewPosLoc = glGetUniformLocation(lightingShader.Program, "viewPos");
glUniform3f(lightPosLoc, camera.Position.x, camera.Position.y, camera.Position.z);
glUniform3f(lightSpotdirLoc, camera.Front.x, camera.Front.y, camera.Front.z);
glUniform1f(lightSpotCutOffLoc, glm::cos(glm::radians(12.5f)));
glUniform1f(lightSpotOuterCutOffLoc, glm::cos(glm::radians(17.5f)));
glUniform3f(viewPosLoc, camera.Position.x, camera.Position.y, camera.Position.z);
// Set lights properties
glUniform3f(glGetUniformLocation(lightingShader.Program, "light.ambient"), 0.1f, 0.1f, 0.1f);
// We set the diffuse intensity a bit higher; note that the right lighting conditions differ with each lighting method and environment.
// Each environment and lighting type requires some tweaking of these variables to get the best out of your environment.
glUniform3f(glGetUniformLocation(lightingShader.Program, "light.diffuse"), 0.8f, 0.8f, 0.8f);
glUniform3f(glGetUniformLocation(lightingShader.Program, "light.specular"), 1.0f, 1.0f, 1.0f);
glUniform1f(glGetUniformLocation(lightingShader.Program, "light.constant"), 1.0f);
glUniform1f(glGetUniformLocation(lightingShader.Program, "light.linear"), 0.09);
glUniform1f(glGetUniformLocation(lightingShader.Program, "light.quadratic"), 0.032);
// Set material properties
glUniform1f(glGetUniformLocation(lightingShader.Program, "material.shininess"), 32.0f);
// Create camera transformations
glm::mat4 view;
view = camera.GetViewMatrix();
glm::mat4 projection = glm::perspective(camera.Zoom, (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f);
// Get the uniform locations
GLint modelLoc = glGetUniformLocation(lightingShader.Program, "model");
GLint viewLoc = glGetUniformLocation(lightingShader.Program, "view");
GLint projLoc = glGetUniformLocation(lightingShader.Program, "projection");
// Pass the matrices to the shader
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
// Bind diffuse map
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, diffuseMap);
// Bind specular map
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, specularMap);
// Draw the container (using container's vertex attributes)
/*glBindVertexArray(containerVAO);
glm::mat4 model;
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);*/
// Draw 10 containers with the same VAO and VBO information; only their world space coordinates differ
glm::mat4 model;
glBindVertexArray(containerVAO);
for (GLuint i = 0; i < 10; i++)
{
model = glm::mat4();
model = glm::translate(model, cubePositions[i]);
GLfloat angle = 20.0f * i;
model = glm::rotate(model, angle, glm::vec3(1.0f, 0.3f, 0.5f));
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
// Again, no need to draw the lamp object
// Also draw the lamp object, again binding the appropriate shader
//lampShader.Use();
//// Get location objects for the matrices on the lamp shader (these could be different on a different shader)
//modelLoc = glGetUniformLocation(lampShader.Program, "model");
//viewLoc = glGetUniformLocation(lampShader.Program, "view");
//projLoc = glGetUniformLocation(lampShader.Program, "projection");
//// Set matrices
//glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
//glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
//model = glm::mat4();
//model = glm::translate(model, lightPos);
//model = glm::scale(model, glm::vec3(0.2f)); // Make it a smaller cube
//glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
//// Draw the light object (using light's vertex attributes)
//glBindVertexArray(lightVAO);
//glDrawArrays(GL_TRIANGLES, 0, 36);
//glBindVertexArray(0);
// Swap the screen buffers
glfwSwapBuffers(window);
}
// Terminate GLFW, clearing any resources allocated by GLFW.
glfwTerminate();
return 0;
}
void SSEffect::render(GLuint posVBO, GLuint colVBO, unsigned int num, RTPSSettings* settings, const Light* light,const Material* material, float scale, GLuint sceneTex, GLuint sceneDepthTex, GLuint framebuffer)
{
if(num==0)
return;
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
currentDepthBuffer="depth";
bool blending = settings->GetSettingAs<bool>("blending","1");
//QT send 2 for check boxes when enable(due to the possiblity of adding a tristate option.
//Apparently the default string-to-bool conversion is true for 1 and false otherwise
//I need it to be false for 0 and true otherwise.
//bool thickness = !settings->GetSettingAs<int>("thickness","1");
bool thickness = settings->GetSettingAs<bool>("thickness","1");
//perserve original buffer
GLint buffer;
glGetIntegerv(GL_DRAW_BUFFER,&buffer);
glClearColor(0.0f,0.0f,0.0f,0.0f);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,m_fbos[0]);
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glActiveTexture(GL_TEXTURE0);
glDisable(GL_TEXTURE_2D);
//Should probably conditionally create the thickness buffer as well.
//Render Thickness buffer.
if(thickness)
{
m_timers["render_thickness"]->start();
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
//give the fluid some thickness everywhere
glClearColor(0.1f,0.1f,0.1f,1.0f);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"],0);
//glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClear(GL_COLOR_BUFFER_BIT);
renderPointsAsSpheres( m_shaderLibrary->shaders["sphereThicknessShader"].getProgram(),posVBO, colVBO, num,settings, light,material,scale);
//renderPointsAsSpheres( m_shaderLibrary->shaders["sphereShader"].getProgram(),posVBO, colVBO, num,settings, light,material,scale);
glFinish();
m_timers["render_thickness"]->stop();
m_timers["blur_thickness"]->start();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness2"],0);
GLuint program= m_shaderLibrary->shaders["fixedWidthGaussianShader"].getProgram();
glEnable(GL_TEXTURE_2D);
float xdir[] = {1.0f/height,0.0f};
float ydir[] = {0.0f,1.0f/width};
glUseProgram(program);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]);
glUniform1i( glGetUniformLocation(program, "imgTex"),0);
glUniform2fv( glGetUniformLocation(program, "dTex"),1,xdir);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
RenderUtils::fullscreenQuad();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness2"]);
glUniform2fv( glGetUniformLocation(program, "dTex"),1,ydir);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
RenderUtils::fullscreenQuad();
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDisable(GL_TEXTURE_2D);
glFinish();
m_timers["blur_thickness"]->stop();
}
//glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT,framebuffer);
m_timers["render_spheres"]->start();
//Render Color and depth buffer of spheres.
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth"],0);
glEnable(GL_TEXTURE_2D);
GLuint sphereProgram = m_shaderLibrary->shaders["sphereShader"].getProgram();
glBindTexture(GL_TEXTURE_2D,sceneDepthTex);
glUseProgram(sphereProgram);
glUniform1i(glGetUniformLocation(sphereProgram,"sceneDepth"),0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
renderPointsAsSpheres(sphereProgram,posVBO, colVBO, num,settings, light,material,scale);
glFinish();
m_timers["render_spheres"]->stop();
//Smooth the depth texture to emulate a surface.
m_timers["smooth_depth"]->start();
//glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth2"],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth"]);
currentDepthBuffer="depth2";
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
smoothDepth(settings);
glFinish();
m_timers["smooth_depth"]->stop();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0);
//Switch to the buffer that was written to in the smoothing step
if(currentDepthBuffer=="depth2")
currentDepthBuffer="depth";
else
currentDepthBuffer="depth2";
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
//if (blending)
//{
//glDepthMask(GL_FALSE);
// glEnable(GL_BLEND);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//}
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"],0);
m_timers["calculate_normals"]->start();
//Now we use the depth to normal shader which converts screenspace depth into
//world coordinates and then computes lighting.
glClear(GL_COLOR_BUFFER_BIT);
GLuint normalProgram = m_shaderLibrary->shaders["depth2NormalShader"].getProgram();
glUseProgram(normalProgram);
glUniform1i( glGetUniformLocation(normalProgram, "depthTex"),0);
glUniform1f( glGetUniformLocation(normalProgram, "del_x"),1.0/((float)width));
glUniform1f( glGetUniformLocation(normalProgram, "del_y"),1.0/((float)height));
RenderUtils::fullscreenQuad();
glFinish();
m_timers["calculate_normals"]->stop();
m_timers["render_composite"]->start();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0);
GLuint compositeProgram = m_shaderLibrary->shaders["compositeFluidShader"].getProgram();
glUseProgram(compositeProgram);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D,sceneTex);
glUniform1i( glGetUniformLocation(compositeProgram, "depthTex"),0);
glUniform1i( glGetUniformLocation(compositeProgram, "normalTex"),1);
glUniform1i( glGetUniformLocation(compositeProgram, "thicknessTex"),2);
glUniform1i( glGetUniformLocation(compositeProgram, "sceneTex"),3);
glUniform1f( glGetUniformLocation(compositeProgram, "gamma"),settings->GetSettingAs<float>("thickness_gamma","0.1"));
//dout<<"Here"<<endl;
if(material)
{
glUniform3fv(glGetUniformLocation(compositeProgram,"material.diffuse"),1,&material->diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.specular"),1,&material->specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.ambient"),1,&material->ambient.x);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.shininess"),1,&material->shininess);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.opacity"),1,&material->opacity);
}
else
{
Material defaultMat;
defaultMat.ambient=float3(0.05f,0.075f,0.25f);
defaultMat.diffuse=float3(0.05f,0.075f,0.25f);
defaultMat.specular=float3(1.0f,1.f,1.0f);
defaultMat.opacity=0.5;
defaultMat.shininess=100;
glUniform3fv(glGetUniformLocation(compositeProgram,"material.diffuse"),1,&defaultMat.diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.specular"),1,&defaultMat.specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.ambient"),1,&defaultMat.ambient.x);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.shininess"),1,&defaultMat.shininess);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.opacity"),1,&defaultMat.opacity);
}
if(light)
{
glUniform3fv(glGetUniformLocation(compositeProgram,"light.diffuse"),1,&light->diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.specular"),1,&light->specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.ambient"),1,&light->ambient.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.position"),1,&light->pos.x);
}
else
{
Light defaultLight;
defaultLight.ambient = float3(0.2f,0.2f,0.2f);
defaultLight.diffuse = float3(1.0f,1.0f,1.0f);
defaultLight.specular = float3(1.0f,1.0f,1.0f);
defaultLight.pos = float3(5.0f,10.0f,-5.0f);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.diffuse"),1,&defaultLight.diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.specular"),1,&defaultLight.specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.ambient"),1,&defaultLight.ambient.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.position"),1,&defaultLight.pos.x);
}
RenderUtils::fullscreenQuad();
glFinish();
m_timers["render_composite"]->stop();
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D,0);
//glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,framebuffer);
m_timers["copy_to_fbo"]->start();
glDrawBuffer(buffer);
glActiveTexture(GL_TEXTURE0);
GLuint copyProgram = m_shaderLibrary->shaders["copyShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "colorTex"),0);
if(settings->GetSettingAs<bool>("render_composite","1"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["Color"]);
}
else if(settings->GetSettingAs<bool>("render_normal","0"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"]);
copyProgram = m_shaderLibrary->shaders["copyInverseShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "colorTex"),0);
}
else if(settings->GetSettingAs<bool>("render_depth","0"))
{
if(currentDepthBuffer=="depth2")
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth"]);
else
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth2"]);
copyProgram = m_shaderLibrary->shaders["copyDepthColorShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0);
}
else if(settings->GetSettingAs<bool>("render_depth_smoothed","0"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
copyProgram = m_shaderLibrary->shaders["copyDepthColorShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0);
}
else if(settings->GetSettingAs<bool>("render_thickness","0"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]);
copyProgram = m_shaderLibrary->shaders["copyScalarShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0);
}
else
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["Color"]);
}
//need to copy the contents to the back buffer. It's important that we copy the
//depth as well. Otherwise anything drawn afterwards may incorrecly occlude the fluid.
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
glUseProgram(copyProgram);
glUniform1i( glGetUniformLocation(copyProgram, "depthTex"),1);
RenderUtils::fullscreenQuad();
glFinish();
m_timers["copy_to_fbo"]->stop();
glUseProgram(0);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,0);
//if (blending)
//{
//glDisable(GL_BLEND);
//}
glPopAttrib();
glPopClientAttrib();
if (m_writeFramebuffers)
{
glFinish();
writeFramebufferTextures();
m_writeFramebuffers = false;
}
}
// The MAIN function, from here we start the application and run the game loop
int main()
{
// Init GLFW
glfwInit();
// Set all the required options for GLFW
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// On mac os, must have this config.
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
// Create a GLFWwindow object that we can use for GLFW's functions
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr);
glfwMakeContextCurrent(window);
// Set the required callback functions
glfwSetKeyCallback(window, key_callback);
// Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions
glewExperimental = GL_TRUE;
// Initialize GLEW to setup the OpenGL Function pointers
glewInit();
// Define the viewport dimensions
glViewport(0, 0, WIDTH, HEIGHT);
glEnable(GL_DEPTH_TEST);
// Build and compile our shader program
ShaderProgram ourShader("/Users/Evan/Documents/XcodeWorkspace/OpenGLCoreStudy/OpenGLCoreStudy/TestCode/GLSL/First3DObjects.vsh", "/Users/Evan/Documents/XcodeWorkspace/OpenGLCoreStudy/OpenGLCoreStudy/TestCode/GLSL/First3DObjects.fsh");
// Set up vertex data (and buffer(s)) and attribute pointers
GLfloat vertices[] = {
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f
};
glm::vec3 cubePositions[] = {
glm::vec3( 0.0f, 0.0f, 0.0f),
glm::vec3( 2.0f, 5.0f, -15.0f),
glm::vec3(-1.5f, -2.2f, -2.5f),
glm::vec3(-3.8f, -2.0f, -12.3f),
glm::vec3( 2.4f, -0.4f, -3.5f),
glm::vec3(-1.7f, 3.0f, -7.5f),
glm::vec3( 1.3f, -2.0f, -2.5f),
glm::vec3( 1.5f, 2.0f, -2.5f),
glm::vec3( 1.5f, 0.2f, -1.5f),
glm::vec3(-1.3f, 1.0f, -1.5f)
};
GLuint VBO, VAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// Position attribute
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
// TexCoord attribute
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glBindVertexArray(0); // Unbind VAO
// Load and create a texture
GLuint texture1;
GLuint texture2;
// ====================
// Texture 1
// ====================
glGenTextures(1, &texture1);
glBindTexture(GL_TEXTURE_2D, texture1); // All upcoming GL_TEXTURE_2D operations now have effect on our texture object
// Set our texture parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture wrapping to GL_REPEAT
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// Set texture filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Load, create texture and generate mipmaps
int width, height;
unsigned char* image = SOIL_load_image("/Users/Evan/Documents/XcodeWorkspace/OpenGLCoreStudy/OpenGLCoreStudy/Resource/Image/container.jpg", &width, &height, 0, SOIL_LOAD_RGB);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
SOIL_free_image_data(image);
glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture when done, so we won't accidentily mess up our texture.
// ===================
// Texture 2
// ===================
glGenTextures(1, &texture2);
glBindTexture(GL_TEXTURE_2D, texture2);
// Set our texture parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// Set texture filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Load, create texture and generate mipmaps
image = SOIL_load_image("/Users/Evan/Documents/XcodeWorkspace/OpenGLCoreStudy/OpenGLCoreStudy/Resource/Image/awesomeface.png", &width, &height, 0, SOIL_LOAD_RGB);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
SOIL_free_image_data(image);
glBindTexture(GL_TEXTURE_2D, 0);
// Game loop
while (!glfwWindowShouldClose(window))
{
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions
glfwPollEvents();
do_movement();
// Render
// Clear the colorbuffer
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Bind Textures using texture units
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture1);
glUniform1i(glGetUniformLocation(ourShader.program, "ourTexture1"), 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture2);
glUniform1i(glGetUniformLocation(ourShader.program, "ourTexture2"), 1);
// Activate shader
ourShader.useShader();
// Camera/View transformation
glm::mat4 view;
view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
// Projection
glm::mat4 projection;
projection = glm::perspective(45.0f, (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f);
// Get the uniform locations
GLint modelLoc = glGetUniformLocation(ourShader.program, "model");
GLint viewLoc = glGetUniformLocation(ourShader.program, "view");
GLint projLoc = glGetUniformLocation(ourShader.program, "projection");
// Pass the matrices to the shader
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
glBindVertexArray(VAO);
for (GLuint i = 0; i < 10; i++)
{
// Calculate the model matrix for each object and pass it to shader before drawing
glm::mat4 model;
model = glm::translate(model, cubePositions[i]);
GLfloat angle = 20.0f * i;
model = glm::rotate(model, angle, glm::vec3(1.0f, 0.3f, 0.5f));
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
// Swap the screen buffers
glfwSwapBuffers(window);
}
// Properly de-allocate all resources once they've outlived their purpose
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
// Terminate GLFW, clearing any resources allocated by GLFW.
glfwTerminate();
return 0;
}
void display(void)
{
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor3f(1.0f, 1.0f, 1.0f);
if (ps.renderMode == 0) {
int i;
glColor3f(0.3f, 0.8f, 1.0f);
glEnable(GL_BLEND);
glEnable(GL_POINT_SMOOTH);
glPointSize(5.0f);
glBegin(GL_POINTS);
for (i = 0; i < ps.pNum; i++)
{
//
if(ps.p[i].phase == bubble)
glColor3f(1.0f, 0.3f, 0.8f);
else if(ps.p[i].phase == water)
glColor3f(0.5f, 0.8f, 1.0f);
else
glColor3f(0.3f, 1.0f, 0.8f);
glVertex2fv(&ps.p[i].pos.x);
}
glEnd();
glPointSize(1.0f);
glDisable(GL_POINT_SMOOTH);
glDisable(GL_BLEND);
}
else if (ps.renderMode > 0) {
//glBindTexture(GL_TEXTURE_2D, waterTex);
//glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, RENDER_SAMPLE, RENDER_SAMPLE, GL_RGBA, GL_FLOAT, ps.texture);
//glEnable(GL_TEXTURE_2D);
//glBegin(GL_QUADS);
//glTexCoord2f(0.0f, 0.0f);
//glVertex2f(0.0f, 0.0f);
//glTexCoord2f(1.0f, 0.0f);
//glVertex2f(1.0f, 0.0f);
//glTexCoord2f(1.0f, 1.0f);
//glVertex2f(1.0f, 1.0f);
//glTexCoord2f(0.0f, 1.0f);
//glVertex2f(0.0f, 1.0f);
//glEnd();
//glDisable(GL_TEXTURE_2D);
if (ps.renderMode == 2) {
int i;
glColor3f(0.3f, 0.8f, 1.0f);
glEnable(GL_BLEND);
glEnable(GL_LINE_SMOOTH);
glLineWidth(1.5f);
glBegin(GL_LINES);
for (i = 0; i < ps.nLine0; i++) {
glVertex2fv(&ps.line0[i].x);
glVertex2fv(&ps.line1[i].x);
}
glEnd();
glColor3f(1.0f, 0.8f, 0.3f);
glBegin(GL_LINES);
for (i = 0; i < ps.nLine1; i++) {
glVertex2fv(&ps.line2[i].x);
glVertex2fv(&ps.line3[i].x);
}
glEnd();
glLineWidth(1.0f);
glDisable(GL_LINE_SMOOTH);
glDisable(GL_BLEND);
}
//
if (ps.renderMode == 1) {
//int i;
//glColor3f(0.3f, 0.8f, 1.0f);
//glEnable(GL_BLEND);
//glEnable(GL_POINT_SMOOTH);
//glPointSize(5.0f);
//glBegin(GL_POINTS);
//for (i = 0; i < ps.pNum; i++)
// glVertex2fv(&ps.p[i].pos.x);
//glEnd();
//glPointSize(1.0f);
//glDisable(GL_POINT_SMOOTH);
////draw contour
//glLineWidth(1.5f);
//glBegin(GL_LINES);
//for (i = 0; i < ps.nLine; i++) {
// glVertex2fv(&ps.line0[i].x);
// glVertex2fv(&ps.line1[i].x);
//}
//glEnd();
//glLineWidth(1.0f);
//glDisable(GL_LINE_SMOOTH);
//glDisable(GL_BLEND);
//glEnable(GL_TEXTURE_2D);
glUseProgram(programObject);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, waterTex);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, RENDER_SAMPLE, RENDER_SAMPLE, GL_RGBA, GL_FLOAT, ps.textureWater);
waterLoc = glGetUniformLocation(programObject, "tex_water");
if(waterLoc >= 0)
glUniform1i(waterLoc, 0);
else
printf("Uniform variable tex_water not found!\n");
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, iceTex);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, RENDER_SAMPLE, RENDER_SAMPLE, GL_RGBA, GL_FLOAT, ps.textureIce);
iceLoc = glGetUniformLocation(programObject, "tex_ice");
if(iceLoc >= 0)
glUniform1i(iceLoc, 1);
else
printf("Uniform variable tex_ice not found!\n");
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
glVertex2f(0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f);
glVertex2f(1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f);
glVertex2f(1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f);
glVertex2f(0.0f, 1.0f);
glEnd();
//glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
glUseProgram(0);
/*glBindTexture(GL_TEXTURE_2D, iceTex);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, RENDER_SAMPLE, RENDER_SAMPLE, GL_RGBA, GL_FLOAT, ps.textureIce);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
glVertex2f(0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f);
glVertex2f(1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f);
glVertex2f(1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f);
glVertex2f(0.0f, 1.0f);
glEnd();
glDisable(GL_TEXTURE_2D);*/
//glColor3f(0.3f, 0.8f, 1.0f);
glEnable(GL_BLEND);
glEnable(GL_POINT_SMOOTH);
glPointSize(10.0f);
//glBegin(GL_POINTS);
int i;
for (i = 0; i < ps.pNum; i++)
{
//
if(ps.p[i].phase == bubble)
{
//glPointSize(10.0f * ps.p[i].volume);
glColor3f(1.0f, 1.0f, 1.0f);
DrawCircle(ps.p[i].pos.x, ps.p[i].pos.y, 0.005 * ps.p[i].volume, 10);
//glVertex2fv(&ps.p[i].pos.x);
}
}
//glEnd();
glPointSize(1.0f);
glDisable(GL_POINT_SMOOTH);
glDisable(GL_BLEND);
}
}
if (systemRunning) {
//if (frameNum % 10 == 0)
//screenShot(frameNum / 10);
frameNum++;
}
renderText();
glutSwapBuffers();
}
void TextureLitMaterial::render(GameObject* pGameObject, Camera* pCamera) {
if (!_diffuseTexture) return;
_shader->use();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, _diffuseTexture->getId());
glUniform1i (_diffMapLoc, 0);
glUniform1f(_diffuseTilingLoc, _diffuseTiling);
if (normalMap) {
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, _normalMapTexture->getId());
glUniform1i (_normalMapLoc, 1);
glUniform1f(_normalTilingLoc, _normalTiling);
}
if (specularMap) {
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, _specularMapTexture->getId());
glUniform1i (_specMapLoc, 2);
glUniform1f(_specularTilingLoc, _specularTiling);
}
if (Renderer::getShadowDepthMapFar()) {
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, Renderer::getShadowDepthMapFar());
glUniform1i (_depthMapLocFar, 3);
}
if (Renderer::getShadowDepthMapFar()) {
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, Renderer::getShadowDepthMapNear());
glUniform1i (_depthMapLocNear, 4);
}
if (Renderer::getShadowDepthMapMid()) {
glActiveTexture(GL_TEXTURE5);
glBindTexture(GL_TEXTURE_2D, Renderer::getShadowDepthMapMid());
glUniform1i (_depthMapLocMid, 5);
}
glUniform1f(_matSmoothLoc, _smoothness);
glUniform1f(_matShineLoc, _shininess);
glUniform1f(_matAmbLoc, _ambient);
glUniform1f(_hasNormMapLoc, normalMap);
glUniform1f(_hasSpecMapLoc, specularMap);
//pass in light data
int index = 0;
DualLinkList<Light> list = Light::GetLightList();
DualLinkNode<Light>* cn = list.startNode;
//GLfloat near_plane = 1.0f, far_plane = 25.0f;
while(cn!=NULL && index < MGE_MAX_LIGHTS)
{
Light* light = (Light*)cn;
if(!light->IsActive())//do not render with inactive lights
{
cn = cn->nextNode;
continue;
}
string indexString ="LightArray[" + std::to_string(index) + "]";
GLuint loc;
int lightType = light->getType();
if (lightType == MGE_LIGHT_DIRECTIONAL)
{
loc = _shader->getUniformLocation(indexString + ".type");
glUniform1i(loc,lightType);
loc = _shader->getUniformLocation(indexString + ".color");
glUniform3fv(loc,1,glm::value_ptr(light->getColor()));
loc = _shader->getUniformLocation(indexString + ".direction");
glUniform3fv(loc,1,glm::value_ptr(light->getDirection()));
//loc = _shader->getUniformLocation(indexString + ".position");
//glUniform3fv(loc,1,glm::value_ptr(light->getLocalPosition()));
glm::mat4 lightProjection, lightView;
lightView = Light::GetDirectionalViewMatrix();
glm::mat4 lightSpaceMatrix;
lightProjection = Renderer::GetFarShadowOrtho();
lightSpaceMatrix = lightProjection * lightView;
glUniformMatrix4fv(_lightMatLocFar, 1, GL_FALSE, glm::value_ptr(lightSpaceMatrix));
lightProjection = Renderer::GetNearShadowOrtho();
lightSpaceMatrix = lightProjection * lightView;
glUniformMatrix4fv(_lightMatLocNear, 1, GL_FALSE, glm::value_ptr(lightSpaceMatrix));
lightProjection = Renderer::GetMidShadowOrtho();
lightSpaceMatrix = lightProjection * lightView;
glUniformMatrix4fv(_lightMatLocMid, 1, GL_FALSE, glm::value_ptr(lightSpaceMatrix));
++index;
}
else
if ((!pGameObject->ignoreNonDirLights) && lightType == MGE_LIGHT_POINT)
{
glm::vec3 lightPos = light->getWorldPosition();
float dist = glm::distance(lightPos, pGameObject->getWorldPosition());
if(dist > light->getFalloff() + pGameObject->GetRenderBound().radius)
{
cn = cn->nextNode;
continue;
}
loc = _shader->getUniformLocation(indexString + ".type");
glUniform1i(loc,lightType);
loc = _shader->getUniformLocation(indexString + ".color");
glUniform3fv(loc,1,glm::value_ptr(light->getColor()));
loc = _shader->getUniformLocation(indexString + ".position");
glUniform3fv(loc,1,glm::value_ptr(lightPos));
loc = _shader->getUniformLocation(indexString + ".attenuation");
glUniform3fv(loc,1,glm::value_ptr(light->getAttenuation()));
++index;
}
//++index;
cn = cn->nextNode;
}
glUniform1i(_shader->getUniformLocation("lightCount"),index);
//set view pos
glUniform3fv(_viewPosLoc, 1, glm::value_ptr(pCamera->getWorldPosition()));
//color
glUniform4fv(_colorLoc,1,glm::value_ptr(color));
//pass in all MVP matrices separately
glUniformMatrix4fv ( _projMatLoc, 1, GL_FALSE, glm::value_ptr(pCamera->getProjection()));
glUniformMatrix4fv ( _viewMatLoc, 1, GL_FALSE, glm::value_ptr(pCamera->getView()));
glUniformMatrix4fv ( _modelMatLoc, 1, GL_FALSE, glm::value_ptr(pGameObject->getWorldTransform()));
//now inform mesh of where to stream its data
pGameObject->getMesh()->streamToOpenGL(0, 1, 2, 3);
//glGetError();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
}
void Uniform1i::apply()
{
glUniform1i(location(), m_val);
}
void Uniform::set1i(GLint value)
{
glUniform1i(location, value);
}
static bool gl_glsl_compile_program(
void *data,
unsigned idx,
void *program_data,
struct shader_program_info *program_info)
{
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
struct shader_program_glsl_data *program = (struct shader_program_glsl_data*)program_data;
GLuint prog = glCreateProgram();
if (!program)
program = &glsl->prg[idx];
if (!prog)
goto error;
if (program_info->vertex)
{
RARCH_LOG("Found GLSL vertex shader.\n");
program->vprg = glCreateShader(GL_VERTEX_SHADER);
if (!gl_glsl_compile_shader(
glsl,
program->vprg,
"#define VERTEX\n#define PARAMETER_UNIFORM\n", program_info->vertex))
{
RARCH_ERR("Failed to compile vertex shader #%u\n", idx);
goto error;
}
glAttachShader(prog, program->vprg);
}
if (program_info->fragment)
{
RARCH_LOG("Found GLSL fragment shader.\n");
program->fprg = glCreateShader(GL_FRAGMENT_SHADER);
if (!gl_glsl_compile_shader(glsl, program->fprg,
"#define FRAGMENT\n#define PARAMETER_UNIFORM\n", program_info->fragment))
{
RARCH_ERR("Failed to compile fragment shader #%u\n", idx);
goto error;
}
glAttachShader(prog, program->fprg);
}
if (program_info->vertex || program_info->fragment)
{
RARCH_LOG("Linking GLSL program.\n");
if (!gl_glsl_link_program(prog))
goto error;
/* Clean up dead memory. We're not going to relink the program.
* Detaching first seems to kill some mobile drivers
* (according to the intertubes anyways). */
if (program->vprg)
glDeleteShader(program->vprg);
if (program->fprg)
glDeleteShader(program->fprg);
program->vprg = 0;
program->fprg = 0;
glUseProgram(prog);
glUniform1i(gl_glsl_get_uniform(glsl, prog, "Texture"), 0);
glUseProgram(0);
}
program->id = prog;
return true;
error:
RARCH_ERR("Failed to link program #%u.\n", idx);
program->id = 0;
return false;
}
// OpenGL3 Render function.
// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop)
// Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly, in order to be able to run within any OpenGL engine that doesn't do so.
void ImGui_ImplGlfwGL3_RenderDrawData(ImDrawData* draw_data)
{
// Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
ImGuiIO& io = ImGui::GetIO();
int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x);
int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y);
if (fb_width == 0 || fb_height == 0)
return;
draw_data->ScaleClipRects(io.DisplayFramebufferScale);
// Backup GL state
GLenum last_active_texture; glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint*)&last_active_texture);
glActiveTexture(GL_TEXTURE0);
GLint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
GLint last_sampler; glGetIntegerv(GL_SAMPLER_BINDING, &last_sampler);
GLint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
GLint last_vertex_array; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
GLint last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode);
GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box);
GLenum last_blend_src_rgb; glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*)&last_blend_src_rgb);
GLenum last_blend_dst_rgb; glGetIntegerv(GL_BLEND_DST_RGB, (GLint*)&last_blend_dst_rgb);
GLenum last_blend_src_alpha; glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*)&last_blend_src_alpha);
GLenum last_blend_dst_alpha; glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*)&last_blend_dst_alpha);
GLenum last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*)&last_blend_equation_rgb);
GLenum last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*)&last_blend_equation_alpha);
GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, polygon fill
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Setup viewport, orthographic projection matrix
glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height);
const float ortho_projection[4][4] =
{
{ 2.0f/io.DisplaySize.x, 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f/-io.DisplaySize.y, 0.0f, 0.0f },
{ 0.0f, 0.0f, -1.0f, 0.0f },
{-1.0f, 1.0f, 0.0f, 1.0f },
};
glUseProgram(g_ShaderHandle);
glUniform1i(g_AttribLocationTex, 0);
glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
glBindSampler(0, 0); // Rely on combined texture/sampler state.
// Recreate the VAO every time
// (This is to easily allow multiple GL contexts. VAO are not shared among GL contexts, and we don't track creation/deletion of windows so we don't have an obvious key to use to cache them.)
GLuint vao_handle = 0;
glGenVertexArrays(1, &vao_handle);
glBindVertexArray(vao_handle);
glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
glEnableVertexAttribArray(g_AttribLocationPosition);
glEnableVertexAttribArray(g_AttribLocationUV);
glEnableVertexAttribArray(g_AttribLocationColor);
glVertexAttribPointer(g_AttribLocationPosition, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, pos));
glVertexAttribPointer(g_AttribLocationUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, uv));
glVertexAttribPointer(g_AttribLocationColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, col));
// Draw
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
const ImDrawIdx* idx_buffer_offset = 0;
glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.Size * sizeof(ImDrawVert), (const GLvoid*)cmd_list->VtxBuffer.Data, GL_STREAM_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx), (const GLvoid*)cmd_list->IdxBuffer.Data, GL_STREAM_DRAW);
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
if (pcmd->UserCallback)
{
pcmd->UserCallback(cmd_list, pcmd);
}
else
{
glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset);
}
idx_buffer_offset += pcmd->ElemCount;
}
}
glDeleteVertexArrays(1, &vao_handle);
// Restore modified GL state
glUseProgram(last_program);
glBindTexture(GL_TEXTURE_2D, last_texture);
glBindSampler(0, last_sampler);
glActiveTexture(last_active_texture);
glBindVertexArray(last_vertex_array);
glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer);
glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
glBlendFuncSeparate(last_blend_src_rgb, last_blend_dst_rgb, last_blend_src_alpha, last_blend_dst_alpha);
if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND);
if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE);
if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
glPolygonMode(GL_FRONT_AND_BACK, (GLenum)last_polygon_mode[0]);
glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]);
}
GLvoid Program::setUniform(GLint location, GLint v0) { glUniform1i (location, v0); }
void SSEffect::smoothDepth( RTPSSettings* settings)
{
GLuint smoothingProgram;
switch(settings->GetSettingAs<int>("filter_type","0"))
{
case NO_SMOOTHING:
return;
case SEPERABLE_GAUSSIAN_BLUR:
smoothingProgram= m_shaderLibrary->shaders["gaussianBlurXShader"].getProgram();
glUseProgram(smoothingProgram);
glUniform1i( glGetUniformLocation(smoothingProgram, "depthTex"),0);
glUniform1f( glGetUniformLocation(smoothingProgram, "del_x"),1.0f/(float)width);
glUniform1f( glGetUniformLocation(smoothingProgram, "falloff"),settings->GetSettingAs<float>("blur_falloff","1.0"));
glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0"));
RenderUtils::fullscreenQuad();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth"],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth2"]);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
smoothingProgram= m_shaderLibrary->shaders["gaussianBlurYShader"].getProgram();
glUseProgram(smoothingProgram);
glUniform1i( glGetUniformLocation(smoothingProgram, "depthTex"),0);
glUniform1f( glGetUniformLocation(smoothingProgram, "del_y"),1.0f/(float)height);
glUniform1f( glGetUniformLocation(smoothingProgram, "falloff"),settings->GetSettingAs<float>("blur_falloff","1.0"));
glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0"));
currentDepthBuffer="depth2";
break;
case GAUSSIAN_BLUR:
smoothingProgram= m_shaderLibrary->shaders["gaussianBlurShader"].getProgram();
glUseProgram(smoothingProgram);
glUniform1i(glGetUniformLocation(smoothingProgram,"depthTex"),0);
glUniform1f( glGetUniformLocation(smoothingProgram, "del_x"),1.0/((float)width));
glUniform1f( glGetUniformLocation(smoothingProgram, "del_y"),1.0/((float)height));
glUniform1f( glGetUniformLocation(smoothingProgram, "falloff"),settings->GetSettingAs<float>("blur_falloff","1.0"));
glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0"));
currentDepthBuffer="depth";
break;
case BILATERAL_GAUSSIAN_BLUR:
{
smoothingProgram= m_shaderLibrary->shaders["bilateralGaussianBlurShader"].getProgram();
float xdir[] = {1.0f/height,0.0f};
float ydir[] = {0.0f,1.0f/width};
glUseProgram(smoothingProgram);
glUniform1i( glGetUniformLocation(smoothingProgram, "depthTex"),0);
glUniform2fv( glGetUniformLocation(smoothingProgram, "blurDir"),1,xdir);
glUniform1f( glGetUniformLocation(smoothingProgram, "sig_range"),settings->GetSettingAs<float>("bilateral_range","0.01"));
glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0"));
RenderUtils::fullscreenQuad();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth"],0);
//glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth2"]);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glUniform2fv( glGetUniformLocation(smoothingProgram, "blurDir"),1,ydir);
//glUniform1f( glGetUniformLocation(smoothingProgram, "sig_range"),bilateralRange);
//glUniform1f( glGetUniformLocation(glsl_program[BILATERAL_GAUSSIAN_SHADER], "sig"),filterRadius);
currentDepthBuffer="depth2";
break;
}
case CURVATURE_FLOW:
{
//int numberIterations=settings->GetSettingAs<int>("curvature_flow_iterations","20");
smoothingProgram= m_shaderLibrary->shaders["curvatureFlowShader"].getProgram();
glUseProgram(smoothingProgram);
int numberIterations=settings->GetSettingAs<int>("curvature_flow_iterations","1");
glUniform1i(glGetUniformLocation(smoothingProgram,"depthTex"),0);
//glUniform1f(glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER],"width"),(float)window_width);
//glUniform1f(glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER],"height"),(float)window_height);
glUniform1f( glGetUniformLocation(smoothingProgram, "del_x"),1.0/((float)width));
glUniform1f( glGetUniformLocation(smoothingProgram, "del_y"),1.0/((float)height));
//glUniform1f( glGetUniformLocation(smoothingProgram, "h_x"),1.0/((float)width-1));
//glUniform1f( glGetUniformLocation(smoothingProgram, "h_y"),1.0/((float)height-1));
//glUniform1f( glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER], "focal_x"),focal_x);
//glUniform1f( glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER], "focal_y"),focal_y);
//glUniform1f( glGetUniformLocation(smoothingProgram, "dt"),1.0f/numberIterations);
glUniform1f( glGetUniformLocation(smoothingProgram, "dt"),settings->GetSettingAs<float>("curvature_flow_dt","0.005"));
//glUniform1f( glGetUniformLocation(smoothingProgram, "distance_threshold"), falloff);
string curReadBuffer;
for(unsigned int i = 0; i<numberIterations; i++)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
RenderUtils::fullscreenQuad();
if(i%2==0)
{
curReadBuffer = "depth2";
currentDepthBuffer="depth";
}
else
{
curReadBuffer = "depth";
currentDepthBuffer="depth2";
}
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[curReadBuffer]);
//glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0);
}
//currentDepthBuffer=curReadBuffer;
glUseProgram(0);
return;
}
default:
break;
}
RenderUtils::fullscreenQuad();
glUseProgram(0);
}
void TMD5Renderer::Render()
{
glUseProgram(shaderProgram);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
assert( glGetError() ==GL_NO_ERROR );
diffuseLocation = glGetUniformLocation(shaderProgram, "diffuse");
assert( glGetError() ==GL_NO_ERROR );
glUniform1i(diffuseLocation, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, normalTexture);
assert( glGetError() ==GL_NO_ERROR );
int normalMapLocation = glGetUniformLocation(shaderProgram, "normalMap");
assert( glGetError() ==GL_NO_ERROR );
glUniform1i(normalMapLocation, 1);
//glActiveTexture(GL_TEXTURE0);
glBindAttribLocation(shaderProgram, 0, "vertex");
glBindAttribLocation(shaderProgram, 1, "uv");
assert( glGetError() ==GL_NO_ERROR );
#ifdef GL_ES_VERSION_2_0
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertices);
assert( glGetError() == GL_NO_ERROR);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, uvs);
assert( glGetError() == GL_NO_ERROR);
glDrawArrays (GL_TRIANGLES, 0, vertexCount);
assert( glGetError() == GL_NO_ERROR);
#else
bonesLocation = glGetUniformLocation(shaderProgram, "bones");
assert( bonesLocation!=-1);
assert( glGetError() ==GL_NO_ERROR );
int count = md5Model->GetJointCount();
float matrices[count * 16];
memset(matrices, 0, sizeof(float)*count*16);
float* ptr = matrices;
for(int j=0;j<count;++j)
{
TMD5Joint* joint = md5Model->GetJoint(j);
Matrix4 transform = joint->transform * joint->inverseBindPose;
*ptr ++ = transform.m[0][0];
*ptr ++ = transform.m[1][0];
*ptr ++ = transform.m[2][0];
*ptr ++ = transform.m[3][0];
*ptr ++ = transform.m[0][1];
*ptr ++ = transform.m[1][1];
*ptr ++ = transform.m[2][1];
*ptr ++ = transform.m[3][1];
*ptr ++ = transform.m[0][2];
*ptr ++ = transform.m[1][2];
*ptr ++ = transform.m[2][2];
*ptr ++ = transform.m[3][2];
*ptr ++ = transform.m[0][3];
*ptr ++ = transform.m[1][3];
*ptr ++ = transform.m[2][3];
*ptr ++ = transform.m[3][3];
}
//glUniform1i(boneCountLocation, count);
assert( glGetError() == GL_NO_ERROR );
glUniformMatrix4fv(bonesLocation, count, GL_FALSE, matrices);
assert( glGetError() == GL_NO_ERROR );
for(int m=0;m<md5Model->meshes.size();++m)
{
if( md5Model->meshes[m]->IsVisible() )
{
TMD5Mesh* mesh = md5Model->meshes[m];
glBindVertexArray(vertexArrayObject[m]);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glEnableVertexAttribArray(3);
glEnableVertexAttribArray(4);
glEnableVertexAttribArray(5);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexVBO[m]);
int indexCount = 3 * (int)mesh->mTriangles.size();
// Draw the triangles !
glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, (void*)0);
assert( glGetError() == GL_NO_ERROR);
}
}
#endif
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(3);
glDisableVertexAttribArray(4);
glDisableVertexAttribArray(5);
glUseProgram(0);
glBindVertexArray(0);
}
void TextureShader::render(RenderState* rstate,
RenderData* render_data, Material* material) {
Mesh* mesh = render_data->mesh();
Texture* texture = material->getTexture("main_texture");
glm::vec3 color = material->getVec3("color");
float opacity = material->getFloat("opacity");
glm::vec4 material_ambient_color = material->getVec4("ambient_color");
glm::vec4 material_diffuse_color = material->getVec4("diffuse_color");
glm::vec4 material_specular_color = material->getVec4("specular_color");
float material_specular_exponent = material->getFloat("specular_exponent");
if (texture->getTarget() != GL_TEXTURE_2D) {
std::string error = "TextureShader::render : texture with wrong target.";
throw error;
}
bool use_light = false;
Light* light;
if (render_data->light_enabled()) {
light = render_data->light();
if (light->enabled()) {
use_light = true;
}
}
mesh->generateVAO();
if (use_light) {
GL(glUseProgram(program_light_->id()));
} else {
GL(glUseProgram(program_no_light_->id()));
}
GL(glActiveTexture (GL_TEXTURE0));
GL(glBindTexture(texture->getTarget(), texture->getId()));
if (use_light) {
glm::vec3 light_position = light->getVec3("world_position");
glm::vec4 light_ambient_intensity = light->getVec4("ambient_intensity");
glm::vec4 light_diffuse_intensity = light->getVec4("diffuse_intensity");
glm::vec4 light_specular_intensity = light->getVec4(
"specular_intensity");
glUniformMatrix4fv(u_mvp_, 1, GL_FALSE, glm::value_ptr(rstate->uniforms.u_mvp));
glUniformMatrix4fv(u_mv_, 1, GL_FALSE, glm::value_ptr(rstate->uniforms.u_mv));
glUniformMatrix4fv(u_mv_it_, 1, GL_FALSE, glm::value_ptr(rstate->uniforms.u_mv_it));
glUniform3f(u_light_pos_, light_position.x, light_position.y,
light_position.z);
glUniform1i(u_texture_, 0);
glUniform3f(u_color_, color.r, color.g, color.b);
glUniform1f(u_opacity_, opacity);
glUniform4f(u_material_ambient_color_, material_ambient_color.r,
material_ambient_color.g, material_ambient_color.b,
material_ambient_color.a);
glUniform4f(u_material_diffuse_color_, material_diffuse_color.r,
material_diffuse_color.g, material_diffuse_color.b,
material_diffuse_color.a);
glUniform4f(u_material_specular_color_, material_specular_color.r,
material_specular_color.g, material_specular_color.b,
material_specular_color.a);
glUniform1f(u_material_specular_exponent_, material_specular_exponent);
glUniform4f(u_light_ambient_intensity_, light_ambient_intensity.r,
light_ambient_intensity.g, light_ambient_intensity.b,
light_ambient_intensity.a);
glUniform4f(u_light_diffuse_intensity_, light_diffuse_intensity.r,
light_diffuse_intensity.g, light_diffuse_intensity.b,
light_diffuse_intensity.a);
glUniform4f(u_light_specular_intensity_, light_specular_intensity.r,
light_specular_intensity.g, light_specular_intensity.b,
light_specular_intensity.a);
glBindVertexArray(mesh->getVAOId());
} else {
glUniformMatrix4fv(u_mvp_no_light_, 1, GL_FALSE,
glm::value_ptr(rstate->uniforms.u_mvp));
glUniform1i(u_texture_no_light_, 0);
glUniform3f(u_color_no_light_, color.r, color.g, color.b);
glUniform1f(u_opacity_no_light_, opacity);
glBindVertexArray(mesh->getVAOId());
}
GL(glDrawElements(render_data->draw_mode(), mesh->indices().size(), GL_UNSIGNED_SHORT,
0));
GL(glBindVertexArray(0));
checkGlError("TextureShader::render");
}
int main() {
// INIT
glfwSetErrorCallback( error_callback );
/* Initialize the library */
if ( !glfwInit() ) {
return -1;
}
// must use exactly version 3
glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 3 );
glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 3 );
glfwWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
/* Create a windowed mode window and its OpenGL context */
window = glfwCreateWindow( WIDTH, HEIGHT, "Hello World", NULL, NULL );
if ( !window ) {
glfwTerminate();
return -1;
}
glfwMakeContextCurrent( window );
glfwSetKeyCallback( window, key_callback );
//glfwSetCursorPosCallback(window, cursor_position_callback);
glfwSetScrollCallback(window, scroll_callback);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
int count;
//printf( "%s\n", glfwGetVideoModes( glfwGetPrimaryMonitor(), &count ) );
glewExperimental = GL_TRUE;
if( glewInit() != GLEW_OK ) {
fprintf( stderr, "glewInit() failed\n" );
}
glViewport( 0, 0, WIDTH, HEIGHT );
glClearColor( 0.2f, 0.3f, 0.3f, 1.0f );
glEnable( GL_DEPTH_TEST );
// SHADER
Shader shader( "./vertexShader.glsl", "./fragmentShader.glsl" );
// Set up vertex data (and buffer(s)) and attribute pointers
GLfloat vertices[] = {
-1.0f, -1.0f, -1.0f, 1.0f, 0.0f,
-1.0f, -1.0f, 1.0f, 0.0f, 0.0f,
-1.0f, 1.0f, -1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
1.0f, -1.0f, -1.0f, 0.0f, 0.0f,
1.0f, -1.0f, 1.0f, 1.0f, 0.0f,
1.0f, 1.0f, -1.0f, 0.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
};
GLuint indices[] = {
0, 1, 2,
1, 2, 3,
1, 3, 5,
3, 5, 7,
4, 5, 7,
4, 6, 7,
0, 4, 6,
0, 2, 6,
2, 3, 7,
2, 6, 7,
0, 1, 5,
0, 4, 5
};
// vertex buffer object (VBO)
// vertex array object (VAO)
GLuint VAO, VBO, EBO;
glGenVertexArrays( 1, &VAO );
glGenBuffers( 1, &VBO );
glGenBuffers( 1, &EBO );
// BIND the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s).
glBindVertexArray( VAO );
glBindBuffer( GL_ARRAY_BUFFER, VBO );
glBufferData( GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, EBO );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW );
// void glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);
// the 0 for index comes from location = 0 in the vertex shader
glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0 );
glVertexAttribPointer( 1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)) );
glEnableVertexAttribArray( 0 );
glEnableVertexAttribArray( 1 );
glBindVertexArray( 0 );
stbi_set_flip_vertically_on_load(1);
// TEXTURE
GLuint texture;
glGenTextures(1, &texture);
//printf( "texture: %d\n", texture );
glBindTexture(GL_TEXTURE_2D, texture); // All upcoming GL_TEXTURE_2D operations now have effect on our texture object
// Set our texture parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture wrapping to GL_REPEAT
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// Set texture filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Load, create texture and generate mipmaps
int width, height, comp;
unsigned char* image = stbi_load("./images/container.jpg", &width, &height, &comp, 3);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
stbi_image_free(image);
glBindTexture(GL_TEXTURE_2D, 0);
GLuint texture1;
glGenTextures(1, &texture1);
//printf( "texture1: %d\n", texture1 );
glBindTexture(GL_TEXTURE_2D, texture1);
// Set our texture parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture wrapping to GL_REPEAT
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// Set texture filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Load, create texture and generate mipmaps
image = stbi_load("./images/awesomeface.png", &width, &height, &comp, 3 );
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
stbi_image_free(image);
glBindTexture(GL_TEXTURE_2D, 0);
glm::mat4 projection;
projection = glm::perspective( 45.0f, (GLfloat)WIDTH/HEIGHT, 0.1f, 100.0f );
/*
for( int y = 0; y < 4; ++y ) {
for( int x = 0; x < 4; ++x ) {
printf( "%f ", test[x][y] );
}
printf("\n");
}
*/
// Game loop
while( !glfwWindowShouldClose( window ) ) {
//for( int iter = 1; iter; --iter ) {
glfwPollEvents();
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glActiveTexture( GL_TEXTURE0 );
glBindTexture(GL_TEXTURE_2D, texture);
glUniform1i( glGetUniformLocation(shader.Program, "texture"), 0 );
glActiveTexture( GL_TEXTURE1 );
glBindTexture(GL_TEXTURE_2D, texture1);
glUniform1i( glGetUniformLocation(shader.Program, "texture1"), 1 );
glUseProgram( shader.Program );
glm::mat4 models[2];
models[0] = glm::translate( models[0], glm::vec3( 4.0f, 4.0f, -10.0f ) );
//models[1] = glm::translate( models[1], glm::vec3( -4.0f, -4.0f, -10.0f ) );
models[1] = glm::scale( models[1], glm::vec3( 50.0f, 50.0f, 50.0f ) );
updateCamera();
//glm::mat4 rotatedView = camera[1] * camera[0] * view;
printf( "rotation x %f, y %f, z %f\n", rotation.x, rotation.y, rotation.z );
glm::mat4 rotatedView;
rotatedView = glm::rotate( rotatedView, rotation.x, glm::vec3(1, 0, 0) ) ;
rotatedView = glm::rotate( rotatedView, rotation.y, glm::vec3(0, 1, 0) ) ;
rotatedView = glm::rotate( rotatedView, rotation.z, glm::vec3(0, 0, 1) ) ;
rotatedView *= view;
//view = glm::translate( view, position );
//glm::mat4 rotatedView;
//projection = glm::rotate( projection, glm::radians(cameraOrientation[1]), glm::vec3(1.0f, 0.0f, 0.0f) );
//projection = glm::rotate( projection, glm::radians(cameraOrientation[0]), glm::vec3(0.0f, 1.0f, 0.0f) );
//projection = projection * (cameraPosition / 10.0f);
glUniformMatrix4fv( glGetUniformLocation(shader.Program, "view" ), 1, GL_FALSE, glm::value_ptr(rotatedView) );
glUniformMatrix4fv( glGetUniformLocation(shader.Program, "projection" ), 1, GL_FALSE, glm::value_ptr(projection) );
for( int numBoxes = 0; numBoxes < 3; ++numBoxes ) {
glUniformMatrix4fv( glGetUniformLocation(shader.Program, "model" ), 1, GL_FALSE, glm::value_ptr(models[numBoxes]) );
glBindVertexArray( VAO );
//glDrawArrays( GL_TRIANGLES, 0, 3 );
glDrawElements( GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0 );
glBindVertexArray( 0 );
}
glfwSwapBuffers( window );
fps();
printf("\n");
}
glDeleteVertexArrays( 1, &VAO );
glDeleteBuffers( 1, &VBO );
glfwDestroyWindow( window );
glfwTerminate();
return 0;
}
void AFK_EntityDisplayQueue::draw(
AFK_ShaderProgram *shaderProgram,
AFK_Jigsaw *vapourJigsaw,
AFK_Jigsaw *edgeJigsaw,
const AFK_3DEdgeShapeBase *baseShape,
const AFK_ShapeSizes& sSizes)
{
size_t instanceCount = queue.size();
if (instanceCount == 0) return;
if (!displayTBOSamplerLocation)
{
vapourJigsawPiecePitchLocation = glGetUniformLocation(shaderProgram->program, "VapourJigsawPiecePitch");
edgeJigsawPiecePitchLocation = glGetUniformLocation(shaderProgram->program, "EdgeJigsawPiecePitch");
jigsawDensityTexSamplerLocation = glGetUniformLocation(shaderProgram->program, "JigsawDensityTex");
jigsawNormalTexSamplerLocation = glGetUniformLocation(shaderProgram->program, "JigsawNormalTex");
jigsawOverlapTexSamplerLocation = glGetUniformLocation(shaderProgram->program, "JigsawOverlapTex");
displayTBOSamplerLocation = glGetUniformLocation(shaderProgram->program, "DisplayTBO");
}
/* Jigsaw initialisation. */
Vec3<float> vapourJigsawPiecePitchSTR = vapourJigsaw->getPiecePitchSTR();
Vec2<float> edgeJigsawPiecePitchST = edgeJigsaw->getPiecePitchST();
glUniform3fv(vapourJigsawPiecePitchLocation, 1, &vapourJigsawPiecePitchSTR.v[0]);
/* Subtlety: that's a piece pitch for the big 3x2 pieces that
* correspond to each cube. However, 0-1 texture co-ordinates in
* the base shape are for each *face*, so I need to divide the
* pitch down:
*/
edgeJigsawPiecePitchST = afk_vec2<float>(
edgeJigsawPiecePitchST.v[0] / 3.0f,
edgeJigsawPiecePitchST.v[1] / 2.0f);
glUniform2fv(edgeJigsawPiecePitchLocation, 1, &edgeJigsawPiecePitchST.v[0]);
glActiveTexture(GL_TEXTURE0);
vapourJigsaw->bindTexture(0);
glUniform1i(jigsawDensityTexSamplerLocation, 0);
glActiveTexture(GL_TEXTURE1);
vapourJigsaw->bindTexture(1);
glUniform1i(jigsawNormalTexSamplerLocation, 1);
glActiveTexture(GL_TEXTURE2);
edgeJigsaw->bindTexture(0);
glUniform1i(jigsawOverlapTexSamplerLocation, 2);
/* Set up the entity display texbuf. */
glActiveTexture(GL_TEXTURE3);
if (!buf) glGenBuffers(1, &buf);
glBindBuffer(GL_TEXTURE_BUFFER, buf);
glBufferData(
GL_TEXTURE_BUFFER,
queue.size() * ENTITY_DISPLAY_UNIT_SIZE,
queue.data(),
GL_STREAM_DRAW);
glTexBuffer(
GL_TEXTURE_BUFFER,
GL_RGBA32F,
buf);
AFK_GLCHK("entity display queue texBuffer")
glUniform1i(displayTBOSamplerLocation, 3);
#if AFK_GL_DEBUG
shaderProgram->Validate();
#endif
baseShape->draw(instanceCount);
glBindTexture(GL_TEXTURE_2D, 0);
glBindTexture(GL_TEXTURE_3D, 0);
glBindTexture(GL_TEXTURE_BUFFER, 0);
}
void NTextInput::Draw(NCamera* View)
{
GenerateBuffers();
if (Texture == NULL || GetColor().w == 0)
{
return;
}
if (Shader == NULL)
{
glEnableClientState(GL_VERTEX_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER,Buffers[0]);
glVertexPointer(2,GL_FLOAT,0,NULL);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER,Buffers[1]);
glTexCoordPointer(2,GL_FLOAT,0,NULL);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (Texture != NULL)
{
glBindTexture(GL_TEXTURE_2D,Texture->GetID());
}
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&View->GetOrthoMatrix()[0][0]);
glMatrixMode(GL_MODELVIEW);
glm::mat4 MVP = View->GetViewMatrix()*GetModelMatrix();
glLoadMatrixf(&MVP[0][0]);
glColor4fv(&(GetColor()[0]));
glDrawArrays(GL_QUADS,0,Verts.size());
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
return;
}
glUseProgram(Shader->GetID());
glActiveTexture(GL_TEXTURE0);
if (Texture != NULL)
{
glBindTexture(GL_TEXTURE_2D,Texture->GetID());
}
glUniform1i(TextureLoc,0);
glm::mat4 MVP = View->GetOrthoMatrix()*View->GetViewMatrix()*GetModelMatrix();
glUniformMatrix4fv(MatrixLoc,1,GL_FALSE,&MVP[0][0]);
glUniform4fv(ColorLoc,1,&(GetColor()[0]));
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER,Buffers[0]);
glVertexAttribPointer(0,2,GL_FLOAT,GL_FALSE,0,NULL);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER,Buffers[1]);
glVertexAttribPointer(1,2,GL_FLOAT,GL_FALSE,0,NULL);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
glDrawArrays(GL_QUADS,0,Verts.size());
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glUseProgram(0);
}
void Font::DrawString(const Graphics& g, const Brush& brush, const string& s, int len, int x, int y, int w, int h, int flags){
int xx = x;
int yy = y;
int rr = x + w;
int bb = y + h;
//g.DrawRect(Pens::Blue, x, y, w, h);
if(len < 0) len = s.length();
vector<int> ws, cs;
int wi = 0, c = 0;
for (int i = 0; i<len;){
char_type cc;
int rs = READ_CHAR(&cc, s.c_str() + i, len-i);
if (rs>0)
i += rs;
else
break;
bool n = cc == L'\n' || cc == 0x0085 || cc == 0x2028 || cc == 0x2029;
//if (!n && cc != L'\r')
PutChar(cc);
int ww = n ? 0 : map[cc]->width;
if ((flags & FontFlag_NoWrap) == 0 && (n || (w >= 0 && wi + ww>w))){
if (c == 0){
ws.push_back(ww);
cs.push_back(1);
wi = 0;
c = 0;
}
else{
ws.push_back(wi);
cs.push_back(c);
wi = ww;
c = 1;
if (n){
wi = 0;
}
}
}
else {
wi += ww;
c++;
}
}
if (c > 0){
ws.push_back(wi);
cs.push_back(c);
}
int rh = cs.size()*face->size->metrics.y_ppem; // real height
// vertical alignment
switch ((flags >> 2) & 3) {
case 1:
yy += (h-rh) / 2;
break;
case 2:
yy += h-rh;
break;
}
//bool clip_not_whole = (flags & FontFlag_ClipNotWhole) != 0;
glUniform1i(Program::CurrentShader()->useTex2, 1);
int line = -1;
int row = 0;
yy -= face->size->metrics.y_ppem;
for (int i = 0; i < len; ){
if (row == 0){
line++;
xx = x;
yy += face->size->metrics.y_ppem;
switch (flags & 0x03) {
case 1:
xx += (w - ws[line]) / 2;
break;
case 2:
xx += w - ws[line];
break;
}
}
char_type cc;
int rs = READ_CHAR(&cc, s.c_str() + i, len - i);
if (rs>0)
i += rs;
else
return;
if (++row == cs[line])
row = 0;
if (cc == L'\r')
continue;
bool n = cc == L'\n' || cc == 0x0085 || cc == 0x2028 || cc == 0x2029; // new line
if (!n){
Char& c = *map[cc];
Rect& r = c.bounds;
float ss = TEXTURE_SIZE;
float L = r.Left() / ss;
float T = ((int)r.Top() % TEXTURE_SIZE) / ss;
float R = r.Right() / ss;
float B = T + c.height / ss;
float ps[] = {
L, T,
R, T,
R, B,
L, B
};
glEnableVertexAttribArray(TEXCOORD_ATTRIB_LOC);
glVertexAttribPointer(TEXCOORD_ATTRIB_LOC, 2, GL_FLOAT, GL_FALSE, 0, ps);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[r.Top() / TEXTURE_SIZE]);
glActiveTexture(GL_TEXTURE0);
g.FillRect(brush, xx + c.left, yy - c.top, c.width, c.height);
glDisableVertexAttribArray(TEXCOORD_ATTRIB_LOC);
//glUniform1i(Program::CurrentShader()->useTex2, 0);
//g.DrawRect(Pens::Green, xx + c.left, yy - c.top, c.width, c.height);
//glUniform1i(Program::CurrentShader()->useTex2, 1);
xx += c.width;
}
}
glUniform1i(Program::CurrentShader()->useTex2, 0);
}
// The MAIN function, from here we start the application and run the game loop
int main()
{
// Init GLFW
glfwInit( );
// Set all the required options for GLFW
glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 3 );
glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 3 );
glfwWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE );
glfwWindowHint( GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
// Create a GLFWwindow object that we can use for GLFW's functions
GLFWwindow *window = glfwCreateWindow( WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr );
int screenWidth, screenHeight;
glfwGetFramebufferSize( window, &screenWidth, &screenHeight );
if ( nullptr == window )
{
std::cout << "Failed to create GLFW window" << std::endl;
glfwTerminate( );
return EXIT_FAILURE;
}
glfwMakeContextCurrent( window );
// Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions
glewExperimental = GL_TRUE;
// Initialize GLEW to setup the OpenGL Function pointers
if ( GLEW_OK != glewInit( ) )
{
std::cout << "Failed to initialize GLEW" << std::endl;
return EXIT_FAILURE;
}
// Define the viewport dimensions
glViewport( 0, 0, screenWidth, screenHeight );
// Setup OpenGL options
glEnable( GL_DEPTH_TEST );
// enable alpha support
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
// Build and compile our shader program
Shader ourShader( "res/shaders/core.vs", "res/shaders/core.frag" );
// Set up vertex data (and buffer(s)) and attribute pointers
// use with Orthographic Projection
/*
GLfloat vertices[] = {
-0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 0.0f,
0.5f * 500, -0.5f * 500, -0.5f * 500, 1.0f, 0.0f,
0.5f * 500, 0.5f * 500, -0.5f * 500, 1.0f, 1.0f,
0.5f * 500, 0.5f * 500, -0.5f * 500, 1.0f, 1.0f,
-0.5f * 500, 0.5f * 500, -0.5f * 500, 0.0f, 1.0f,
-0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 0.0f,
-0.5f * 500, -0.5f * 500, 0.5f * 500, 0.0f, 0.0f,
0.5f * 500, -0.5f * 500, 0.5f * 500, 1.0f, 0.0f,
0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 1.0f,
0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 1.0f,
-0.5f * 500, 0.5f * 500, 0.5f * 500, 0.0f, 1.0f,
-0.5f * 500, -0.5f * 500, 0.5f * 500, 0.0f, 0.0f,
-0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f,
-0.5f * 500, 0.5f * 500, -0.5f * 500, 1.0f, 1.0f,
-0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f,
-0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f,
-0.5f * 500, -0.5f * 500, 0.5f * 500, 0.0f, 0.0f,
-0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f,
0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f,
0.5f * 500, 0.5f * 500, -0.5f * 500, 1.0f, 1.0f,
0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f,
0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f,
0.5f * 500, -0.5f * 500, 0.5f * 500, 0.0f, 0.0f,
0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f,
-0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f,
0.5f * 500, -0.5f * 500, -0.5f * 500, 1.0f, 1.0f,
0.5f * 500, -0.5f * 500, 0.5f * 500, 1.0f, 0.0f,
0.5f * 500, -0.5f * 500, 0.5f * 500, 1.0f, 0.0f,
-0.5f * 500, -0.5f * 500, 0.5f * 500, 0.0f, 0.0f,
-0.5f * 500, -0.5f * 500, -0.5f * 500, 0.0f, 1.0f,
-0.5f * 500, 0.5f * 500, -0.5f * 500, 0.0f, 1.0f,
0.5f * 500, 0.5f * 500, -0.5f * 500, 1.0f, 1.0f,
0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f,
0.5f * 500, 0.5f * 500, 0.5f * 500, 1.0f, 0.0f,
-0.5f * 500, 0.5f * 500, 0.5f * 500, 0.0f, 0.0f,
-0.5f * 500, 0.5f * 500, -0.5f * 500, 0.0f, 1.0f
};
*/
// use with Perspective Projection
GLfloat vertices[] = {
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, -0.5f, 1.0f, 1.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f,
0.5f, 0.5f, -0.5f, 1.0f, 1.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f
};
GLuint VBO, VAO;
glGenVertexArrays( 1, &VAO );
glGenBuffers( 1, &VBO );
glBindVertexArray(VAO);
glBindBuffer( GL_ARRAY_BUFFER, VBO );
glBufferData( GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW );
// Position attribute
glVertexAttribPointer( 0, 3, GL_FLOAT , GL_FALSE, 5 * sizeof( GLfloat ), ( GLvoid * )0 );
glEnableVertexAttribArray( 0 );
// TexCoord attribute
glVertexAttribPointer( 2, 2, GL_FLOAT, GL_FALSE, 5 * sizeof( GLfloat ), ( GLvoid * )( 3 * sizeof( GLfloat ) ) );
glEnableVertexAttribArray( 2 );
glBindVertexArray( 0 ); // Unbind VAO
// Load and create a texture
GLuint texture;
// ====================
// Texture
// ====================
glGenTextures( 1, &texture );
glBindTexture( GL_TEXTURE_2D, texture ); // All upcoming GL_TEXTURE_2D operations now have effect on our texture object
// Set our texture parameters
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); // Set texture wrapping to GL_REPEAT
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
// Set texture filtering
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
// Load, create texture and generate mipmaps
int width, height;
unsigned char *image = SOIL_load_image( "res/images/image1.jpg", &width, &height, 0, SOIL_LOAD_RGBA );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image );
glGenerateMipmap( GL_TEXTURE_2D );
SOIL_free_image_data( image );
glBindTexture( GL_TEXTURE_2D, 0 ); // Unbind texture when done, so we won't accidentily mess up our texture.
glm::mat4 projection;
projection = glm::perspective( 45.0f, ( GLfloat )screenWidth / ( GLfloat )screenHeight, 0.1f, 100.0f );
//projection = glm::ortho(0.0f, ( GLfloat )screenWidth, 0.0f, ( GLfloat )screenHeight, 0.1f, 1000.0f);
// Game loop
while ( !glfwWindowShouldClose( window ) )
{
// Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions
glfwPollEvents( );
// Render
// Clear the colorbuffer
glClearColor( 0.2f, 0.3f, 0.3f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// Bind Textures using texture units
glActiveTexture( GL_TEXTURE0 );
glBindTexture( GL_TEXTURE_2D, texture );
glUniform1i(glGetUniformLocation( ourShader.Program, "ourTexture1" ), 0 );
// Activate shader
ourShader.Use( );
// Create transformations
glm::mat4 model;
glm::mat4 view;
model = glm::rotate( model, ( GLfloat)glfwGetTime( ) * 1.0f, glm::vec3( 0.5f, 1.0f, 0.0f ) ); // use with perspective projection
//model = glm::rotate( model, 0.5f, glm::vec3( 1.0f, 0.0f, 0.0f ) ); // use to compare orthographic and perspective projection
//view = glm::translate( view, glm::vec3( screenWidth / 2, screenHeight / 2, -700.0f ) ); // use with orthographic projection
view = glm::translate( view, glm::vec3( 0.0f, 0.0f, -3.0f ) ); // use with perspective projection
// Get their uniform location
GLint modelLoc = glGetUniformLocation( ourShader.Program, "model" );
GLint viewLoc = glGetUniformLocation( ourShader.Program, "view" );
GLint projLoc = glGetUniformLocation( ourShader.Program, "projection" );
// Pass them to the shaders
glUniformMatrix4fv( modelLoc, 1, GL_FALSE, glm::value_ptr( model ) );
glUniformMatrix4fv( viewLoc, 1, GL_FALSE, glm::value_ptr( view ) );
glUniformMatrix4fv( projLoc, 1, GL_FALSE, glm::value_ptr( projection ) );
// Draw container
glBindVertexArray( VAO );
glDrawArrays( GL_TRIANGLES, 0, 36 );
glBindVertexArray( 0 );
// Swap the screen buffers
glfwSwapBuffers( window );
}
// Properly de-allocate all resources once they've outlived their purpose
glDeleteVertexArrays( 1, &VAO );
glDeleteBuffers( 1, &VBO );
// Terminate GLFW, clearing any resources allocated by GLFW.
glfwTerminate( );
return EXIT_SUCCESS;
}
GLUSboolean initBackground()
{
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLUSshape background;
glusFileLoadText("../Example15_ES/shader/Background.vert.glsl", &vertexSource);
glusFileLoadText("../Example15_ES/shader/Background.frag.glsl", &fragmentSource);
glusProgramBuildFromSource(&g_programBackground, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &fragmentSource.text);
glusFileDestroyText(&vertexSource);
glusFileDestroyText(&fragmentSource);
//
g_projectionMatrixBackgroundLocation = glGetUniformLocation(g_programBackground.program, "u_projectionMatrix");
g_modelViewMatrixBackgroundLocation = glGetUniformLocation(g_programBackground.program, "u_modelViewMatrix");
g_cubemapBackgroundLocation = glGetUniformLocation(g_programBackground.program, "u_cubemap");
g_vertexBackgroundLocation = glGetAttribLocation(g_programBackground.program, "a_vertex");
g_normalBackgroundLocation = glGetAttribLocation(g_programBackground.program, "a_normal");
//
glBindVertexArray(0);
//
glusShapeCreateSpheref(&background, (GLfloat) (GLfloat) WATER_PLANE_LENGTH / 2.0f + 0.5f, 32);
g_numberIndicesBackground = background.numberIndices;
glGenBuffers(1, &g_verticesBackgroundVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO);
glBufferData(GL_ARRAY_BUFFER, background.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) background.vertices, GL_STATIC_DRAW);
glGenBuffers(1, &g_normalsBackgroundVBO);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsBackgroundVBO);
glBufferData(GL_ARRAY_BUFFER, background.numberVertices * 3 * sizeof(GLfloat), (GLfloat*) background.normals, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &g_indicesBackgroundVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, background.numberIndices * sizeof(GLuint), (GLuint*) background.indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glusShapeDestroyf(&background);
//
glUseProgram(g_programBackground.program);
// We assume, that the parent program created the texture!
glUniform1i(g_cubemapBackgroundLocation, 0);
//
glGenVertexArrays(1, &g_vaoBackground);
glBindVertexArray(g_vaoBackground);
glBindBuffer(GL_ARRAY_BUFFER, g_verticesBackgroundVBO);
glVertexAttribPointer(g_vertexBackgroundLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_vertexBackgroundLocation);
glBindBuffer(GL_ARRAY_BUFFER, g_normalsBackgroundVBO);
glVertexAttribPointer(g_normalBackgroundLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(g_normalBackgroundLocation);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesBackgroundVBO);
return GLUS_TRUE;
}
void GlslProg::uniform( const std::string &name, int data )
{
GLint loc = getUniformLocation( name );
glUniform1i( loc, data );
}
void Shader::updateInt(const char* name, int v)
{
GLint x = findUniform(name);
if (x != -1) glUniform1i(x,v);
}
void GameWindow::SetUniform(uint32_t Uniform, int i)
{
glUniform1i(uniforms[Uniform], i);
}
// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
// If text or lines are blurry when integrating ImGui in your engine:
// - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
void ImGui_ImplGlut_RenderDrawLists(ImDrawData* draw_data)
{
// Backup GL state
GLint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
GLint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
GLint last_vertex_array; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
GLint last_blend_src; glGetIntegerv(GL_BLEND_SRC, &last_blend_src);
GLint last_blend_dst; glGetIntegerv(GL_BLEND_DST, &last_blend_dst);
GLint last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, &last_blend_equation_rgb);
GLint last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &last_blend_equation_alpha);
GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
glActiveTexture(GL_TEXTURE0);
// Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays)
ImGuiIO& io = ImGui::GetIO();
int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x);
int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y);
draw_data->ScaleClipRects(io.DisplayFramebufferScale);
// Setup viewport, orthographic projection matrix
glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height);
const float ortho_projection[4][4] =
{
{ 2.0f/io.DisplaySize.x, 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f/-io.DisplaySize.y, 0.0f, 0.0f },
{ 0.0f, 0.0f, -1.0f, 0.0f },
{-1.0f, 1.0f, 0.0f, 1.0f },
};
glUseProgram(g_ShaderHandle);
glUniform1i(g_AttribLocationTex, 0);
glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
glBindVertexArray(g_VaoHandle);
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
const ImDrawIdx* idx_buffer_offset = 0;
glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.size() * sizeof(ImDrawVert), (GLvoid*)&cmd_list->VtxBuffer.front(), GL_STREAM_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx), (GLvoid*)&cmd_list->IdxBuffer.front(), GL_STREAM_DRAW);
for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != cmd_list->CmdBuffer.end(); pcmd++)
{
if (pcmd->UserCallback)
{
pcmd->UserCallback(cmd_list, pcmd);
}
else
{
glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset);
}
idx_buffer_offset += pcmd->ElemCount;
}
}
// Restore modified GL state
glUseProgram(last_program);
glBindTexture(GL_TEXTURE_2D, last_texture);
glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer);
glBindVertexArray(last_vertex_array);
glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
glBlendFunc(last_blend_src, last_blend_dst);
if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND);
if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE);
if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
}
