static void render()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setUniformMat4(program1, "model", objects[0].model);
glUseProgram(program1);
glBindVertexArray(objects[0].vao);
glBindTexture(GL_TEXTURE_2D, objects[0].texture);
glDrawElements(GL_TRIANGLES, indicesCount[0], GL_UNSIGNED_INT, nullptr);
//render ui objects, background first
glDisable(GL_DEPTH_TEST);
glUseProgram(gui_shader);
glBindVertexArray(gui.background.vao);
glBindTexture(GL_TEXTURE_2D, gui.background.texture);
glDrawArrays(GL_TRIANGLES, 0, 6);
//then buttons;
for(int i=0; i<gui.button_num; ++i)
{
button b = gui.buttons[i];
glBindVertexArray(b.vao);
glBindTexture(GL_TEXTURE_2D, b.texture[b.state]);
glDrawArrays(GL_TRIANGLES, 0, 6);
}
glEnable(GL_DEPTH_TEST);
glBindVertexArray(0);
}
void Skybox::onDraw(const Mat4& transform, uint32_t flags)
{
auto camera = Camera::getVisitingCamera();
Mat4 cameraModelMat = camera->getNodeToWorldTransform();
auto state = getGLProgramState();
state->apply(transform);
Vec4 color(_displayedColor.r / 255.f, _displayedColor.g / 255.f, _displayedColor.b / 255.f, 1.f);
state->setUniformVec4("u_color", color);
cameraModelMat.m[12] = cameraModelMat.m[13] = cameraModelMat.m[14] = 0;
state->setUniformMat4("u_cameraRot", cameraModelMat);
glEnable(GL_DEPTH_TEST);
StateBlock::_defaultState->setDepthTest(true);
glDepthFunc(GL_LEQUAL);
StateBlock::_defaultState->setDepthFunction(DEPTH_LEQUAL);
glEnable(GL_CULL_FACE);
StateBlock::_defaultState->setCullFace(true);
glCullFace(GL_BACK);
StateBlock::_defaultState->setCullFaceSide(CULL_FACE_SIDE_BACK);
glDisable(GL_BLEND);
StateBlock::_defaultState->setBlend(false);
if (Configuration::getInstance()->supportsShareableVAO())
{
GL::bindVAO(_vao);
}
else
{
GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION);
glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(Vec3), nullptr);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer);
}
glDrawElements(GL_TRIANGLES, (GLsizei)36, GL_UNSIGNED_BYTE, nullptr);
if (Configuration::getInstance()->supportsShareableVAO())
{
GL::bindVAO(0);
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 8);
CHECK_GL_ERROR_DEBUG();
}
void kit::BakedTerrain::renderShadows(glm::mat4 const & viewMatrix, glm::mat4 const & projectionMatrix)
{
glDisable(GL_CULL_FACE);
auto program = kit::Model::getShadowProgram(false, false, false);
program->setUniformMat4("uniform_mvpMatrix", projectionMatrix * viewMatrix * getWorldTransformMatrix());
program->use();
renderGeometry();
}
void kit::Model::renderShadows(glm::mat4 const & viewMatrix, glm::mat4 const & projectionMatrix)
{
for (auto &currSubmeshIndex : m_mesh->getSubmeshEntries())
{
auto & currMaterial = currSubmeshIndex.second.m_material;
auto & currSubmesh = currSubmeshIndex.second.m_submesh;
if (!currMaterial->getCastShadows())
{
continue;
}
if (currMaterial->getDoubleSided())
{
glDisable(GL_CULL_FACE);
}
else
{
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
}
bool O = (currMaterial->getOpacityMask() != nullptr);
bool S = (m_skeleton != nullptr);
bool I = m_instanced;
auto currProgram = kit::Model::getShadowProgram(S, O, I);
currProgram->setUniformMat4("uniform_mvpMatrix", projectionMatrix * viewMatrix * getWorldTransformMatrix());
if(O)
{
currProgram->setUniformTexture("uniform_opacityMask", currMaterial->getOpacityMask().get());
}
if(S)
{
currProgram->setUniformMat4v("uniform_bones", m_skeleton->getSkin());
}
if(I)
{
currProgram->setUniformMat4v("uniform_instanceTransform", m_instanceTransform);
currProgram->use();
currSubmesh->renderGeometryInstanced(m_instanceTransform.size());
}
else
{
currProgram->use();
currSubmesh->renderGeometry();
}
}
}
void M2DRotation::setTexture(const std::string &source)
{
this->initWithFile(source);
// this->setAnchorPoint(Vec2(0.5, 0));
this->getTexture()->setAntiAliasTexParameters();
auto vertStr = FileUtils::getInstance()->getStringFromFile("res/gltest/2dper.vert");
auto fragStr = FileUtils::getInstance()->getStringFromFile("res/gltest/2dper.fsh");
auto pstate = GLProgramState::create( GLProgram::createWithByteArrays(vertStr.c_str(), fragStr.c_str()) );
Mat4 rmat;
Mat4::createRotationX(-3.1415926/6, &rmat);
pstate->setUniformMat4("u_rotation", rmat);
// pstate->setUniformTexture("u_textureTo", texture);
// pstate->setUniformFloat("u_progress", 0);
// pstate->setUniformFloat("u_start", 0.11);
this->setGLProgramState(pstate);
}
static void setVS(unsigned int program , const glm::mat4 projection , const glm::mat4 view , const glm::mat4 model)
{
setUniformMat4(program,"projection",projection);
setUniformMat4(program,"vp",view);
setUniformMat4(program,"model",model);
}
void O2DColorShader::prepare(OCamera2D *camera)
{
setUniformMat4("u_MVP", camera->getCameraMatrix());
}
int main(int argc, char *argv[])
{
GLFWwindow* window;
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
// OpenGL 3.3, Mac OS X is reported to have some problem. However I don't have Mac to test
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
// For Mac OS X
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
window = glfwCreateWindow(1280, 960, "Mesh Smoothing Demo", NULL, NULL);
if (!window)
{
glfwTerminate();
return EXIT_FAILURE;
}
glfwMakeContextCurrent(window);
// This line MUST put below glfwMakeContextCurrent
glewExperimental = GL_TRUE;
glewInit();
// Enable vsync
glfwSwapInterval(1);
// Setup input callback
glfwSetKeyCallback(window, key_callback);
glfwSetMouseButtonCallback(window, mouse_callback);
setup_gui_texture();
setup_gui_render_obj();
filenames[0] = "smoothing";
filenames[1] = "/ori/";
filenames[2] = "/lap/";
filenames[3] = "/tau/";
// load shader program
shaders[0] = setup_shader(readfile("shaders/vs.txt").c_str(), readfile("shaders/fs.txt").c_str());
gui_shader = setup_shader(readfile("shaders/guivs.txt").c_str(), readfile("shaders/guifs.txt").c_str());
shaders[1] = setup_shader(readfile("shaders/nvs.txt").c_str(), readfile("shaders/nfs.txt").c_str());
shaders[2] = setup_shader(readfile("shaders/fvs.txt").c_str(), readfile("shaders/ffs.txt").c_str());
printf("we have:%d, %d, %d\n", shaders[0], shaders[1], shaders[2]);
program1 = shaders[0];
show_obj = add_obj("smoothing/ori/bunny.obj");
glm::vec3 light_pos(0.0f, 0.0f, 0.0f);
camera_location = glm::vec4(0.0f, 0.0f, 2.0f, 1.0f);
up_direction = glm::vec4(0.0f, 1.0f, 0.0f, 1.0f);
glEnable(GL_DEPTH_TEST);
glCullFace(GL_BACK);
glm::vec3 camera_location_xyz = glm::vec3(camera_location.x, camera_location.y, camera_location.z);
glm::vec3 up_direction_xyz = glm::vec3(up_direction.x, up_direction.y, up_direction.z);
setUniformMat4(shaders[0], "p", glm::perspective(glm::radians(45.0f), 640.0f/480, 0.1f, 100.f) *glm::mat4(1.0f));
setUniformMat4(shaders[0], "v", glm::lookAt(camera_location_xyz, glm::vec3(0.0f), glm::vec3(0, 1, 0))*glm::mat4(1.0f));
setUniformMat4(shaders[1], "p", glm::perspective(glm::radians(45.0f), 640.0f/480, 0.1f, 100.f) *glm::mat4(1.0f));
setUniformMat4(shaders[1], "v", glm::lookAt(camera_location_xyz, glm::vec3(0.0f), glm::vec3(0, 1, 0))*glm::mat4(1.0f));
setUniformMat4(shaders[2], "p", glm::perspective(glm::radians(45.0f), 640.0f/480, 0.1f, 100.f) *glm::mat4(1.0f));
setUniformMat4(shaders[2], "v", glm::lookAt(camera_location_xyz, glm::vec3(0.0f), glm::vec3(0, 1, 0))*glm::mat4(1.0f));
glm::mat4 rot;
glm::mat4 rev;
float last, start;
last = start = glfwGetTime();
float fps = 0;
while (!glfwWindowShouldClose(window))
{
rotate();
zoom();
camera_location_xyz = glm::vec3(camera_location.x, camera_location.y, camera_location.z);
up_direction_xyz = glm::vec3(up_direction.x, up_direction.y, up_direction.z);
setUniformMat4(shaders[0], "v", glm::lookAt(camera_location_xyz, glm::vec3(0.0f), up_direction_xyz)*glm::mat4(1.0f));
setUniformMat4(shaders[1], "v", glm::lookAt(camera_location_xyz, glm::vec3(0.0f), up_direction_xyz)*glm::mat4(1.0f));
setUniformMat4(shaders[2], "v", glm::lookAt(camera_location_xyz, glm::vec3(0.0f), up_direction_xyz)*glm::mat4(1.0f));
render();
glfwSwapBuffers(window);
glfwPollEvents();
fps++;
if(glfwGetTime() - last > 1.0)
{
std::cout<<(double)fps/(glfwGetTime()-last)<<std::endl;
fps = 0;
last = glfwGetTime();
}
}
releaseObjects();
glfwDestroyWindow(window);
glfwTerminate();
return EXIT_SUCCESS;
}
static void set_vp(unsigned int prog) {
setUniformMat4(prog, "vp", glm::perspective(glm::radians(45.0f), 640.0f / 480, 1.0f, 100.f) *
glm::lookAt(glm::vec3(40.0f), glm::vec3(), glm::vec3(0, 1, 0)) * glm::mat4(1.0f));
}
