void process(std::vector<SoftPhongDrawCall>& cmds) {
if (viewer_->testUserMessage(kUMSpace)) {
if (++nspace_ == 1) {
sample_cat_ = (sample_cat_ + 1) % 4;
}
}
else {
nspace_ = 0;
}
Vector3f eye(0, -3 - pos_, 2.0f), at(0, 0, 0), up(0, 0, 1);
Vector3f eye_pos = eye;
Vector3f light_dir(-1.0f, -1.0f, 1.0f);
Matrix44f modeltrsf = Matrix44f::Rotate(0.0f, 0.0f, 1.0f, alpha_);
Matrix44f viewtrsf = Matrix44f::LookAt(eye, at, up);
output_.uniforms.texture = texlist_[itex_];//纹理
output_.uniforms.model_trsf = modeltrsf;//模型变换
output_.uniforms.mvp_trsf = modeltrsf * viewtrsf * proj_;//模型*视图变换*投影变换
output_.uniforms.eye_pos = eye_pos;//相机位置
output_.uniforms.light_dir = light_dir;//光源位置
output_.uniforms.sample_cat = sample_cat_;
cmds.push_back(output_);
}
// this method should be called after any camera transformation (perspective or modelview)
// it will update viewport, perspective, view matrix, and update the uniforms
void GLWidget3D::updateCamera() {
// update matrices
int height = this->height() ? this->height() : 1;
glViewport(0, 0, (GLint)this->width(), (GLint)this->height());
camera.updatePerspective(this->width(),height);
// update uniforms
float mvpMatrixArray[16];
float mvMatrixArray[16];
for(int i=0;i<16;i++){
mvpMatrixArray[i]=camera.mvpMatrix.data()[i];
mvMatrixArray[i]=camera.mvMatrix.data()[i];
}
float normMatrixArray[9];
for(int i=0;i<9;i++){
normMatrixArray[i]=camera.normalMatrix.data()[i];
}
//glUniformMatrix4fv(mvpMatrixLoc, 1, false, mvpMatrixArray);
glUniformMatrix4fv(glGetUniformLocation(vboRenderManager.program, "mvpMatrix"), 1, false, mvpMatrixArray);
glUniformMatrix4fv(glGetUniformLocation(vboRenderManager.program, "mvMatrix"), 1, false, mvMatrixArray);
glUniformMatrix3fv(glGetUniformLocation(vboRenderManager.program, "normalMatrix"), 1, false, normMatrixArray);
// light direction
QVector3D light_dir(-0.40f, 0.81f, -0.51f);
glUniform3f(glGetUniformLocation(vboRenderManager.program, "lightDir"), light_dir.x(), light_dir.y(), light_dir.z());
}
void GLWidgetSimpleShadow::updateShadowMatrix(GLWidget3D* glWidget3D){
QVector3D light_dir(-0.40f, 0.81f, -0.51f);
//////////////////////////////////////////////////////
float fov = 45.0f;
float aspect = (float)shadowWidth / (float)shadowHeight;
float zfar = 15000.0f;//3800.0
float znear = 7000.0f;//1500.0
float f = 1.0f / tanf(fov * (M_PI / 360.0));
double m[16] = {
f/aspect, 0, 0, 0,
0, f, 0, 0,
0, 0, (zfar+znear)/(znear-zfar), (2.0f*zfar*znear)/(znear-zfar),
0, 0, -1, 0
};
light_pMatrix=QMatrix4x4(m);
// BIAS MATRIX
light_biasMatrix.setToIdentity();
light_biasMatrix.scale(0.5f);
light_biasMatrix.translate(0.5f,0.5f,0.5f);
// UNIFORMS LOC
light_mvpMatrixLoc= glGetUniformLocation(programId, "light_mvpMatrix");
light_biasMatrixLoc= glGetUniformLocation(programId, "light_biasMatrix");
light_dirLoc= glGetUniformLocation(programId, "lightDir");
//printf("LOC lights %d %d %d\n",light_mvpMatrixLoc,light_biasMatrixLoc,light_dirLoc);
// UPDATE MATRIX
light_mvMatrix.setToIdentity();
light_mvMatrix.lookAt(-light_dir*10000,//2500
light_dir.normalized(),//QVector3D(-0.60f,0.55,-0.6),
QVector3D(0.0f, 0.0f, 1.0f));
light_mvpMatrix=light_pMatrix*light_mvMatrix;
///////////////////////////////////////////////////////
float light_mvpMatrixArray[16];
float light_biasMatrixArray[16];
for(int i=0;i<16;i++){
light_mvpMatrixArray[i]=light_mvpMatrix.data()[i];
light_biasMatrixArray[i]=light_biasMatrix.data()[i];
}
glUniformMatrix4fv(light_mvpMatrixLoc,1,GL_FALSE,light_mvpMatrixArray);
glUniformMatrix4fv(light_biasMatrixLoc,1,GL_FALSE,light_biasMatrixArray);
glUniform3f(light_dirLoc,light_dir.x(),light_dir.y(),light_dir.z());
}//
/**
* This function is called whenever the widget needs to be painted.
*/
void GLWidget3D::paintGL()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDisable(GL_TEXTURE_2D);
// pass the model view projection matrix to the shader
float mvpMatrixArray[16];
float mvMatrixArray[16];
for (int i = 0; i < 16; ++i) {
mvpMatrixArray[i] = camera.mvpMatrix.data()[i];
mvMatrixArray[i] = camera.mvMatrix.data()[i];
}
glUniformMatrix4fv(glGetUniformLocation(program, "mvpMatrix"), 1, false, mvpMatrixArray);
glUniformMatrix4fv(glGetUniformLocation(program, "mvMatrix"), 1, false, mvMatrixArray);
// pass the light direction to the shader
QVector3D light_dir(-0.2, -0.1, -1);
light_dir.normalize();
glUniform3f(glGetUniformLocation(program, "lightDir"), light_dir.x(), light_dir.y(), light_dir.z());
drawScene();
}
int main(int argc, char** argv) {
TGAImage image(width, height, TGAImage::RGB);
if (argc == 2) {
model = new Model(argv[1]);
} else {
model = new Model("obj/african_head.obj");
}
Vec3f light_dir(0, 0, -1);
int* zbuffer = new int[width*height];
memset(zbuffer, std::numeric_limits<int>::min(), sizeof(zbuffer));
for (int i = 0; i < model->nfaces(); i++) {
std::vector<Vec3i> face = model->face(i);
Vec3i screen_coords[3];
Vec3f world_coords[3];
for (int j = 0; j < 3; j++) {
Vec3f v = model->vert(face[j].x);
world_coords[j] = v;
screen_coords[j] = Vec3i((v.x+1.)*width/2., (v.y+1.)*height/2., (v.z + 1.) * depth / 2.);
}
Vec3f n = (world_coords[2] - world_coords[0]) ^ (world_coords[1] - world_coords[0]);
n.normalize();
float intensity = n * light_dir;
if (intensity > 0) {
Vec2i uv[3];
for (int k=0; k<3; k++) {
uv[k] = model->uv(i, k);
}
triangle(screen_coords[0], screen_coords[1], screen_coords[2],
uv[0], uv[1], uv[2], intensity, zbuffer, image);
}
}
image.flip_vertically();
image.write_tga_file("/home/eugene/Documents/image.tga");
delete model;
delete[] zbuffer;
return 0;
}
int main() {
GLFWwindow * window = initWindow(windowWidth, windowHeight);
if (!window) {
glfwTerminate();
return -1;
}
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, cursor_callback);
glfwSetScrollCallback(window, scroll_callback);
glEnable(GL_DEPTH_TEST);
// prepare texture loading library(devil)
ilInit();
// prepare an array of vertices
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
};
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 lightVAO;
glGenVertexArrays(1, &lightVAO);
glBindVertexArray(lightVAO);
GLuint lightVBO;
glGenBuffers(1, &lightVBO);
glBindBuffer(GL_ARRAY_BUFFER, lightVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat),
(void*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat),
(void*)(6 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glBindVertexArray(0);
Shader shaders("shader.vert", "shader.frag");
Shader lightShaders("lightShader.vert", "lightShader.frag");
std::cout << "Input path: ";
std::string path;
std::getline(std::cin, path);
std::cout << "path is: " << path << std::endl;
std::cout << "Loading model..." << std::endl;
Model themodel(path.c_str());
std::cout << "Model loaded!" << std::endl;
double last_frame = glfwGetTime();
while (!glfwWindowShouldClose(window)) {
double current_frame = glfwGetTime();
double delta_time = current_frame - last_frame;
last_frame = current_frame;
glfwPollEvents();
do_movement(delta_time);
glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLfloat light_pos_angle = glm::radians(60.0f * current_frame);
glm::vec3 light_pos(1.2f + sin(light_pos_angle), 0.0f, 2.0f + cos(light_pos_angle));
glm::vec3 light_dir(-0.2f, -1.0f, -0.3f);
// draw common container
shaders.Use();
glm::mat4 view = camera.GetViewMatrix();
glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom),
(GLfloat)windowWidth / (GLfloat)windowHeight,
0.01f, 1000.0f);
shaders.SetUniform("view", view);
shaders.SetUniform("projection", projection);
glm::vec3 lightColor(1.0f, 1.0f, 1.0f);
//lightColor.r = sin(current_frame * 2.0f);
//lightColor.g = sin(current_frame * 0.7f);
//lightColor.b = sin(current_frame * 1.3f);
shaders.SetUniform("ViewPos", camera.Position);
// directional light
shaders.SetUniform("dirLight.direction", light_dir);
shaders.SetUniform("dirLight.ambient", 0.1f, 0.1f, 0.1f);
shaders.SetUniform("dirLight.diffuse", 0.5f, 0.5f, 0.5f);
shaders.SetUniform("dirLight.specular", 1.0f, 1.0f, 1.0f);
// point light
shaders.SetUniform("pointLights[0].position", light_pos);
shaders.SetUniform("pointLights[0].ambient", lightColor * 0.1f);
shaders.SetUniform("pointLights[0].diffuse", lightColor * 0.5f);
shaders.SetUniform("pointLights[0].specular", 1.0f, 1.0f, 1.0f);
shaders.SetUniform("pointLights[0].constant", 1.0f);
shaders.SetUniform("pointLights[0].linear", 0.09f);
shaders.SetUniform("pointLights[0].quadratic", 0.032f);
shaders.SetUniform("pointLightCount", 1);
glm::vec3 spotLight((GLfloat)flash_light_on);
// spot light
shaders.SetUniform("spotLight.ambient", spotLight * 0.1f);
shaders.SetUniform("spotLight.diffuse", spotLight * 0.5f);
shaders.SetUniform("spotLight.specular", spotLight);
shaders.SetUniform("spotLight.position", camera.Position);
shaders.SetUniform("spotLight.direction", camera.Front);
shaders.SetUniform("spotLight.cutoff", glm::cos(glm::radians(12.5f)));
shaders.SetUniform("spotLight.outerCutoff", glm::cos(glm::radians(17.5f)));
shaders.SetUniform("material.shininess", 10000.0f);
glm::mat4 model = glm::translate(glm::mat4(), glm::vec3(0.2f, -1.0f, 1.0f));
model = glm::scale(model, glm::vec3(0.1f, 0.1f, 0.1f));
shaders.SetUniform("model", model);
glm::mat3 normalMatrix = glm::mat3(glm::transpose(glm::inverse(model)));
shaders.SetUniform("normalMatrix", normalMatrix);
themodel.Draw(shaders);
// draw lamp
lightShaders.Use();
glm::mat4 lightModel = glm::scale(glm::translate(glm::mat4(), light_pos), glm::vec3(0.2f));
lightShaders.SetUniform("view", view);
lightShaders.SetUniform("projection", projection);
lightShaders.SetUniform("model", lightModel);
lightShaders.SetUniform("lightColor", lightColor);
glBindVertexArray(lightVAO);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
glfwSwapBuffers(window);
}
glfwTerminate();
return 0;
}
void GLWidgetSimpleShadow::initShadow(int _programId,GLWidget3D* glWidget3D) {
printf("---------- >> INIT SHADOW\n");
QVector3D light_dir(-0.40f, 0.81f, -0.51f);
programId = _programId;
// PROJECTION MATRIX
float fov = 60.0f;//45.0f; // Think if bigger
float aspect = (float)shadowWidth / (float)shadowHeight;
float zfar = 15000.0f;//
float znear = 1000.0f;// FIX
float f = 1.0f / tanf(fov * (M_PI / 360.0));
double m[16] = {
f/aspect, 0, 0, 0,
0, f, 0, 0,
0, 0, (zfar+znear)/(znear-zfar), (2.0f*zfar*znear)/(znear-zfar),
0, 0, -1, 0
};
light_pMatrix=QMatrix4x4(m);
// BIAS MATRIX
light_biasMatrix.setToIdentity();
light_biasMatrix.scale(0.5f);
light_biasMatrix.translate(0.5f,0.5f,0.5f);
// UNIFORMS LOC
light_mvpMatrixLoc= glGetUniformLocation(programId, "light_mvpMatrix");
light_biasMatrixLoc= glGetUniformLocation(programId, "light_biasMatrix");
light_dirLoc= glGetUniformLocation(programId, "lightDir");
printf("LOC lights %d %d %d\n",light_mvpMatrixLoc,light_biasMatrixLoc,light_dirLoc);
// UPDATE MATRIX
//QVector3D light_position=glWidget3D->getCamera()->light_dir.toVector3D();
light_mvMatrix.setToIdentity();
// FIX
/*light_mvMatrix.lookAt(QVector3D(1365.0,-1200.0f,1245.0),
QVector3D(-0.60f,0.55,-0.6),
QVector3D(0.0f, 0.0f, 1.0f));*/
light_mvMatrix.lookAt(-light_dir*10000,//2500
light_dir.normalized(),//QVector3D(-0.60f,0.55,-0.6),
QVector3D(0.0f, 0.0f, 1.0f));
light_mvpMatrix=light_pMatrix*light_mvMatrix;
updateShadowMatrix(glWidget3D);
// INIT shadowMap
// FBO
glGenFramebuffers(1,&FBO);
glBindFramebuffer(GL_FRAMEBUFFER,FBO);
////////////////////
glGenTextures(MAX_SPLITS, &shadowMap[0]);
glActiveTexture(GL_TEXTURE6);
glBindTexture(GL_TEXTURE_2D,shadowMap[0]);
glTexImage2D(GL_TEXTURE_2D, 0,GL_DEPTH_COMPONENT32, shadowWidth, shadowHeight, 0,GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glActiveTexture(GL_TEXTURE0);
////
VBOUtil::check_gl_error("Init ShadowMap");
glUniform1i(glGetUniformLocation(programId,"shadowMap"), 6);//shadowMap in tex1
glBindFramebuffer(GL_FRAMEBUFFER,0);
printf("---------- << INIT SHADOW\n");
}//
