void Shader::sendf(const char *name, float x, float y, float z)
{
glUniform3f(glGetUniformLocation(m_program,name), x,y,z);
}
void TestStage::onRender( float dFrame )
{
glDisable( GL_DEPTH_TEST );
glDisable( GL_CULL_FACE );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
glEnable( GL_STENCIL_TEST );
GameWindow& window = Global::getDrawEngine()->getWindow();
int w = window.getWidth();
int h = window.getHeight();
for ( LightList::iterator iter = lights.begin(), itEnd = lights.end();
iter != itEnd ; ++iter )
{
Light& light = *iter;
#if 1
glColorMask(false, false, false, false);
glStencilFunc(GL_ALWAYS, 1, 1);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
for( BlockList::iterator iter = blocks.begin(), itEnd = blocks.end();
iter != itEnd ; ++iter )
{
Block& block = *iter;
renderPolyShadow( light , block.pos , block.getVertices() , block.getVertexNum() );
}
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilFunc(GL_EQUAL, 0, 1);
glColorMask(true, true, true, true);
#endif
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glUseProgram(program);
glUniform2f( loc_lightLocation , light.pos.x , light.pos.y );
glUniform3f( loc_lightColor , light.color.x , light.color.y , light.color.z );
glUniform3f( loc_lightAttenuation , 0 , 1 / 5.0 , 0 );
glBegin( GL_QUADS );
glVertex2i( 0 , 0 );
glVertex2i( w , 0 );
glVertex2i( w , h );
glVertex2i( 0 , h );
glEnd();
glUseProgram(0);
glDisable(GL_BLEND);
glClear(GL_STENCIL_BUFFER_BIT);
}
glDisable( GL_STENCIL_TEST );
GLGraphics2D& g = ::Global::getDrawEngine()->getGLGraphics();
g.beginRender();
RenderUtility::setFont( g , FONT_S8 );
FixString< 256 > str;
Vec2i pos = Vec2i( 10 , 10 );
g.drawText( pos , str.format( "Lights Num = %u" , lights.size() ) );
g.endRender();
}
__attribute__((force_align_arg_pointer)) void RelightingEffect::display() {
GLuint normalTexInput = normalTexture;
for (int i = 0; i < preblurFilterPasses; i++) {
if (selectedPreFilter == 1) {
//HORIZONTAL
glUseProgram(preblurHShader->id());
glUniform1i(preblurHShader->uniform("imageWidth"), inputWidth);
glUniform1i(preblurHShader->uniform("sampleRadius"), preblurKernelSize);
glUniform1f(preblurHShader->uniform("distributionSigma"), preblurSigma);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, normalTexInput);
glUniform1i(preblurHShader->uniform("colourTexture"), 0);
glUniform1i(preblurHShader->uniform("flipCoords"), false);
renderQuad(intermdiateBuffer->fbo());
normalTexInput = intermdiateBuffer->texture();
//VERTICAL
glUseProgram(preblurVShader->id());
glUniform1i(preblurVShader->uniform("imageHeight"), inputHeight);
glUniform1i(preblurVShader->uniform("sampleRadius"), preblurKernelSize);
glUniform1f(preblurVShader->uniform("distributionSigma"), preblurSigma);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, normalTexInput);
glUniform1i(preblurVShader->uniform("colourTexture"), 0);
glUniform1i(preblurVShader->uniform("flipCoords"), false);
renderQuad(intermdiateBuffer->fbo());
} else if (selectedPreFilter == 2) {
//HORIZONTAL
glUseProgram(HBilateralShader->id());
glUniform1i(HBilateralShader->uniform("imageWidth"), inputWidth);
glUniform1i(HBilateralShader->uniform("sampleRadius"), preblurKernelSize);
glUniform1f(HBilateralShader->uniform("distributionSigma"), preblurSigma);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, depthTexture);
glUniform1i(HBilateralShader->uniform("depthTexture"), 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, normalTexInput);
glUniform1i(HBilateralShader->uniform("colourTexture"), 1);
glUniform1i(HBilateralShader->uniform("flipCoords"), false);
renderQuad(intermdiateBuffer->fbo());
normalTexInput = intermdiateBuffer->texture();
//VERTICAL
glUseProgram(VBilateralShader->id());
glUniform1i(VBilateralShader->uniform("imageHeight"), inputHeight);
glUniform1i(VBilateralShader->uniform("sampleRadius"), preblurKernelSize);
glUniform1f(VBilateralShader->uniform("distributionSigma"), preblurSigma);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, depthTexture);
glUniform1i(VBilateralShader->uniform("depthTexture"), 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, normalTexInput);
glUniform1i(VBilateralShader->uniform("colourTexture"), 1);
glUniform1i(VBilateralShader->uniform("flipCoords"), false);
renderQuad(intermdiateBuffer->fbo());
}
}
// bind the program (the shaders)
glUseProgram(phongShader->id());
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, depthTexture);
glUniform1i(phongShader->uniform("depthTexture"), 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, colourTexture);
glUniform1i(phongShader->uniform("colourTexture"), 1);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, normalTexInput);
glUniform1i(phongShader->uniform("normalTexture"), 2);
Eigen::Quaternionf q(lightDirection);
Eigen::AngleAxisf aa(q);
Eigen::Vector3f v = aa.axis();
glUniform3f(phongShader ->uniform("lightPosition"), v(0), v(1), v(2));
glUniform3f(phongShader ->uniform("ambientMat"), materialAmbient[0], materialAmbient[1], materialAmbient[2]);
glUniform3f(phongShader ->uniform("diffuseMat"), materialDiffuse[0], materialDiffuse[1], materialDiffuse[2]);
glUniform3f(phongShader ->uniform("specularMat"), materialSpecular[0], materialSpecular[1], materialSpecular[2]);
glUniform3f(phongShader ->uniform("ambientLight"), lightAmbient[0], lightAmbient[1], lightAmbient[2]);
glUniform3f(phongShader ->uniform("diffuseLight"), lightDiffuse[0], lightDiffuse[1], lightDiffuse[2]);
glUniform3f(phongShader ->uniform("specularLight"), lightSpecular[0], lightSpecular[1], lightSpecular[2]);
glUniform1f(phongShader ->uniform("shininess"), shininess);
glUniform1i(phongShader->uniform("flipCoords"), useKinect);
renderQuad(0);
}
void GlslProg::uniform( const std::string &name, const Color &data )
{
GLint loc = getUniformLocation( name );
glUniform3f( loc, data.r, data.g, data.b );
}
void gle::Program::setUniform(const GLchar* uniform,
gle::Color<GLfloat> const & color)
{
glUniform3f(_uniformLocations[uniform], color.r, color.g, color.b);
}
void Uniform<geom::Vector3f>::SetUnchecked(geom::Vector3f const & value) const
{
ASSERT(IsInitialized());
auto flipped = ToOpenGl(value);
GL_CALL(glUniform3f(_location, flipped.x, flipped.y, flipped.z));
}
void deferred_renderer_end() {
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
/* Render out ssao */
glBindFramebuffer(GL_FRAMEBUFFER, ssao_fbo);
glViewport(0, 0, graphics_viewport_width() / 2, graphics_viewport_height() / 2);
GLuint ssao_handle = shader_program_handle(PROGRAM_SSAO);
glUseProgram(ssao_handle);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glActiveTexture(GL_TEXTURE0 + 0 );
glBindTexture(GL_TEXTURE_2D, depth_texture);
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(ssao_handle, "depth_texture"), 0);
glActiveTexture(GL_TEXTURE0 + 1 );
glBindTexture(GL_TEXTURE_2D, texture_handle(RANDOM));
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(ssao_handle, "random_texture"), 1);
float seed = CAMERA->position.x + CAMERA->position.y + CAMERA->position.z;
glUniform1f(glGetUniformLocation(ssao_handle, "seed"), seed);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0, -1.0, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0, -1.0, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0, 1.0, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0, 1.0, 0.0f);
glEnd();
glActiveTexture(GL_TEXTURE0 + 1 );
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0 + 0 );
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
/* End */
/* Render full screen quad to hdr fbo */
glBindFramebuffer(GL_FRAMEBUFFER, hdr_fbo);
glViewport(0, 0, graphics_viewport_width(), graphics_viewport_height());
GLuint screen_handle = shader_program_handle(PROGRAM_COMPOSE);
glUseProgram(screen_handle);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glActiveTexture(GL_TEXTURE0 + 0 );
glBindTexture(GL_TEXTURE_2D, diffuse_texture);
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(screen_handle, "diffuse_texture"), 0);
glActiveTexture(GL_TEXTURE0 + 1 );
glBindTexture(GL_TEXTURE_2D, positions_texture);
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(screen_handle, "positions_texture"), 1);
glActiveTexture(GL_TEXTURE0 + 2 );
glBindTexture(GL_TEXTURE_2D, normals_texture);
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(screen_handle, "normals_texture"), 2);
glActiveTexture(GL_TEXTURE0 + 3 );
glBindTexture(GL_TEXTURE_2D, depth_texture);
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(screen_handle, "depth_texture"), 3);
glActiveTexture(GL_TEXTURE0 + 4 );
glBindTexture(GL_TEXTURE_2D, texture_handle(SHADOW_TEX));
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(screen_handle, "shadows_texture"), 4);
glActiveTexture(GL_TEXTURE0 + 5 );
glBindTexture(GL_TEXTURE_2D, ssao_texture);
glEnable(GL_TEXTURE_2D);
glGenerateMipmap(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(screen_handle, "ssao_texture"), 5);
glActiveTexture(GL_TEXTURE0 + 6 );
glBindTexture(GL_TEXTURE_2D, texture_handle(ENVIRONMENT));
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(screen_handle, "env_texture"), 6);
GLint cam_position = glGetUniformLocation(screen_handle, "camera_position");
glUniform3f(cam_position, CAMERA->position.x, CAMERA->position.y, CAMERA->position.z);
GLint lproj_matrix_u = glGetUniformLocation(screen_handle, "light_proj");
glUniformMatrix4fv(lproj_matrix_u, 1, 0, LIGHT_PROJ_MATRIX);
GLint lview_matrix_u = glGetUniformLocation(screen_handle, "light_view");
glUniformMatrix4fv(lview_matrix_u, 1, 0, LIGHT_VIEW_MATRIX);
for(int i = 0; i < num_lights; i++) {
light_power[i] = lights[i]->power;
light_falloff[i] = lights[i]->falloff;
light_position[i] = lights[i]->position;
light_target[i] = lights[i]->target;
light_diffuse[i] = lights[i]->diffuse_color;
light_ambient[i] = lights[i]->ambient_color;
light_specular[i] = lights[i]->specular_color;
}
glUniform1i(glGetUniformLocation(screen_handle, "num_lights"), num_lights);
GLint light_power_u = glGetUniformLocation(screen_handle, "light_power");
GLint light_falloff_u = glGetUniformLocation(screen_handle, "light_falloff");
GLint light_position_u = glGetUniformLocation(screen_handle, "light_position");
GLint light_target_u = glGetUniformLocation(screen_handle, "light_target");
GLint light_diffuse_u = glGetUniformLocation(screen_handle, "light_diffuse");
GLint light_ambient_u = glGetUniformLocation(screen_handle, "light_ambient");
GLint light_specular_u = glGetUniformLocation(screen_handle, "light_specular");
glUniform1fv(light_power_u, num_lights, (const GLfloat*)light_power);
glUniform1fv(light_falloff_u, num_lights, (const GLfloat*)light_falloff);
glUniform3fv(light_position_u, num_lights, (const GLfloat*)light_position);
glUniform3fv(light_target_u, num_lights, (const GLfloat*)light_target);
glUniform3fv(light_diffuse_u, num_lights, (const GLfloat*)light_diffuse);
glUniform3fv(light_ambient_u, num_lights, (const GLfloat*)light_ambient);
glUniform3fv(light_specular_u, num_lights, (const GLfloat*)light_specular);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0, -1.0, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0, -1.0, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0, 1.0, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0, 1.0, 0.0f);
glEnd();
glActiveTexture(GL_TEXTURE0 + 6 );
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0 + 5 );
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0 + 4 );
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0 + 3 );
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0 + 2 );
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0 + 1 );
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0 + 0 );
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glUseProgram(0);
/* Render HDR to LDR buffer */
glBindFramebuffer(GL_FRAMEBUFFER, ldr_fbo);
GLuint screen_tonemap_handle = shader_program_handle(PROGRAM_TONEMAP);
glUseProgram(screen_tonemap_handle);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glActiveTexture(GL_TEXTURE0 + 0 );
glBindTexture(GL_TEXTURE_2D, hdr_texture);
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(screen_tonemap_handle, "hdr_texture"), 0);
glUniform1f(glGetUniformLocation(screen_tonemap_handle, "exposure"), EXPOSURE);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0, -1.0, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0, -1.0, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0, 1.0, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0, 1.0, 0.0f);
glEnd();
glActiveTexture(GL_TEXTURE0 + 0 );
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glUseProgram(0);
/* Generate Mipmaps, adjust exposure */
unsigned char color[4] = {0,0,0,0};
int level = -1;
int width = 0;
int height = 0;
glActiveTexture(GL_TEXTURE0 + 0 );
glBindTexture(GL_TEXTURE_2D, ldr_texture);
glEnable(GL_TEXTURE_2D);
glGenerateMipmap(GL_TEXTURE_2D);
do {
level++;
glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &height);
if (level > 50) { error("Unable to find lowest mip level. Perhaps mipmaps were not generated"); }
} while ((width > 1) || (height > 1));
glGetTexImage(GL_TEXTURE_2D, level, GL_RGBA, GL_UNSIGNED_BYTE, color);
glActiveTexture(GL_TEXTURE0 + 0 );
glDisable(GL_TEXTURE_2D);
float average = (float)(color[0] + color[1] + color[2]) / (3.0 * 255.0);
EXPOSURE += (EXPOSURE_TARGET - average) * EXPOSURE_SPEED;
/* Render final frame */
glBindFramebuffer(GL_FRAMEBUFFER, 0);
GLuint screen_post_handle = shader_program_handle(PROGRAM_POST);
glUseProgram(screen_post_handle);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glActiveTexture(GL_TEXTURE0 + 0 );
glBindTexture(GL_TEXTURE_2D, ldr_texture);
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(screen_post_handle, "diffuse_texture"), 0);
glActiveTexture(GL_TEXTURE0 + 1 );
glBindTexture(GL_TEXTURE_2D, texture_handle(VIGNETTING));
glEnable(GL_TEXTURE_2D);
glUniform1i(glGetUniformLocation(screen_post_handle, "vignetting_texture"), 1);
glActiveTexture(GL_TEXTURE0 + 2 );
glBindTexture(GL_TEXTURE_3D, texture_handle(COLOR_CORRECTION));
glEnable(GL_TEXTURE_3D);
glUniform1i(glGetUniformLocation(screen_post_handle, "lut"), 2);
glUniform1i(glGetUniformLocation(screen_post_handle, "width"), graphics_viewport_width());
glUniform1i(glGetUniformLocation(screen_post_handle, "height"), graphics_viewport_height());
glUniform1i(glGetUniformLocation(screen_post_handle, "aa_type"), 1);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0, -1.0, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0, -1.0, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0, 1.0, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0, 1.0, 0.0f);
glEnd();
glActiveTexture(GL_TEXTURE0 + 2 );
glDisable(GL_TEXTURE_3D);
glActiveTexture(GL_TEXTURE0 + 1 );
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0 + 0 );
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glUseProgram(0);
}
void Pipeline::SetUniformCameraPosition(){
Vector3f position = m_camera->GetPosition();
glUniform3f(m_CameraPositionLocation, position.x, position.y, position.z);
}
int main(int argc, char** argv)
{
if (!glfwInit()) // 初始化glfw库
{
std::cout << "Error::GLFW could not initialize GLFW!" << std::endl;
return -1;
}
// 开启OpenGL 3.3 core profile
std::cout << "Start OpenGL core profile version 3.3" << std::endl;
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);
// 创建窗口
GLFWwindow* window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT,
"Demo of directional lighting", NULL, NULL);
if (!window)
{
std::cout << "Error::GLFW could not create winddow!" << std::endl;
glfwTerminate();
return -1;
}
// 创建的窗口的context指定为当前context
glfwMakeContextCurrent(window);
// 注册窗口键盘事件回调函数
glfwSetKeyCallback(window, key_callback);
// 注册鼠标事件回调函数
glfwSetCursorPosCallback(window, mouse_move_callback);
// 注册鼠标滚轮事件回调函数
glfwSetScrollCallback(window, mouse_scroll_callback);
// 鼠标捕获 停留在程序内
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// 初始化GLEW 获取OpenGL函数
glewExperimental = GL_TRUE; // 让glew获取所有拓展函数
GLenum status = glewInit();
if (status != GLEW_OK)
{
std::cout << "Error::GLEW glew version:" << glewGetString(GLEW_VERSION)
<< " error string:" << glewGetErrorString(status) << std::endl;
glfwTerminate();
return -1;
}
// 设置视口参数
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
// Section1 准备顶点数据
// 指定顶点属性数据 顶点位置 纹理 法向量
GLfloat vertices[] = {
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f,1.0f, // A
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, // B
0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, // C
0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, // C
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, // D
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, // A
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, // E
-0.5f, 0.5f, -0.5f, 0.0, 1.0f, 0.0f, 0.0f, -1.0f, // H
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 0.0f, -1.0f, // G
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 0.0f, -1.0f, // G
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, -1.0f, // F
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, // E
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, // D
-0.5f, 0.5f, -0.5f, 1.0, 1.0f, -1.0f, 0.0f, 0.0f, // H
-0.5f, -0.5f, -0.5f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, // E
-0.5f, -0.5f, -0.5f,1.0f, 0.0f, -1.0f, 0.0f, 0.0f, // E
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, // A
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, // D
0.5f, -0.5f, -0.5f,1.0f, 0.0f, 1.0f, 0.0f, 0.0f, // F
0.5f, 0.5f, -0.5f,1.0f, 1.0f, 1.0f, 0.0f, 0.0f, // G
0.5f, 0.5f, 0.5f,0.0f, 1.0f, 1.0f, 0.0f, 0.0f, // C
0.5f, 0.5f, 0.5f,0.0f, 1.0f, 1.0f, 0.0f, 0.0f, // C
0.5f, -0.5f, 0.5f,0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // B
0.5f, -0.5f, -0.5f,1.0f, 0.0f, 1.0f, 0.0f, 0.0f, // F
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, // G
-0.5f, 0.5f, -0.5f, 0.0, 1.0f, 0.0f, 1.0f, 0.0f, // H
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, // D
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, // D
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, // C
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, // G
-0.5f, -0.5f, 0.5f,0.0f, 0.0f, 0.0f, -1.0f, 0.0f, // A
-0.5f, -0.5f, -0.5f,0.0f, 1.0f, 0.0f, -1.0f, 0.0f, // E
0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, -1.0f, 0.0f, // F
0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, -1.0f, 0.0f, // F
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, -1.0f, 0.0f, // B
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, // A
};
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 VAOId, VBOId;
// Step1: 创建并绑定VAO对象
glGenVertexArrays(1, &VAOId);
glBindVertexArray(VAOId);
// Step2: 创建并绑定VBO 对象 传送数据
glGenBuffers(1, &VBOId);
glBindBuffer(GL_ARRAY_BUFFER, VBOId);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// Step3: 指定解析方式 并启用顶点属性
// 顶点位置属性
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
8 * sizeof(GL_FLOAT), (GLvoid*)0);
glEnableVertexAttribArray(0);
// 顶点纹理坐标
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,
8 * sizeof(GL_FLOAT), (GLvoid*)(3 * sizeof(GL_FLOAT)));
glEnableVertexAttribArray(1);
// 顶点法向量属性
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE,
8 * sizeof(GL_FLOAT), (GLvoid*)(5 * sizeof(GL_FLOAT)));
glEnableVertexAttribArray(2);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
// 创建光源的VAO
GLuint lampVAOId;
glGenVertexArrays(1, &lampVAOId);
glBindVertexArray(lampVAOId);
glBindBuffer(GL_ARRAY_BUFFER, VBOId); // 重用上面的数据 无需重复发送顶点数据
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GL_FLOAT), (GLvoid*)0);
glEnableVertexAttribArray(0); // 只需要顶点位置即可
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
// Section2 准备着色器程序
Shader shader("cube.vertex", "cube.frag");
Shader lampShaer("lamp.vertex", "lamp.frag");
// Section3 准备diffuseMap和specularMap
GLint diffuseMap = TextureHelper::load2DTexture("../../resources/textures/container_diffuse.png");
GLint specularMap = TextureHelper::load2DTexture("../../resources/textures/container_specular.png");
shader.use();
glUniform1i(glGetUniformLocation(shader.programId, "material.diffuseMap"), 0);
glUniform1i(glGetUniformLocation(shader.programId, "material.specularMap"), 1);
glEnable(GL_DEPTH_TEST);
// 开始游戏主循环
while (!glfwWindowShouldClose(window))
{
GLfloat currentFrame = (GLfloat)glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
glfwPollEvents(); // 处理例如鼠标 键盘等事件
do_movement(); // 根据用户操作情况 更新相机属性
// 清除颜色缓冲区 重置为指定颜色
//glClearColor(0.18f, 0.04f, 0.14f, 1.0f);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glm::mat4 projection = glm::perspective(camera.mouse_zoom,
(GLfloat)(WINDOW_WIDTH) / WINDOW_HEIGHT, 1.0f, 100.0f); // 投影矩阵
glm::mat4 view = camera.getViewMatrix(); // 视变换矩阵
// 这里填写场景绘制代码
glBindVertexArray(VAOId);
shader.use();
// 设置光源属性
GLint lightAmbientLoc = glGetUniformLocation(shader.programId, "light.ambient");
GLint lightDiffuseLoc = glGetUniformLocation(shader.programId, "light.diffuse");
GLint lightSpecularLoc = glGetUniformLocation(shader.programId, "light.specular");
GLint lightDirLoc = glGetUniformLocation(shader.programId, "light.direction");
glUniform3f(lightAmbientLoc, 0.2f, 0.2f, 0.2f);
glUniform3f(lightDiffuseLoc, 0.5f, 0.5f, 0.5f);
glUniform3f(lightSpecularLoc, 1.0f, 1.0f, 1.0f);
glUniform3f(lightDirLoc, lampDir.x, lampDir.y, lampDir.z); // 方向光源
// 设置材料光照属性
// 启用diffuseMap
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, diffuseMap);
// 启用specularMap
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, specularMap);
GLint objectShininessLoc = glGetUniformLocation(shader.programId, "material.shininess");
glUniform1f(objectShininessLoc, 32.0f);
// 设置观察者位置
GLint viewPosLoc = glGetUniformLocation(shader.programId, "viewPos");
glUniform3f(viewPosLoc, camera.position.x, camera.position.y, camera.position.z);
// 设置变换矩阵
glUniformMatrix4fv(glGetUniformLocation(shader.programId, "projection"),
1, GL_FALSE, glm::value_ptr(projection));
glUniformMatrix4fv(glGetUniformLocation(shader.programId, "view"),
1, GL_FALSE, glm::value_ptr(view));
// 绘制多个立方体
glm::mat4 model;
for (int i = 0; i < sizeof(cubePositions) / sizeof(cubePositions[0]); ++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(glGetUniformLocation(shader.programId, "model"),
1, GL_FALSE, glm::value_ptr(model));
glDrawArrays(GL_TRIANGLES, 0, 36);
}
// 方向光源 不再需要用立方体模拟光源
// glBindVertexArray(lampVAOId);
// lampShaer.use();
// glUniformMatrix4fv(glGetUniformLocation(lampShaer.programId, "projection"),
// 1, GL_FALSE, glm::value_ptr(projection));
// glUniformMatrix4fv(glGetUniformLocation(lampShaer.programId, "view"),
// 1, GL_FALSE, glm::value_ptr(view));
// model = glm::mat4();
// model = glm::translate(model, lampPos);
// model = glm::scale(model, glm::vec3(0.2f, 0.2f, 0.2f));
// glUniformMatrix4fv(glGetUniformLocation(lampShaer.programId, "model"),
// 1, GL_FALSE, glm::value_ptr(model));
// glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
glUseProgram(0);
glfwSwapBuffers(window); // 交换缓存
}
// 释放资源
glDeleteVertexArrays(1, &VAOId);
glDeleteBuffers(1, &VBOId);
glDeleteVertexArrays(1, &lampVAOId);
glfwTerminate();
return 0;
}
int main(int argc, const char * argv[]) {
if(!glfwInit()){
return -1;
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
auto window = glfwCreateWindow(WIDTH, HEIGHT, "Mutiple lights", nullptr, nullptr);
if (nullptr == window) {
std::cout << "Failed to create GLFW windows" << std::endl;
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
int actualWidth;
int actualHeight;
glfwGetFramebufferSize(window, &actualWidth, &actualHeight);
glViewport(0, 0, actualWidth, actualHeight);
// 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);
glEnable(GL_DEPTH_TEST);
Shader lightingShader("vertex.vsh", "fragment.fsh");
Shader lampShader("vertex.vsh", "lamp.fsh");
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
};
int width, height;
unsigned char* image = SOIL_load_image("container2.png", &width, &height, 0, SOIL_LOAD_RGB);
GLuint diffuseMap;
glGenTextures(1, &diffuseMap);
glBindTexture(GL_TEXTURE_2D, diffuseMap);
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_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
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);
image = SOIL_load_image("lighting_maps_specular_color.png", &width, &height, 0, SOIL_LOAD_RGB);
GLuint specularMap;
glGenTextures(1, &specularMap);
glBindTexture(GL_TEXTURE_2D, specularMap);
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_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
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);
// image = SOIL_load_image("matrix.jpg", &width, &height, 0, SOIL_LOAD_RGB);
// GLuint emissionMap;
// glGenTextures(1, &emissionMap);
// glBindTexture(GL_TEXTURE_2D, emissionMap);
//
// 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_NEAREST);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//
// 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);
// 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)
};
glm::vec3 pointLightPositions[] = {
glm::vec3( 0.7f, 0.2f, 2.0f),
glm::vec3( 2.3f, -3.3f, -4.0f),
glm::vec3(-4.0f, 2.0f, -12.0f),
glm::vec3( 0.0f, 0.0f, -3.0f)
};
glm::vec3 pointLightColors[] = {
glm::vec3(0.4f, 0.7f, 0.1f),
glm::vec3(0.4f, 0.7f, 0.1f),
glm::vec3(0.4f, 0.7f, 0.1f),
glm::vec3(0.4f, 0.7f, 0.1f)
};
GLuint VAO;
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
GLuint VBO;
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
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);
GLuint lightVAO;
glGenVertexArrays(1, &lightVAO);
glBindVertexArray(lightVAO);
// We only need to bind to the VBO, the container's VBO's data already contains the correct data.
glBindBuffer(GL_ARRAY_BUFFER, VBO);
// Set the vertex attributes (only position data for our lamp)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
// glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
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();
// Clear the colorbuffer
glClearColor(0.9f, 0.9f, 0.9f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Use cooresponding shader when setting uniforms/drawing objects
lightingShader.Use();
GLint objectColorLoc = glGetUniformLocation(lightingShader.Program, "objectColor");
GLint lightColorLoc = glGetUniformLocation(lightingShader.Program, "lightColor");
GLint viewPosLoc = glGetUniformLocation(lightingShader.Program, "viewPos");
glUniform3f(objectColorLoc, 1.0f, 0.5f, 0.31f);
glUniform3f(lightColorLoc, 1.0f, 1.0f, 1.0f);
glUniform3f(viewPosLoc, camera.Position.x, camera.Position.y, camera.Position.z);
GLint matDiffuseLoc = glGetUniformLocation(lightingShader.Program, "material.diffuse");
glUniform1i(matDiffuseLoc, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, diffuseMap);
GLint matSpecularLoc = glGetUniformLocation(lightingShader.Program, "material.specular");
glUniform1i(matSpecularLoc, 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, specularMap);
// 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));
// Directional light
glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.direction"), -0.2f, -1.0f, -0.3f);
glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.ambient"), 0.5f, 0.5f, 0.5f);
glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.diffuse"), 1.0f, 1.0f, 1.0f);
glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.specular"), 1.0f, 1.0f, 1.0f);
// Point light 1
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].position"), pointLightPositions[0].x, pointLightPositions[0].y, pointLightPositions[0].z);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].ambient"), pointLightColors[0].x * 0.1, pointLightColors[0].y * 0.1, pointLightColors[0].z * 0.1);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].diffuse"), pointLightColors[0].x, pointLightColors[0].y, pointLightColors[0].z);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].specular"), pointLightColors[0].x, pointLightColors[0].y, pointLightColors[0].z);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[0].constant"), 1.0f);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[0].linear"), 0.07);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[0].quadratic"), 0.017);
// Point light 2
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].position"), pointLightPositions[1].x, pointLightPositions[1].y, pointLightPositions[1].z);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].ambient"), pointLightColors[1].x * 0.1, pointLightColors[1].y * 0.1, pointLightColors[1].z * 0.1);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].diffuse"), pointLightColors[1].x, pointLightColors[1].y, pointLightColors[1].z);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].specular"), pointLightColors[1].x, pointLightColors[1].y, pointLightColors[1].z);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[1].constant"), 1.0f);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[1].linear"), 0.07);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[1].quadratic"), 0.017);
// Point light 3
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].position"), pointLightPositions[2].x, pointLightPositions[2].y, pointLightPositions[2].z);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].ambient"), pointLightColors[2].x * 0.1, pointLightColors[2].y * 0.1, pointLightColors[2].z * 0.1);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].diffuse"), pointLightColors[2].x, pointLightColors[2].y, pointLightColors[2].z);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].specular") ,pointLightColors[2].x, pointLightColors[2].y, pointLightColors[2].z);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[2].constant"), 1.0f);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[2].linear"), 0.07);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[2].quadratic"), 0.017);
// Point light 4
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].position"), pointLightPositions[3].x, pointLightPositions[3].y, pointLightPositions[3].z);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].ambient"), pointLightColors[3].x * 0.1, pointLightColors[3].y * 0.1, pointLightColors[3].z * 0.1);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].diffuse"), pointLightColors[3].x, pointLightColors[3].y, pointLightColors[3].z);
glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].specular"), pointLightColors[3].x, pointLightColors[3].y, pointLightColors[3].z);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[3].constant"), 1.0f);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[3].linear"), 0.07);
glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[3].quadratic"), 0.017);
// SpotLight
glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.position"), camera.Position.x, camera.Position.y, camera.Position.z);
glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.direction"), camera.Front.x, camera.Front.y, camera.Front.z);
glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.ambient"), 0.0f, 0.0f, 0.0f);
glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.diffuse"), 0.0f, 1.0f, 0.0f);
glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.specular"), 0.0f, 1.0f, 0.0f);
glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.constant"), 1.0f);
glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.linear"), 0.07);
glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.quadratic"), 0.017);
glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.cutOff"), glm::cos(glm::radians(7.0f)));
glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.outerCutOff"), glm::cos(glm::radians(10.0f)));
// Draw the container (using container's vertex attributes)
glm::mat4 model;
glBindVertexArray(VAO);
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);
// 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));
glBindVertexArray(lightVAO);
for(GLuint i = 0; i < 4; i++)
{
model = glm::mat4();
model = glm::translate(model, pointLightPositions[i]);
GLfloat angle = 20.0f * i;
model = glm::rotate(model, angle, glm::vec3(1.0f, 0.3f, 0.5f));
model = glm::scale(model, glm::vec3(0.2,0.2,0.2));
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
// Swap the screen buffers
glfwSwapBuffers(window);
}
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glfwTerminate();
return 0;
}
int main(void) {
// initialise the windows
GLFWwindow *window;
glfwSetErrorCallback(error_callback);
if (!glfwInit()) {
return -1;
}
window = glfwCreateWindow(640, 480, "Test", NULL, NULL);
if (window == nullptr) {
std::cout << "Erreur lors du chargement de la fenetree ";
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
printf("OpenGL Version:%s\n", glGetString(GL_VERSION));
printf("GLSL Version :%s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
// create a windows
if (!window) {
fprintf(stderr, "Failed to initialize GLFW\n");
glfwTerminate();
return -1;
}
// make the window's current context
// loop until the window close
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
// GLFW Options
//glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// triangle
// must be normalized to be inside the screen
// GLEW INITIALISATION
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK)
{
std::cout << "Failed to initialize GLEW" << std::endl;
}
Shader lightingShader("shader.vs", "shader.frag");
Shader lampShader("shaderLight.vs", "shaderLight.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
};
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);
// Position attribute
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);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
glViewport(0, 0, WIDTH, HEIGHT);
glEnable(GL_DEPTH_TEST);
// 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("images/container2.png", &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("images/container2_specular.png", &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);
// Set texture units
lightingShader.Use();
glUniform1i(glGetUniformLocation(lightingShader.Program, "diffuse"), 0);
glUniform1i(glGetUniformLocation(lightingShader.Program, "specular"), 1);
glUniform1i(glGetUniformLocation(lightingShader.Program, "emission"), 2);
//generate the different positions of the box
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)
};
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 viewPosLoc = glGetUniformLocation(lightingShader.Program, "viewPos");
glUniform3f(lightPosLoc, lightPos.x, lightPos.y, lightPos.z);
glUniform3f(viewPosLoc, camera.Position.x, camera.Position.y, camera.Position.z);
// Set lights properties
glUniform3f(glGetUniformLocation(lightingShader.Program, "light.ambient"), 0.2f, 0.2f, 0.2f);
glUniform3f(glGetUniformLocation(lightingShader.Program, "light.diffuse"), 0.5f, 0.5f, 0.5f);
glUniform3f(glGetUniformLocation(lightingShader.Program, "light.specular"), 1.0f, 1.0f, 1.0f);
//set the light direction (the ray ara parallel because light source is infinitely far away
GLint lightDirPos = glGetUniformLocation(lightingShader.Program, "light.direction");
glUniform3f(lightDirPos, -0.2f, -1.0f, -0.3f);
// Set material properties
glUniform1f(glGetUniformLocation(lightingShader.Program, "material.shininess"), 64.0f);
glUniform1i(glGetUniformLocation(lightingShader.Program, "specular"), 1);
// 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);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, specularMap);
// Draw the container (using container's vertex attributes)
glBindVertexArray(containerVAO);
glm::mat4 model;
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);
}
// 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);
}
// Properly de-allocate all resources once they've outlived their purpose
glDeleteVertexArrays(1, &containerVAO);
glDeleteBuffers(1, &VBO);
// Terminate GLFW, clearing any resources allocated by GLFW.
glfwTerminate();
return 0;
}
/*******************************************************************************
Function: SetCameraPosition
Description: This function put the camera position to some location in shader.
Inputs: Matrix for calculating view space.
Outputs: None.
*******************************************************************************/
void Billboarding::SetCameraPosition(const JE::Vector3f& pos)
{
glUniform3f(m_cameraPosLocation, pos.m_x, pos.m_y, pos.m_z);
}
void GLSLProgramObject::SetUniform3f(int idx, float v0, float v1, float v2 ) { assert(IsBound()); auto it = uniformStates.find(uniformLocs[idx]); if (it != uniformStates.end() && it->second.Set(v0, v1, v2 )) glUniform3f(it->second.GetLocation(), v0, v1, v2 ); }
void GLSLProgramObject::SetUniform(UniformState* uState, float v0, float v1, float v2) { assert(IsBound()); if (uState->Set(v0, v1, v2 )) glUniform3f(uState->GetLocation(), v0, v1, v2 ); }
void LightSystem::render() {
glUniform3f(AmbientID, ambientColor.x, ambientColor.y, ambientColor.z);
if (!lightList.empty())
renderLight();
}
void setUniform (int loc, const Vec3f& v) { if (loc >= 0) glUniform3f(loc, v.x, v.y, v.z); }
void Shader::setUniform3f(const GLchar *name, const math::vec3& vector) {
glUniform3f(getUniformLocation(name), vector.x, vector.y, vector.z);
}
void LightingTechnique::SetEyeWorldPos(const Vector3f& EyeWorldPos)
{
glUniform3f(m_eyeWorldPosLocation, EyeWorldPos.x, EyeWorldPos.y, EyeWorldPos.z);
}
void M2DFx::sendUniform(const string& name, const float x, const float y,
const float z)
{
GLuint location = getUniformLocation(name);
glUniform3f(location, x, y, z);
}
void drawContainers(GLuint VAO, Shader shader, bool shadowMap, GLuint map) {
// Bind the VAO and shader.
glBindVertexArray(VAO);
glm::vec3 lightPosition = glm::vec3(-2.0f, 4.0f, -1.0f);
GLfloat near_plane = 1.0f, far_plane = 7.5f;
glm::mat4 lightProjection = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f,
near_plane, far_plane);
glm::mat4 lightView = glm::lookAt(
lightPosition,
glm::vec3(0.0f),
glm::vec3(1.0f)
);
glm::mat4 lightSpace = lightProjection * lightView;
GLuint lightSpaceMatrix = glGetUniformLocation(shader.program, "lightSpaceMatrix");
glUniformMatrix4fv(lightSpaceMatrix, 1, GL_FALSE, glm::value_ptr(lightSpace));
if (!shadowMap) {
// Pass light value.
GLuint materialDiffuse = glGetUniformLocation(shader.program, "diffuseTexture");
glUniform1i(materialDiffuse, 0);
// Pass the shadow map/depth map or whatever. Non consistent names are good.
GLuint depthMap = glGetUniformLocation(shader.program, "shadowMap");
glUniform1i(depthMap, 1);
// Bind the textures.
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, containerTexture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, map);
// Misc values.
GLuint viewPos = glGetUniformLocation(shader.program, "viewPos");
glUniform3f(viewPos, camera.position.x, camera.position.y, camera.position.z);
GLuint lightPos = glGetUniformLocation(shader.program, "lightPos");
glUniform3f(lightPos, lightPosition.x, lightPosition.y, lightPosition.z);
// Draw multiple containers!
GLuint modelMatrix = glGetUniformLocation(shader.program, "model");
GLuint normalMatrix = glGetUniformLocation(shader.program, "normalMatrix");
for (GLuint i = 0; i < 10; i++) {
// Apply world transformations.
model = glm::mat4();
model = glm::translate(model, cubePositions[i]);
model = glm::rotate(model, i * 20.0f, glm::vec3(1.0f, 0.3f, 0.5f));
glUniformMatrix4fv(modelMatrix, 1, GL_FALSE, glm::value_ptr(model));
// Calculate the normal matrix on the CPU (keep them normals perpendicular).
normal = glm::mat3(glm::transpose(glm::inverse(model)));
glUniformMatrix3fv(normalMatrix, 1, GL_FALSE, glm::value_ptr(normal));
// Draw the container.
glDrawArrays(GL_TRIANGLES, 0, 36);
}
// Draw a scaled container under the camera to act as a floor.
model = glm::mat4();
model = glm::translate(model, glm::vec3(0.0f, -1.0f, 0.0f));
model = glm::scale(model, glm::vec3(15.0f, 0.001f, 15.0f));
glUniformMatrix4fv(modelMatrix, 1, GL_FALSE, glm::value_ptr(model));
normal = glm::mat3(glm::transpose(glm::inverse(model)));
glUniformMatrix3fv(normalMatrix, 1, GL_FALSE, glm::value_ptr(normal));
glDrawArrays(GL_TRIANGLES, 0, 36);
} else {
// Draw multiple containers!
GLuint modelMatrix = glGetUniformLocation(shader.program, "model");
for (GLuint i = 0; i < 10; i++) {
// Apply world transformations.
model = glm::mat4();
model = glm::translate(model, cubePositions[i]);
model = glm::rotate(model, i * 20.0f, glm::vec3(1.0f, 0.3f, 0.5f));
glUniformMatrix4fv(modelMatrix, 1, GL_FALSE, glm::value_ptr(model));
// Draw the container.
glDrawArrays(GL_TRIANGLES, 0, 36);
}
// Draw a scaled container under the camera to act as a floor.
model = glm::mat4();
model = glm::translate(model, glm::vec3(0.0f, -1.0f, 0.0f));
model = glm::scale(model, glm::vec3(15.0f, 0.001f, 15.0f));
glUniformMatrix4fv(modelMatrix, 1, GL_FALSE, glm::value_ptr(model));
glDrawArrays(GL_TRIANGLES, 0, 36);
}
// We're done drawing containers.
glBindVertexArray(0);
}
void GlslProg::uniform( const std::string &name, const Vec3f &data )
{
GLint loc = getUniformLocation( name );
glUniform3f( loc, data.x, data.y, data.z );
}
void OGL::OGLShader::SetParameter(std::string const& valueName, const Vector3f& value)
{
glUniform3f(_pImpl->GetUniformLocation(valueName), value.x, value.y, value.z);
}
void sglUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
glUniform3f(location, v0, v1, v2);
}
void CustomPostEffectShader::render(Camera* camera,
RenderTexture* render_texture,
PostEffectData* post_effect_data,
std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& tex_coords,
std::vector<unsigned short>& triangles) {
glUseProgram(program_->id());
#if _GVRF_USE_GLES3_
GLuint tmpID;
if(vaoID_ == 0)
{
glGenVertexArrays(1, &vaoID_);
glBindVertexArray(vaoID_);
glGenBuffers(1, &tmpID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, tmpID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned short)*triangles.size(), &triangles[0], GL_STATIC_DRAW);
if (vertices.size())
{
glGenBuffers(1, &tmpID);
glBindBuffer(GL_ARRAY_BUFFER, tmpID);
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3)*vertices.size(), &vertices[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(a_position_);
glVertexAttribPointer(a_position_, 3, GL_FLOAT, 0, 0, 0);
}
if (tex_coords.size())
{
glGenBuffers(1, &tmpID);
glBindBuffer(GL_ARRAY_BUFFER, tmpID);
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec2)*tex_coords.size(), &tex_coords[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(a_tex_coord_);
glVertexAttribPointer(a_tex_coord_, 2, GL_FLOAT, 0, 0, 0);
}
}
int texture_index = 0;
if (u_texture_ != -1) {
glActiveTexture(getGLTexture(texture_index));
glBindTexture(GL_TEXTURE_2D, render_texture->getId());
glUniform1i(u_texture_, texture_index++);
}
if (u_projection_matrix_ != -1) {
glm::mat4 view = camera->getViewMatrix();
glUniformMatrix4fv(u_projection_matrix_, 1, GL_TRUE, glm::value_ptr(view));
}
if (u_right_eye_ != -1) {
bool right = camera->render_mask() & RenderData::RenderMaskBit::Right;
glUniform1i(u_right_eye_, right ? 1 : 0);
}
for (auto it = texture_keys_.begin(); it != texture_keys_.end(); ++it) {
glActiveTexture(getGLTexture(texture_index));
Texture* texture = post_effect_data->getTexture(it->second);
glBindTexture(texture->getTarget(), texture->getId());
glUniform1i(it->first, texture_index++);
}
for (auto it = float_keys_.begin(); it != float_keys_.end(); ++it) {
glUniform1f(it->first, post_effect_data->getFloat(it->second));
}
for (auto it = vec2_keys_.begin(); it != vec2_keys_.end(); ++it) {
glm::vec2 v = post_effect_data->getVec2(it->second);
glUniform2f(it->first, v.x, v.y);
}
for (auto it = vec3_keys_.begin(); it != vec3_keys_.end(); ++it) {
glm::vec3 v = post_effect_data->getVec3(it->second);
glUniform3f(it->first, v.x, v.y, v.z);
}
for (auto it = vec4_keys_.begin(); it != vec4_keys_.end(); ++it) {
glm::vec4 v = post_effect_data->getVec4(it->second);
glUniform4f(it->first, v.x, v.y, v.z, v.w);
}
for (auto it = mat4_keys_.begin(); it != mat4_keys_.end(); ++it) {
glm::mat4 m = post_effect_data->getMat4(it->second);
glUniformMatrix4fv(it->first, 1, GL_FALSE, glm::value_ptr(m));
}
glBindVertexArray(vaoID_);
glDrawElements(GL_TRIANGLES, triangles.size(), GL_UNSIGNED_SHORT, 0);
glBindVertexArray(0);
#else
if (a_position_ != -1) {
glVertexAttribPointer(a_position_, 3, GL_FLOAT, GL_FALSE, 0,
vertices.data());
glEnableVertexAttribArray(a_position_);
}
if (a_tex_coord_ != -1) {
glVertexAttribPointer(a_tex_coord_, 2, GL_FLOAT, GL_FALSE, 0,
tex_coords.data());
glEnableVertexAttribArray(a_tex_coord_);
}
int texture_index = 0;
if (u_texture_ != -1) {
glActiveTexture(getGLTexture(texture_index));
glBindTexture(GL_TEXTURE_2D, render_texture->getId());
glUniform1i(u_texture_, texture_index++);
}
if (u_projection_matrix_ != -1) {
glm::mat4 view = camera->getViewMatrix();
glUniformMatrix4fv(u_projection_matrix_, 1, GL_TRUE, glm::value_ptr(view));
}
if (u_right_eye_ != -1) {
bool right = camera->render_mask() & RenderData::RenderMaskBit::Right;
glUniform1i(u_right_eye_, right ? 1 : 0);
}
for (auto it = texture_keys_.begin(); it != texture_keys_.end(); ++it) {
glActiveTexture(getGLTexture(texture_index));
Texture* texture = post_effect_data->getTexture(it->second);
glBindTexture(texture->getTarget(), texture->getId());
glUniform1i(it->first, texture_index++);
}
for (auto it = float_keys_.begin(); it != float_keys_.end(); ++it) {
glUniform1f(it->first, post_effect_data->getFloat(it->second));
}
for (auto it = vec2_keys_.begin(); it != vec2_keys_.end(); ++it) {
glm::vec2 v = post_effect_data->getVec2(it->second);
glUniform2f(it->first, v.x, v.y);
}
for (auto it = vec3_keys_.begin(); it != vec3_keys_.end(); ++it) {
glm::vec3 v = post_effect_data->getVec3(it->second);
glUniform3f(it->first, v.x, v.y, v.z);
}
for (auto it = vec4_keys_.begin(); it != vec4_keys_.end(); ++it) {
glm::vec4 v = post_effect_data->getVec4(it->second);
glUniform4f(it->first, v.x, v.y, v.z, v.w);
}
for (auto it = mat4_keys_.begin(); it != mat4_keys_.end(); ++it) {
glm::mat4 m = post_effect_data->getMat4(it->second);
glUniformMatrix4fv(it->first, 1, GL_FALSE, glm::value_ptr(m));
}
glDrawElements(GL_TRIANGLES, triangles.size(), GL_UNSIGNED_SHORT,
triangles.data());
#endif
}
void gle::Program::setUniform(const GLchar* uniform, const gle::Vector3f& value)
{
glUniform3f(_uniformLocations[uniform], value.x, value.y, value.z);
}
void RenderInterfaceDefaultGLCore::draw2DTriangles(const VertexPTC * verts, int vertCount,
const UInt16 * indexes, int indexCount,
TextureHandle texture, int frameMaxZ)
{
NTB_ASSERT(verts != nullptr);
NTB_ASSERT(indexes != nullptr);
NTB_ASSERT(vertCount > 0);
NTB_ASSERT(indexCount > 0);
glBindBuffer(GL_ARRAY_BUFFER, vboTris2D);
glBufferData(GL_ARRAY_BUFFER, vertCount * sizeof(VertexPTC), verts, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iboTris2D);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount * sizeof(UInt16), indexes, GL_DYNAMIC_DRAW);
glEnableVertexAttribArray(0); // Position
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(VertexPTC), offsetPtr(0));
glEnableVertexAttribArray(1); // Texture coordinate
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(VertexPTC), offsetPtr(sizeof(float) * 3));
glEnableVertexAttribArray(2); // Color
glVertexAttribPointer(2, GL_BGRA, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(VertexPTC), offsetPtr(sizeof(float) * 5));
// Texture is optional.
// If not set, use a default white texture so we can share the same shader program.
glActiveTexture(GL_TEXTURE0);
if (texture != nullptr)
{
glBindTexture(GL_TEXTURE_2D, reinterpret_cast<const GLTextureRecord *>(texture)->texId);
}
else
{
if (whiteTexture == nullptr)
{
makeWhiteTexture();
NTB_ASSERT(whiteTexture != nullptr);
}
glBindTexture(GL_TEXTURE_2D, whiteTexture->texId);
}
// Set shader:
glUseProgram(shaderProgTris2D);
// Set uniform vec3 u_ScreenParams:
glUniform3f(shaderProgTris2D_ScreenParams,
static_cast<GLfloat>(glStates.viewport[2] - glStates.viewport[0]),
static_cast<GLfloat>(glStates.viewport[3] - glStates.viewport[1]),
static_cast<GLfloat>(frameMaxZ));
// Set texture to TMU 0:
glUniform1i(shaderProgTris2D_ColorTexture, 0);
// Draw call:
glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, nullptr);
if (checkGLErrors)
{
checkGLError(__FILE__, __LINE__);
}
}
void Shader::setUniform3f(const GLchar* name, float x, float y, float z)
{
glUniform3f(this->getUniformLocation(name), x, y, z);
}
void RenderInterfaceDefaultGLCore::drawClipped2DTriangles(const VertexPTC * verts, int vertCount,
const UInt16 * indexes, int indexCount,
const DrawClippedInfo * drawInfo,
int drawInfoCount, int frameMaxZ)
{
NTB_ASSERT(verts != nullptr);
NTB_ASSERT(indexes != nullptr);
NTB_ASSERT(drawInfo != nullptr);
NTB_ASSERT(vertCount > 0);
NTB_ASSERT(indexCount > 0);
NTB_ASSERT(drawInfoCount > 0);
glBindBuffer(GL_ARRAY_BUFFER, vboTris2D);
glBufferData(GL_ARRAY_BUFFER, vertCount * sizeof(VertexPTC), verts, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iboTris2D);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount * sizeof(UInt16), indexes, GL_DYNAMIC_DRAW);
glEnableVertexAttribArray(0); // Position
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(VertexPTC), offsetPtr(0));
glEnableVertexAttribArray(1); // Texture coordinate
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(VertexPTC), offsetPtr(sizeof(float) * 3));
glEnableVertexAttribArray(2); // Color
glVertexAttribPointer(2, GL_BGRA, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(VertexPTC), offsetPtr(sizeof(float) * 5));
glActiveTexture(GL_TEXTURE0);
glEnable(GL_SCISSOR_TEST);
// Set shader:
glUseProgram(shaderProgTris2D);
// Set uniform vec3 u_ScreenParams:
glUniform3f(shaderProgTris2D_ScreenParams,
static_cast<GLfloat>(glStates.viewport[2] - glStates.viewport[0]),
static_cast<GLfloat>(glStates.viewport[3] - glStates.viewport[1]),
static_cast<GLfloat>(frameMaxZ));
// Set texture to TMU 0 (if any):
glUniform1i(shaderProgTris2D_ColorTexture, 0);
GLuint currentTexId = 0;
for (int i = 0; i < drawInfoCount; ++i)
{
int viewportX = drawInfo[i].viewportX;
int viewportY = drawInfo[i].viewportY;
int viewportW = drawInfo[i].viewportW;
int viewportH = drawInfo[i].viewportH;
int clipX = drawInfo[i].clipBoxX;
int clipY = drawInfo[i].clipBoxY;
int clipW = drawInfo[i].clipBoxW;
int clipH = drawInfo[i].clipBoxH;
// Invert Y for OpenGL. In GL the origin of the
// window/framebuffer is the bottom left corner,
// and so is the origin of the viewport/scissor-box
// (that's why the `- viewportH` part is also needed).
const int framebufferH = glStates.viewport[3] - glStates.viewport[1];
viewportY = framebufferH - viewportY - viewportH;
clipY = framebufferH - clipY - clipH;
glViewport(viewportX, viewportY, viewportW, viewportH);
glScissor(clipX, clipY, clipW, clipH);
const GLTextureRecord * texGl = reinterpret_cast<const GLTextureRecord *>(drawInfo[i].texture);
if (texGl != nullptr && texGl->texId != currentTexId)
{
currentTexId = texGl->texId;
glBindTexture(GL_TEXTURE_2D, currentTexId);
}
else
{
if (whiteTexture == nullptr)
{
makeWhiteTexture();
NTB_ASSERT(whiteTexture != nullptr);
}
if (whiteTexture->texId != currentTexId)
{
currentTexId = whiteTexture->texId;
glBindTexture(GL_TEXTURE_2D, currentTexId);
}
}
// Issue the draw call:
glDrawElements(GL_TRIANGLES, drawInfo[i].indexCount, GL_UNSIGNED_SHORT,
offsetPtr(drawInfo[i].firstIndex * sizeof(UInt16)));
}
glDisable(GL_SCISSOR_TEST);
glViewport(glStates.viewport[0], glStates.viewport[1],
glStates.viewport[2], glStates.viewport[3]);
if (checkGLErrors)
{
checkGLError(__FILE__, __LINE__);
}
}
void Shader::setFloat3(const std::string &name, float v1, float v2, float v3)
{
int location = glGetUniformLocation(mProgram, name.c_str());
glUniform3f(location, v1, v2, v3);
}
int main()
{
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
//glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr);
if (window == nullptr)
{
std::cout << "Failed to create GLFW window" << std::endl;
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK)
{
std::cout << "Failed to initialize GLEW" << std::endl;
return -1;
}
glViewport(0, 0, WIDTH, HEIGHT);
glEnable(GL_DEPTH_TEST);
Shader lightingShader("./lighting.vs", "./lighting.frag");
Shader lampShader("./lamp.vs", "./lamp.frag");
// Set up vertex data (and buffer(s)) and attribute pointers
GLfloat vertices[] = {
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f
};
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, 6 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glBindVertexArray(0);
GLuint lightVAO;
glGenVertexArrays(1, &lightVAO);
glBindVertexArray(lightVAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
while(!glfwWindowShouldClose(window))
{
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
glfwPollEvents();
do_movement();
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
lightingShader.Use();
GLint objectColorLoc = glGetUniformLocation(lightingShader.Program, "objectColor");
GLint lightColorLoc = glGetUniformLocation(lightingShader.Program, "lightColor");
GLint lightLoc = glGetUniformLocation(lightingShader.Program, "lightPos");
glUniform3f(objectColorLoc, 1.0f, 0.5f, 0.31f);
glUniform3f(lightColorLoc, 1.0f, 0.5f, 1.0f);
glUniform3f(lightLoc, lightPos.x, lightPos.y, lightPos.z);
glm::mat4 view;
view = camera.GetViewMatrix();
glm::mat4 projection = glm::perspective(camera.Zoom, (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f);
GLint modelLoc = glGetUniformLocation(lightingShader.Program, "model");
GLint viewLoc = glGetUniformLocation(lightingShader.Program, "view");
GLint projLoc = glGetUniformLocation(lightingShader.Program, "projection");
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
glBindVertexArray(containerVAO);
glm::mat4 model;
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
// 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);
glfwSwapBuffers(window);
}
glDeleteVertexArrays(1, &containerVAO);
glDeleteVertexArrays(1, &lightVAO);
glDeleteBuffers(1, &VBO);
glfwTerminate();
return 0;
}
