void Scene::deferredRender() {
// Requires:
// + A g-buffer class to store framebuffers for each attribute;
// + Code to bind each framebuffer to a separate fragdatalocation;
// + A g-buffer shader program that populates the g-buffer when rendering geometry;
// + A VAO for each mesh to support the g-buffer shader program;
// - Deferred shading programs that take input from the g-buffer instead of the vertex shader, etc.;
// Render all geometry to g-buffer:
gBuffer->bind();
// TODO: Refactor enabling of framebuffer colour attachments.
GLuint attachments[3] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2 };
glDrawBuffers(3, attachments);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, camera->frameWidth, camera->frameHeight);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
drawModels(gBufferProgram, *camera);
glDisable(GL_CULL_FACE);
profiler.split("render g-buffer");
// Attach g-buffer uniforms to the deferred shaders:
gBuffer->bindTextures();
deferredShadingProgram->use();
deferredShadingProgram->setUniform("texDepthStencil", gBuffer->textureAttachments[GL_DEPTH_STENCIL_ATTACHMENT]);
deferredShadingProgram->setUniform("texNormal", gBuffer->textureAttachments[GL_COLOR_ATTACHMENT0]);
deferredShadingProgram->setUniform("texAlbedoRoughness", gBuffer->textureAttachments[GL_COLOR_ATTACHMENT1]);
deferredShadingProgram->setUniform("texEnvMapColSpecIntensity", gBuffer->textureAttachments[GL_COLOR_ATTACHMENT2]);
glm::mat4 projInverse = glm::inverse(camera->proj);
deferredShadingProgram->setUniform("projInverse", projInverse);
glm::mat4 viewInverse = glm::inverse(camera->view);
deferredShadingProgram->setUniform("viewInverse", viewInverse);
deferredShadingProgram->setUniform("view", camera->view);
// Clear the framebuffer:
framebuffer->bind();
glClear(GL_COLOR_BUFFER_BIT);
glDisable(GL_CULL_FACE);
// Render the environment map:
framebuffer->bind();
glViewport(0, 0, camera->frameWidth, camera->frameHeight);
screen->setTexture(gBuffer->textureAttachments[GL_COLOR_ATTACHMENT2]);
screen->render();
screen->removeTexture();
// Run the deferred shader over the framebuffer for each light:
int lightNum = 1;
for (auto light : lights) {
auto sharedLight = light.lock();
if (sharedLight->enabled) {
auto lightCamera = prepareShadowMap(lightNum, sharedLight);
framebuffer->bind();
glViewport(0, 0, camera->frameWidth, camera->frameHeight);
// glClear(GL_COLOR_BUFFER_BIT);
gBuffer->bindTextures();
screen->setTexture(framebuffer->textureAttachments[GL_COLOR_ATTACHMENT0]);
Model::setLightUniformsOnShaderProgram(deferredShadingProgram, sharedLight, lightCamera);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
screen->render(deferredShadingProgram);
glDisable(GL_BLEND);
profiler.split("deferred light ", lightNum);
// // Add the light's contribution to the screen:
// addFramebufferToTarget();
// Render a tiny shadow map:
if (!previewOptions.disable && (sharedLight->type == scene::Light::Type::spot ||
sharedLight->type == scene::Light::Type::directional)) {
drawShadowMapThumbnail(lightNum - 1);
}
profiler.split("drawShadowMapThumbnail ", lightNum);
}
lightNum++;
}
// Draw skybox and transparent meshes:
// (use the depth buffer from the g-buffer)
framebuffer->bind();
glViewport(0, 0, camera->frameWidth, camera->frameHeight);
framebuffer->attach(gBuffer->textureAttachments[GL_DEPTH_STENCIL_ATTACHMENT], GL_TEXTURE_2D, GL_DEPTH_STENCIL_ATTACHMENT);
// Draw skybox first:
skyBox->draw(*camera, skyBox->environmentMapProgram);
// Draw all transparent meshes:
// Disable depth buffer writes (for order invariant drawing):
glDepthMask(GL_FALSE);
lightNum = 1;
for (auto light : lights) {
auto sharedLight = light.lock();
if (sharedLight->enabled) {
auto lightCamera = prepareShadowMap(lightNum, sharedLight);
framebuffer->bind();
glViewport(0, 0, camera->frameWidth, camera->frameHeight);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
checkForAndPrintGLError(__FILE__, __LINE__);
drawModels(sharedLight, lightCamera, true, *camera);
glDisable(GL_BLEND);
profiler.split("transparent: light ", lightNum);
}
lightNum++;
}
// Enable depth buffer writes:
glDepthMask(GL_TRUE);
// Restore the framebuffer's depth attachment:
framebuffer->attach(std::move(framebuffer->renderbufferAttachment));
profiler.split("deferred lighting");
if (previewOptions.disable) {
addFramebufferToTarget(framebufferSize, nullptr);
} else {
if (!previewOptions.fullscreen)
addFramebufferToTarget(framebufferSize, nullptr, 2, 0.5, 0.5);
}
// Render g-buffer thumbnails:
if (!previewOptions.disable)
drawGBufferThumbnails();
}
int main()
{
int retVal = -1;
if (glfwInit())
{
//glfwWindowHint(GLFW_DOUBLEBUFFER, GL_FALSE);
glfwWindowHint(GLFW_RESIZABLE, GL_TRUE);
glfwWindowHint(GLFW_SAMPLES, 16);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glEnable(GL_MULTISAMPLE);
const int initWinWidth = 640;
const int initWinHeight = 480;
GLFWwindow * win = glfwCreateWindow(initWinWidth, initWinHeight, "TxCube", NULL, NULL);
if (win)
{
glfwMakeContextCurrent(win);
glfwSetWindowSizeCallback(win, OnWindowSize);
glfwSwapInterval(1);
glewExperimental = GL_TRUE;
if (glewInit() == GLEW_OK)
{
// workaround GLEW issue with GL_INVALID_ENUM rising just after glewInit
glGetError();
GLuint vertexArrayId;
glGenVertexArrays(1, &vertexArrayId); assert(!glGetError());
glBindVertexArray(vertexArrayId); assert(!glGetError());
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); assert(!glGetError());
glEnable(GL_CULL_FACE); assert(!glGetError());
glCullFace(GL_FRONT); assert(!glGetError());
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
scene = new Scene();
scene->setViewport(initWinWidth, initWinHeight);
int cnt = 0;
uint64_t freq = Crosy::getPerformanceFrequency();
uint64_t ticks = Crosy::getPerformanceCounter();
while (!glfwWindowShouldClose(win))
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); assert(!glGetError());
scene->draw();
glfwSwapBuffers(win);
glfwPollEvents();
cnt++;
Crosy::sleep(10);
float timePass = float(Crosy::getPerformanceCounter() - ticks) / freq;
if (timePass > 10)
{
float fps = cnt / timePass;
const int bufSize = 256;
char str[bufSize];
#ifdef _MSC_VER
_snprintf(str, bufSize, "Fps: %.3f", fps);
#else
snprintf(str, bufSize, "Fps: %.3f", fps);
#endif
glfwSetWindowTitle(win, str);
ticks = Crosy::getPerformanceCounter();
cnt = 0;
}
}
retVal = 0;
delete scene;
}
}
glfwTerminate();
}
return retVal;
}
static void draw_scene(GLFWwindow* window, double t)
{
double xpos, ypos, zpos, angle_x, angle_y, angle_z;
static double t_old = 0.0;
float dt;
mat4x4 projection;
// Calculate frame-to-frame delta time
dt = (float) (t - t_old);
t_old = t;
mat4x4_perspective(projection,
65.f * (float) M_PI / 180.f,
aspect_ratio,
1.0, 60.0);
glClearColor(0.1f, 0.1f, 0.1f, 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf((const GLfloat*) projection);
// Setup camera
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Rotate camera
angle_x = 90.0 - 10.0;
angle_y = 10.0 * sin(0.3 * t);
angle_z = 10.0 * t;
glRotated(-angle_x, 1.0, 0.0, 0.0);
glRotated(-angle_y, 0.0, 1.0, 0.0);
glRotated(-angle_z, 0.0, 0.0, 1.0);
// Translate camera
xpos = 15.0 * sin((M_PI / 180.0) * angle_z) +
2.0 * sin((M_PI / 180.0) * 3.1 * t);
ypos = -15.0 * cos((M_PI / 180.0) * angle_z) +
2.0 * cos((M_PI / 180.0) * 2.9 * t);
zpos = 4.0 + 2.0 * cos((M_PI / 180.0) * 4.9 * t);
glTranslated(-xpos, -ypos, -zpos);
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
setup_lights();
glEnable(GL_LIGHTING);
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_DENSITY, 0.05f);
glFogfv(GL_FOG_COLOR, fog_color);
draw_floor();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glDepthMask(GL_TRUE);
draw_fountain();
glDisable(GL_LIGHTING);
glDisable(GL_FOG);
// Particles must be drawn after all solid objects have been drawn
draw_particles(window, t, dt);
// Z-buffer not needed anymore
glDisable(GL_DEPTH_TEST);
}
void OpenGLState::Apply() const {
// Culling
if (cull.enabled != cur_state.cull.enabled) {
if (cull.enabled) {
glEnable(GL_CULL_FACE);
} else {
glDisable(GL_CULL_FACE);
}
}
if (cull.mode != cur_state.cull.mode) {
glCullFace(cull.mode);
}
if (cull.front_face != cur_state.cull.front_face) {
glFrontFace(cull.front_face);
}
// Depth test
if (depth.test_enabled != cur_state.depth.test_enabled) {
if (depth.test_enabled) {
glEnable(GL_DEPTH_TEST);
} else {
glDisable(GL_DEPTH_TEST);
}
}
if (depth.test_func != cur_state.depth.test_func) {
glDepthFunc(depth.test_func);
}
// Depth mask
if (depth.write_mask != cur_state.depth.write_mask) {
glDepthMask(depth.write_mask);
}
// Color mask
if (color_mask.red_enabled != cur_state.color_mask.red_enabled ||
color_mask.green_enabled != cur_state.color_mask.green_enabled ||
color_mask.blue_enabled != cur_state.color_mask.blue_enabled ||
color_mask.alpha_enabled != cur_state.color_mask.alpha_enabled) {
glColorMask(color_mask.red_enabled, color_mask.green_enabled, color_mask.blue_enabled,
color_mask.alpha_enabled);
}
// Stencil test
if (stencil.test_enabled != cur_state.stencil.test_enabled) {
if (stencil.test_enabled) {
glEnable(GL_STENCIL_TEST);
} else {
glDisable(GL_STENCIL_TEST);
}
}
if (stencil.test_func != cur_state.stencil.test_func ||
stencil.test_ref != cur_state.stencil.test_ref ||
stencil.test_mask != cur_state.stencil.test_mask) {
glStencilFunc(stencil.test_func, stencil.test_ref, stencil.test_mask);
}
if (stencil.action_depth_fail != cur_state.stencil.action_depth_fail ||
stencil.action_depth_pass != cur_state.stencil.action_depth_pass ||
stencil.action_stencil_fail != cur_state.stencil.action_stencil_fail) {
glStencilOp(stencil.action_stencil_fail, stencil.action_depth_fail,
stencil.action_depth_pass);
}
// Stencil mask
if (stencil.write_mask != cur_state.stencil.write_mask) {
glStencilMask(stencil.write_mask);
}
// Blending
if (blend.enabled != cur_state.blend.enabled) {
if (blend.enabled) {
glEnable(GL_BLEND);
cur_state.logic_op = GL_COPY;
glLogicOp(cur_state.logic_op);
glDisable(GL_COLOR_LOGIC_OP);
} else {
glDisable(GL_BLEND);
glEnable(GL_COLOR_LOGIC_OP);
}
}
if (blend.color.red != cur_state.blend.color.red ||
blend.color.green != cur_state.blend.color.green ||
blend.color.blue != cur_state.blend.color.blue ||
blend.color.alpha != cur_state.blend.color.alpha) {
glBlendColor(blend.color.red, blend.color.green, blend.color.blue, blend.color.alpha);
}
if (blend.src_rgb_func != cur_state.blend.src_rgb_func ||
blend.dst_rgb_func != cur_state.blend.dst_rgb_func ||
blend.src_a_func != cur_state.blend.src_a_func ||
blend.dst_a_func != cur_state.blend.dst_a_func) {
glBlendFuncSeparate(blend.src_rgb_func, blend.dst_rgb_func, blend.src_a_func,
blend.dst_a_func);
}
if (blend.rgb_equation != cur_state.blend.rgb_equation ||
blend.a_equation != cur_state.blend.a_equation) {
glBlendEquationSeparate(blend.rgb_equation, blend.a_equation);
}
if (logic_op != cur_state.logic_op) {
glLogicOp(logic_op);
}
// Textures
for (unsigned i = 0; i < ARRAY_SIZE(texture_units); ++i) {
if (texture_units[i].texture_2d != cur_state.texture_units[i].texture_2d) {
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, texture_units[i].texture_2d);
}
if (texture_units[i].sampler != cur_state.texture_units[i].sampler) {
glBindSampler(i, texture_units[i].sampler);
}
}
// Lighting LUTs
for (unsigned i = 0; i < ARRAY_SIZE(lighting_luts); ++i) {
if (lighting_luts[i].texture_1d != cur_state.lighting_luts[i].texture_1d) {
glActiveTexture(GL_TEXTURE3 + i);
glBindTexture(GL_TEXTURE_1D, lighting_luts[i].texture_1d);
}
}
// Fog LUT
if (fog_lut.texture_1d != cur_state.fog_lut.texture_1d) {
glActiveTexture(GL_TEXTURE9);
glBindTexture(GL_TEXTURE_1D, fog_lut.texture_1d);
}
// Framebuffer
if (draw.read_framebuffer != cur_state.draw.read_framebuffer) {
glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer);
}
if (draw.draw_framebuffer != cur_state.draw.draw_framebuffer) {
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, draw.draw_framebuffer);
}
// Vertex array
if (draw.vertex_array != cur_state.draw.vertex_array) {
glBindVertexArray(draw.vertex_array);
}
// Vertex buffer
if (draw.vertex_buffer != cur_state.draw.vertex_buffer) {
glBindBuffer(GL_ARRAY_BUFFER, draw.vertex_buffer);
}
// Uniform buffer
if (draw.uniform_buffer != cur_state.draw.uniform_buffer) {
glBindBuffer(GL_UNIFORM_BUFFER, draw.uniform_buffer);
}
// Shader program
if (draw.shader_program != cur_state.draw.shader_program) {
glUseProgram(draw.shader_program);
}
cur_state = *this;
}
//Method initializes OpenGL for rendering to a window/viewport
bool engine_3d::Init()
{
/// We need our GLFW function pointers to be assigned, if this process fails we cannot continue
if ( !glfwInit() )
{
return false;
}
/// Here we query how much sampling is possible and set that to be used if possible
GLint samples = 8;
glGetIntegerv( GL_SAMPLES, &samples );
if ( samples )
{
glEnable( GL_MULTISAMPLE );
}
glfwWindowHint( GLFW_SAMPLES, samples );
GLFWmonitor** monitors;
int count;
monitors = glfwGetMonitors( &count );
const GLFWvidmode* mode = glfwGetVideoMode( glfwGetPrimaryMonitor() );
///Create a window of a particular type
switch ( winMode )
{
case engine_WindowModel::FULLSCREEN:
window = glfwCreateWindow( mode->width, mode->height, "Fullscreen", glfwGetPrimaryMonitor(), NULL );
screenHeight = mode->height;
screenWidth = mode->width;
break;
case engine_WindowModel::DECORATEDWINDOW:
window = glfwCreateWindow( screenWidth, screenHeight, "Decorated Window", NULL, NULL );
break;
case engine_WindowModel::BORDERLESSFULLSCREEN:
glfwWindowHint( GLFW_DECORATED, false );
glfwWindowHint( GLFW_RED_BITS, mode->redBits );
glfwWindowHint( GLFW_GREEN_BITS, mode->greenBits );
glfwWindowHint( GLFW_BLUE_BITS, mode->blueBits );
glfwWindowHint( GLFW_REFRESH_RATE, mode->refreshRate );
window = glfwCreateWindow( mode->width, mode->height, "Borderless Fullscreen", NULL, NULL );
screenHeight = mode->height;
screenWidth = mode->width;
break;
}
/// If creating the window failed we need to terminate
if ( !window )
{
glfwTerminate();
return false;
}
/// Associates this window with OpenGL's rendering (I believe)
glfwMakeContextCurrent( window );
/// Sets our input processing function, all input will be passed to this function
//glfwSetScrollCallback( window, scroll_callback );
glfwSetKeyCallback( window, key_callback );
glfwSetCursorPosCallback( window, cursor_position_callback );
glfwSetMouseButtonCallback( window, mouse_button_callback );
/// start GLEW extension handler
glewExperimental = GL_TRUE;
///Initialize OpenGL functions
glewInit();
const GLubyte* renderer = glGetString( GL_RENDERER ); /// get renderer string
const GLubyte* version = glGetString( GL_VERSION ); /// version as a string
///oLog( Level::Info ) << "Renderer: " << renderer;
///oLog( Level::Info ) << "OpenGL version supported: " << version;
projectionMatrix = glm::mat4( 1.f );
viewMatrix = glm::mat4( 1.f );
glEnable( GL_CULL_FACE );
glCullFace( GL_BACK );
glFrontFace( GL_CCW );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); ///clear colour: r,g,b,a
glfwSwapInterval( 1 ); ///cap FPS
currentDC = wglGetCurrentDC();
currentContext = wglGetCurrentContext();
return true;
}
void templateAppDraw( void ) {
glClearColor( 0.5f, 0.5f, 0.5f, 1.0f );
glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT );
GFX_set_matrix_mode( MODELVIEW_MATRIX );
GFX_load_identity();
vec3 e = { 0.0f, -6.0f, 1.35f },
c = { 0.0f, -5.0f, 1.35f },
u = { 0.0f, 0.0f, 1.0f };
GFX_look_at( &e, &c, &u );
unsigned int i = 0;
while( i != obj->n_objmesh ) {
OBJMATERIAL *objmaterial = obj->objmesh[ i ].objtrianglelist[ 0 ].objmaterial;
if( objmaterial->dissolve == 1.0f ) {
GFX_push_matrix();
GFX_translate( obj->objmesh[ i ].location.x,
obj->objmesh[ i ].location.y,
obj->objmesh[ i ].location.z );
OBJ_draw_mesh( obj, i );
GFX_pop_matrix();
}
++i;
}
i = 0;
while( i != obj->n_objmesh ) {
OBJMATERIAL *objmaterial = obj->objmesh[ i ].objtrianglelist[ 0 ].objmaterial;
if( !objmaterial->dissolve ) {
GFX_push_matrix();
GFX_translate( obj->objmesh[ i ].location.x,
obj->objmesh[ i ].location.y,
obj->objmesh[ i ].location.z );
glCullFace( GL_FRONT );
OBJ_draw_mesh( obj, i );
glCullFace( GL_BACK );
OBJ_draw_mesh( obj, i );
GFX_pop_matrix();
}
++i;
}
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
i = 0;
while( i != obj->n_objmesh ) {
OBJMATERIAL *objmaterial = obj->objmesh[ i ].objtrianglelist[ 0 ].objmaterial;
if( objmaterial->dissolve > 0.0f && objmaterial->dissolve < 1.0f ) {
GFX_push_matrix();
GFX_translate( obj->objmesh[ i ].location.x,
obj->objmesh[ i ].location.y,
obj->objmesh[ i ].location.z );
glCullFace( GL_FRONT );
OBJ_draw_mesh( obj, i );
glCullFace( GL_BACK );
OBJ_draw_mesh( obj, i );
GFX_pop_matrix();
}
++i;
}
glDisable( GL_BLEND );
}
void StateBlock::bindNoRestore()
{
CC_ASSERT(_defaultState);
// Update any state that differs from _defaultState and flip _defaultState bits
if ((_bits & RS_BLEND) && (_blendEnabled != _defaultState->_blendEnabled))
{
if (_blendEnabled)
glEnable(GL_BLEND);
else
glDisable(GL_BLEND);
_defaultState->_blendEnabled = _blendEnabled;
}
if ((_bits & RS_BLEND_FUNC) && (_blendSrc != _defaultState->_blendSrc || _blendDst != _defaultState->_blendDst))
{
GL::blendFunc((GLenum)_blendSrc, (GLenum)_blendDst);
_defaultState->_blendSrc = _blendSrc;
_defaultState->_blendDst = _blendDst;
}
if ((_bits & RS_CULL_FACE) && (_cullFaceEnabled != _defaultState->_cullFaceEnabled))
{
if (_cullFaceEnabled)
glEnable(GL_CULL_FACE);
else
glDisable(GL_CULL_FACE);
_defaultState->_cullFaceEnabled = _cullFaceEnabled;
}
if ((_bits & RS_CULL_FACE_SIDE) && (_cullFaceSide != _defaultState->_cullFaceSide))
{
glCullFace((GLenum)_cullFaceSide);
_defaultState->_cullFaceSide = _cullFaceSide;
}
if ((_bits & RS_FRONT_FACE) && (_frontFace != _defaultState->_frontFace))
{
glFrontFace((GLenum)_frontFace);
_defaultState->_frontFace = _frontFace;
}
if ((_bits & RS_DEPTH_TEST) && (_depthTestEnabled != _defaultState->_depthTestEnabled))
{
if (_depthTestEnabled)
glEnable(GL_DEPTH_TEST);
else
glDisable(GL_DEPTH_TEST);
_defaultState->_depthTestEnabled = _depthTestEnabled;
}
if ((_bits & RS_DEPTH_WRITE) && (_depthWriteEnabled != _defaultState->_depthWriteEnabled))
{
glDepthMask(_depthWriteEnabled ? GL_TRUE : GL_FALSE);
_defaultState->_depthWriteEnabled = _depthWriteEnabled;
}
if ((_bits & RS_DEPTH_FUNC) && (_depthFunction != _defaultState->_depthFunction))
{
glDepthFunc((GLenum)_depthFunction);
_defaultState->_depthFunction = _depthFunction;
}
// if ((_bits & RS_STENCIL_TEST) && (_stencilTestEnabled != _defaultState->_stencilTestEnabled))
// {
// if (_stencilTestEnabled)
// glEnable(GL_STENCIL_TEST);
// else
// glDisable(GL_STENCIL_TEST);
// _defaultState->_stencilTestEnabled = _stencilTestEnabled;
// }
// if ((_bits & RS_STENCIL_WRITE) && (_stencilWrite != _defaultState->_stencilWrite))
// {
// glStencilMask(_stencilWrite);
// _defaultState->_stencilWrite = _stencilWrite;
// }
// if ((_bits & RS_STENCIL_FUNC) && (_stencilFunction != _defaultState->_stencilFunction ||
// _stencilFunctionRef != _defaultState->_stencilFunctionRef ||
// _stencilFunctionMask != _defaultState->_stencilFunctionMask))
// {
// glStencilFunc((GLenum)_stencilFunction, _stencilFunctionRef, _stencilFunctionMask);
// _defaultState->_stencilFunction = _stencilFunction;
// _defaultState->_stencilFunctionRef = _stencilFunctionRef;
// _defaultState->_stencilFunctionMask = _stencilFunctionMask;
// }
// if ((_bits & RS_STENCIL_OP) && (_stencilOpSfail != _defaultState->_stencilOpSfail ||
// _stencilOpDpfail != _defaultState->_stencilOpDpfail ||
// _stencilOpDppass != _defaultState->_stencilOpDppass))
// {
// glStencilOp((GLenum)_stencilOpSfail, (GLenum)_stencilOpDpfail, (GLenum)_stencilOpDppass);
// _defaultState->_stencilOpSfail = _stencilOpSfail;
// _defaultState->_stencilOpDpfail = _stencilOpDpfail;
// _defaultState->_stencilOpDppass = _stencilOpDppass;
// }
_defaultState->_bits |= _bits;
}
static void draw_textured_begin(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob)
{
unsigned char obcol[4];
bool is_tex, solidtex;
Mesh *me = ob->data;
ImagePaintSettings *imapaint = &scene->toolsettings->imapaint;
/* XXX scene->obedit warning */
/* texture draw is abused for mask selection mode, do this so wire draw
* with face selection in weight paint is not lit. */
if ((v3d->drawtype <= OB_WIRE) && (ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT))) {
solidtex = false;
Gtexdraw.is_lit = 0;
}
else if (v3d->drawtype == OB_SOLID || ((ob->mode & OB_MODE_EDIT) && v3d->drawtype != OB_TEXTURE)) {
/* draw with default lights in solid draw mode and edit mode */
solidtex = true;
Gtexdraw.is_lit = -1;
}
else {
/* draw with lights in the scene otherwise */
solidtex = false;
if (v3d->flag2 & V3D_SHADELESS_TEX)
Gtexdraw.is_lit = 0;
else
Gtexdraw.is_lit = GPU_scene_object_lights(scene, ob, v3d->lay, rv3d->viewmat, !rv3d->is_persp);
}
rgba_float_to_uchar(obcol, ob->col);
if (solidtex || v3d->drawtype == OB_TEXTURE) is_tex = true;
else is_tex = false;
Gtexdraw.ob = ob;
Gtexdraw.stencil = (imapaint->flag & IMAGEPAINT_PROJECT_LAYER_STENCIL) ? imapaint->stencil : NULL;
Gtexdraw.is_texpaint = (ob->mode == OB_MODE_TEXTURE_PAINT);
Gtexdraw.texpaint_material = (imapaint->mode == IMAGEPAINT_MODE_MATERIAL);
Gtexdraw.canvas = (Gtexdraw.texpaint_material) ? NULL : imapaint->canvas;
Gtexdraw.is_tex = is_tex;
/* naughty multitexturing hacks to quickly support stencil + shading + alpha blending
* in new texpaint code. The better solution here would be to support GLSL */
if (Gtexdraw.is_texpaint) {
glActiveTexture(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PREVIOUS);
/* load the stencil texture here */
if (Gtexdraw.stencil != NULL) {
glActiveTexture(GL_TEXTURE2);
if (GPU_verify_image(Gtexdraw.stencil, NULL, false, false, false, false)) {
float col[4] = {imapaint->stencil_col[0], imapaint->stencil_col[1], imapaint->stencil_col[2], 1.0f};
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_TEXTURE);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, col);
if ((imapaint->flag & IMAGEPAINT_PROJECT_LAYER_STENCIL_INV) == 0) {
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_ONE_MINUS_SRC_COLOR);
}
else {
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_COLOR);
}
}
}
glActiveTexture(GL_TEXTURE0);
}
Gtexdraw.color_profile = BKE_scene_check_color_management_enabled(scene);
Gtexdraw.use_game_mat = (RE_engines_find(scene->r.engine)->flag & RE_GAME) != 0;
Gtexdraw.use_backface_culling = (v3d->flag2 & V3D_BACKFACE_CULLING) != 0;
memcpy(Gtexdraw.obcol, obcol, sizeof(obcol));
set_draw_settings_cached(1, NULL, NULL, Gtexdraw);
glShadeModel(GL_SMOOTH);
glCullFace(GL_BACK);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, (me->flag & ME_TWOSIDED) ? GL_TRUE : GL_FALSE);
}
ENTRYPOINT void draw_providence(ModeInfo * mi)
{
providencestruct *mp;
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if(!providence)
return;
mp = &providence[MI_SCREEN(mi)];
MI_IS_DRAWN(mi) = True;
if(!mp->glx_context)
return;
glXMakeCurrent(display, window, *(mp->glx_context));
/* setup twoside lighting */
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient2);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, mp->position0);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_NORMALIZE);
glFrontFace(GL_CCW);
/* glDisable(GL_CULL_FACE); */
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(current_device_rotation(), 0, 0, 1);
/* modify camera */
if(fabs(mp->camera_velocity) > EPSILON) {
mp->camera_z = max(min(mp->camera_z + 0.1*mp->camera_velocity, -4.0), -12.0);
mp->camera_velocity = 0.95*mp->camera_velocity;
}
/* rotate providence */
glTranslatef(0.0, 0.0, mp->camera_z + sin(mp->theta/4.0));
glRotatef(10.0+20.0*sin(mp->theta/2.0), 1.0, 0.0, 0.0);
gltrackball_rotate(mp->trackball);
glRotatef(mp->theta * 180.0 / Pi, 0.0, -1.0, 0.0);
# ifdef HAVE_MOBILE /* Keep it the same relative size when rotated. */
{
GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi);
int o = (int) current_device_rotation();
if (o != 0 && o != 180 && o != -180)
glScalef (1/h, 1/h, 1/h);
}
# endif
/* draw providence */
draw_providence_strip(mi);
glPopMatrix();
if(MI_IS_FPS(mi)) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
/* update */
mp->currenttime += 1.0 / FPS;
mp->theta = mp->currenttime / 2.0 * mp->theta_scale;
update_particles(mp);
}
M(void, glCullFace, jint mode) {
glCullFace(mode);
}
int __cdecl main(int argc, char* argv[])
{
WNDCLASSEX wc={sizeof(WNDCLASSEX), 0, wp, 0, 0, 0, 0, 0, 0, 0, "GLAP301"};
wc.hCursor=LoadCursor(0, IDC_ARROW);;
wc.hIcon=LoadIcon(0,IDI_APPLICATION);
RegisterClassEx(&wc);
RECT wrect={0, 0, W, H};
AdjustWindowRectEx(&wrect, WS_OVERLAPPEDWINDOW, FALSE, WS_EX_APPWINDOW);
HWND win=CreateWindowEx(WS_EX_APPWINDOW, "GLAP301", "Render Window", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
wrect.right-wrect.left, wrect.bottom-wrect.top, 0, 0, 0, 0);
ShowWindow(win, SW_SHOWNORMAL);
UpdateWindow(win);
MSG msg={0, 0, 0, 0, 0, {0, 0}};
CTimer timer;
CUIGL GL;
GL.Init(W, H, 1, 1, win);
WGLPROC(glCreateShader);
WGLPROC(glShaderSource);
WGLPROC(glCompileShader);
WGLPROC(glGetShaderiv);
WGLPROC(glGetShaderInfoLog);
WGLPROC(glCreateProgram);
WGLPROC(glAttachShader);
WGLPROC(glLinkProgram);
WGLPROC(glUseProgram);
WGLPROC(glGenBuffers);
WGLPROC(glDeleteBuffers);
WGLPROC(glBindBuffer);
WGLPROC(glBufferData);
WGLPROC(glMapBuffer);
WGLPROC(glUnmapBuffer);
WGLPROC(glVertexAttribPointer);
WGLPROC(glGetAttribLocation);
WGLPROC(glEnableVertexAttribArray);
WGLPROC(glActiveTexture);
WGLPROC(glGetUniformLocation);
WGLPROC(glProgramUniform1i);
WGLPROC(glProgramUniform3f);
WGLPROC(glProgramUniform4f);
WGLPROC(glProgramUniformMatrix4fv);
GLuint ibo=-1;
glGenBuffers(1, &ibo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibsize, ib, GL_STATIC_DRAW);
GLuint vbo=-1;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, vbsize, vb, GL_STATIC_DRAW);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glEnableVertexAttribArray(3);
glEnableVertexAttribArray(4);
glEnable(GL_DEPTH);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthFunc(GL_LESS);
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
GLuint body_tex=LoadTexture("data\\body_diff.png");
GLuint body_norm=LoadTexture("data\\body_norm.png");
GLuint fur_tex=LoadTexture("data\\fur_diff.png");
GLuint fur_norm=LoadTexture("data\\fur_norm.png");
GLShader sh;
glClearColor(0.3f, 0.5f, 0.8f, 1.0f);
glClearDepth(1.0f);
while(1)
{
while(PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
if(msg.message==WM_QUIT)
break;
}
if(gAppState.reloadShaders)
{
sh.CreateFromFile("data\\model.vs", "data\\model.fs");
gAppState.reloadShaders=false;
glVertexAttribPointer(glGetAttribLocation(sh.GetPName(), "i_pos"), 3, GL_FLOAT, GL_FALSE, 4*16, (void*)(0*4));
glVertexAttribPointer(glGetAttribLocation(sh.GetPName(), "i_nor"), 3, GL_FLOAT, GL_FALSE, 4*16, (void*)(3*4));
glVertexAttribPointer(glGetAttribLocation(sh.GetPName(), "i_tan"), 3, GL_FLOAT, GL_FALSE, 4*16, (void*)(10*4));
glVertexAttribPointer(glGetAttribLocation(sh.GetPName(), "i_bin"), 3, GL_FLOAT, GL_FALSE, 4*16, (void*)(13*4));
glVertexAttribPointer(glGetAttribLocation(sh.GetPName(), "i_tex"), 2, GL_FLOAT, GL_FALSE, 4*16, (void*)(6*4));
}
glProgramUniform1i(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"sTex"), 0);
glProgramUniform1i(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"sNor"), 1);
float4x4 wm;
wm=float4x4::Scale(0.05)
*float4x4::RotY(-sin(mpx), cos(mpx))
*float4x4::RotX(-1, 0)
*float4x4::RotX(-sin(mpy*0.3), cos(mpy*0.3))
;
float fov=1.3;
float camrx=(mx-W/2.0f)/5000.0;
float camry=(my-H/2.0f)/5000.0;
float4x4 vpm=float4x4::Projection(0.25, 2000, fov, H/(float)W*fov).Transposed()
*float4x4::Translation(0, 0, dz)
*float4x4::RotY(0, -1)
*float4x4::RotX(sin(camry), cos(camry))
*float4x4::RotY(-sin(camrx), cos(camrx))
;
glProgramUniformMatrix4fv(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"u_wm" ), 1, false, &wm.m00);
glProgramUniformMatrix4fv(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"u_vpm"), 1, false, &vpm.m00);
double time=timer.GetTime();
float lightPos0[3]={sin(time),0.5, cos(time)};
float lightPos1[3]={sin(-time*0.5),-0.5, cos(time*0.5)};;
float lightPos2[3]={camrx*70, camry*70, -3};
float lightCol0[3]={1.0,0.7,0.3};
float lightCol1[3]={0.3,0.7,1.0};
float lightCol2[3]={1.0,1.0,1.0};
glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightPos0"), lightPos0[0], lightPos0[1], lightPos0[2]);
glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightPos1"), lightPos1[0], lightPos1[1], lightPos1[2]);
glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightPos2"), lightPos2[0], lightPos2[1], lightPos2[2]);
glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightCol0"), lightCol0[0], lightCol0[1], lightCol0[2]);
glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightCol1"), lightCol1[0], lightCol1[1], lightCol1[2]);
glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightCol2"), lightCol2[0], lightCol2[1], lightCol2[2]);
glDepthMask(true);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
sh.Use();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, body_tex);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, body_norm);
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
glDrawElements(GL_TRIANGLES, (4340*3), GL_UNSIGNED_INT, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, fur_tex);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, fur_norm);
glDepthMask(false);
glEnable(GL_BLEND);
glDisable(GL_CULL_FACE);
glDrawElements(GL_TRIANGLES, indexcount-(4340*3), GL_UNSIGNED_INT, (void*)(4340*3*4));
GL.FrameEnd();
if(msg.message==WM_QUIT)
break;
if(gAppState.quitRequested)
break;
Sleep(10); // prevent 100% CPU consuming
}
return 0;
};
int main( int argc, char** argv )
{
std::cout << "Starting..\n";
std::vector<std::string> file_names;
parse_args(argc, argv, file_names);
file_names.push_back(std::string("b0e0.hgt"));
InitGraphics();
glfwSetWindowTitle( "p7" );
// Ensure we can capture the escape key being pressed below
glfwEnable( GLFW_STICKY_KEYS );
// Dark blue background
glClearColor(0.7f, 0.7f, 0.7f, 0.0f);
// Enable depth test
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LESS);
// glFrontFace(GL_CCW);
// Create and compile our GLSL program from the shaders
GLuint programIDs[2] = { LoadShaders( "tvs.vertexshader", "cfs.fragmentshader" ), LoadShaders( "tvs2.vertexshader", "cfs.fragmentshader" )};
std::cout << "Linked shaders..\n";
// Get a handle for our "MVP" uniform
GLuint MatrixIDs[2] = {glGetUniformLocation(programIDs[0], "MVP"), glGetUniformLocation(programIDs[1], "MVP")};
GLuint EdgexIDs[2] = {glGetUniformLocation(programIDs[0], "Edgex"), glGetUniformLocation(programIDs[1], "Edgex")};
GLuint EdgeyIDs[2] = {glGetUniformLocation(programIDs[0], "Edgey"), glGetUniformLocation(programIDs[1], "Edgey")};
GLuint HeightIDs[2] = {glGetUniformLocation(programIDs[0], "height"), glGetUniformLocation(programIDs[1], "height")};
GLuint TextureIDs[2] = {glGetUniformLocation(programIDs[0], "tex2d"), glGetUniformLocation(programIDs[1], "tex2d")};
GLuint TimeIDs[2] = {glGetUniformLocation(programIDs[0], "time"), glGetUniformLocation(programIDs[1], "time")};
GLuint AlphaIDs[2] = {glGetUniformLocation(programIDs[0], "alpha"), glGetUniformLocation(programIDs[1], "alpha")};
std::cout << "Got uniforms..\n";
std::cout << glGetString(GL_VERSION) << std::endl;
std::cout << "Loadin textures...\n";
char texName[] = "texture3.jpg";
std::cout << texName << std::endl;
int t1x,t1y,t1comp;
FILE* t1f = fopen(texName, "rb");
unsigned char* tex1data = stbi_load_from_file(t1f, &t1x, &t1y, &t1comp,0);
unsigned int tex_2d;
glGenTextures(1, &tex_2d);
glBindTexture(GL_TEXTURE_2D, tex_2d);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, t1x, t1y, 0, GL_RGB, GL_UNSIGNED_BYTE, tex1data);
/*
char texNameCl[] = "textureClouds3.png";
std::cout << texNameCl << std::endl;
int t2x,t2y,t2comp;
FILE* t2f = fopen(texNameCl, "rb");
unsigned char* tex2data = stbi_load_from_file (t2f, &t2x, &t2y, &t2comp,0);
unsigned int tex_cl;
glGenTextures(1, &tex_cl);
glBindTexture(GL_TEXTURE_2D, tex_cl);
//-->
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, t2x, t2y, 0, GL_RGB, GL_UNSIGNED_BYTE, tex2data);
*/
std::cout << "Done!\n";
const int side(1201);
const int vBOsize(file_names.size());
//Vertices:
short piece_map[360][181];
for(int i=0; i<360; i++)
for(int y=0; y<=180; y++)
piece_map[i][y] = -1;
unsigned int numberOfVertices=side*side;
GLuint vaoObjects[vBOsize+1], vertexBufferObject, vBOs[vBOsize+1];
std::vector<std::pair<int, int> > edges(vBOsize+1);
// -->
std::cout << "Generating arrays...\n";
glGenVertexArrays(vBOsize, vaoObjects);
std::cout << "Done\n";
glGenBuffers(vBOsize, vBOs);
int height;
// <---
for(short i=0; i< vBOsize; i++)
{
std::vector< int > vertexPositionsVec(3*numberOfVertices);
int* vertexPositions = &vertexPositionsVec[0];
loadVertices(file_names[i], vertexPositionsVec, true, side, edges[i], height);
glBindVertexArray(vaoObjects[i]);
glBindBuffer(GL_ARRAY_BUFFER, vBOs[i]);
glVertexAttribPointer(
0, // attribute. No particular reason for 0, but must match the layout in the shader.
3, // size
GL_INT, // type
GL_FALSE, // normalized?
0, // stride
(void*)0 // array buffer offset
);
glBufferData(GL_ARRAY_BUFFER, sizeof(int)*3*numberOfVertices, vertexPositions, GL_STATIC_DRAW);
if(i<vBOsize-1)
{
piece_map[edges[i].second+180][edges[i].first+90]=i;
std::cout << edges[i].second+180 << " " << edges[i].first+90 << std::endl;
}
}
//Indices::
GLuint indexBufferObject, iBOs[maxLoD], numberOfIndices;
std::vector<GLuint> nOIs(maxLoD);
glGenBuffers(maxLoD, iBOs);
for(unsigned int density=1, i=0; i<maxLoD; i++, density*=2)
{
std::cout << "Entering for with i: " << i << "\n";
nOIs[i]=(side-1)/density;
if((side-1)%density!=0)
nOIs[i]+=1;
nOIs[i]=6*(nOIs[i]*(nOIs[i]));
std::cout << "Allocating memory...\n";
GLuint* indices = new GLuint [nOIs[i]];
std::cout << "Done.\n";
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iBOs[i]);
std::cout << "Density: " << density << " Number of indices: " << nOIs[i] << std::endl;
genIndices(indices, side, density);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*nOIs[i], indices, GL_STATIC_DRAW);
std::cout << "Leaving for with i: " << i << "\n";
}
// Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
glm::mat4 Projection =
// glm::mat4(1.0f);
glm::perspective(45.0f, 4.0f / 3.0f, 100.f, 30000.0f);
// Camera matrix
// int xVw = edges[0].first*side, yVw = edges[0].second*side;
int xVw = 6000, yVw = -6000;
height = 3000;
glm::mat4 View = glm::lookAt(
glm::vec3(xVw,yVw,2*height), // Camera is at (4,3,-3), in World Space
glm::vec3(xVw,yVw,0), // and looks at the origin
glm::vec3(0,1,0) // Head is up (set to 0,-1,0 to look upside-down)
);
// Model matrix : an identity matrix (model will be at the origin)
glm::mat4 Model = glm::mat4(1.0f);
// Our ModelViewProjection : multiplication of our 3 matrices
glm::mat4 MVP = Projection * View * Model; // Remember, matrix multiplication is the other way around
std::cout << "Init done.\n";
glfwSetKeyCallback(Key_Callback);
double last_time = glfwGetTime(), last_reset=last_time;
int FPScounter=0;
x = edges[0].second*12010;
startx=x;
y = edges[0].first*12010;
starty=y;
std::cout << edges[0].first << " " << edges[0].second << std::endl;
do {
int ex = x/12010+180;
int ey = y/12010+90;
//time statistics:
FPScounter++;
double cur_time = glfwGetTime();
if(cur_time-last_reset>=2)
{
double FPS = (float)FPScounter/(cur_time-last_reset);
std::cout << "FPS: " << FPS << " lod: " << iBOindex << std::endl;
std::cout << ex << " " << ey << " " << alpha << std::endl;
if(autolod && abs(FPS-optfps)>4)
{
if(FPS<optfps && iBOindex<maxLoD)
iBOindex++;
if(FPS>4*optfps && iBOindex > 0)
iBOindex--;
}
FPScounter=0;
last_reset=cur_time;
}
last_time=cur_time;
// Clear the screen
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Use our shader
glUseProgram(programIDs[ball]);
glm::mat4 Vw;
// Send our transformation to the currently bound shader,
// in the "MVP" uniform
Vw=MVP * glm::translate( mat4(1.0),vec3((-x + 6000)*ball,(-y - 6000)*ball,(z - 12000)*ball))
* glm::rotate(mat4(1.0), oz, glm::vec3(0,1,0))
* glm::rotate(mat4(1.0), ox, glm::vec3(1,0,0))
* glm::rotate(mat4(1.0), oy, glm::vec3(0,0,1))
* glm::translate( mat4(1.0), vec3(-x*(1-ball), -y*(1-ball), z*(1-ball)));
glUniformMatrix4fv(MatrixIDs[ball], 1, GL_FALSE, &Vw[0][0]);
glUniform1i(HeightIDs[ball], 0);
glUniform1f(TimeIDs[ball], glfwGetTime());
glUniform1f(AlphaIDs[ball], (float)alpha*0.1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex_2d);
glUniform1i(TextureIDs[ball], /*GL_TEXTURE0+*/0);
indexBufferObject=iBOs[iBOindex];
numberOfIndices=nOIs[iBOindex];
// std::cout << ex << " " << ey << std::endl;
if(ball==0)
{
glCullFace(GL_FRONT);
for(int i = max(ex-3,0); i<= min(ex+3,360) ; i++)
for(int j=max(ey-3,0); j<= min(ey+3,180); j++)
{
glUniform1i(EdgexIDs[ball], (i-180));
glUniform1i(EdgeyIDs[ball], (j-90));
int point;
if(piece_map[i][j]==-1)
{
point=vBOsize-1;
draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]);
}
else
{
point = piece_map[i][j];
draw(vaoObjects[point], vBOs[point], indexBufferObject, numberOfIndices);
}
// std::cout << "Drawing " << file_names[point] << "with mods " << i-180 << " " << j-90 << std::endl
// << i << " " << ex << " " << j << " " << ey << std::endl;
}
}
else
{
glCullFace(GL_FRONT);
for(int i=/*edges[0].second+180+*/0; i</*edges[0].second+18*/360; i++)
for(int j=/*edges[0].first+90+*/0; j<=/*edges[0].first+90*/180; j++)
{
glUniform1i(EdgexIDs[ball], (i-180));
glUniform1i(EdgeyIDs[ball], (j-90));
int point;
if(piece_map[i][j]==-1)
{
point=vBOsize-1;
draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]);
}
else
{
point = piece_map[i][j];
draw(vaoObjects[point], vBOs[point], indexBufferObject, numberOfIndices);
}
}
}
//CLOUDS
/*
Vw=MVP * glm::translate( mat4(1.0),vec3((-x + 6000)*ball,(-y - 6000)*ball,(z - 12000)*ball))
* glm::rotate(mat4(1.0), oz+(float)glfwGetTime(), glm::vec3(0,1,0))
* glm::rotate(mat4(1.0), ox, glm::vec3(1,0,0))
* glm::rotate(mat4(1.0), oy, glm::vec3(0,0,1))
* glm::translate( mat4(1.0), vec3(-x*(1-ball), -y*(1-ball), z*(1-ball)));
glUniformMatrix4fv(MatrixIDs[ball], 1, GL_FALSE, &Vw[0][0]);
glUniform1i(HeightIDs[ball], 100);
glUniform1f(TimeIDs[ball], glfwGetTime());
glUniform1f(AlphaIDs[ball], 0.25);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex_cl);
glUniform1i(TextureIDs[ball], 0);
indexBufferObject=iBOs[iBOindex];
numberOfIndices=nOIs[iBOindex];
// std::cout << ex << " " << ey << std::endl;
if(ball==0)
{
glCullFace(GL_FRONT);
for(int i = max(ex-3,0); i<= min(ex+3,360) ;i++)
for(int j=max(ey-3,0); j<= min(ey+3,180); j++)
{
glUniform1i(EdgexIDs[ball], (i-180));
glUniform1i(EdgeyIDs[ball], (j-90));
int point;
{
point=vBOsize-1;
draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]);
}
}
}
else
{
glCullFace(GL_FRONT);
for(int i=0; i<360;i++)
for(int j=0; j<=180;j++)
{
glUniform1i(EdgexIDs[ball], (i-180));
glUniform1i(EdgeyIDs[ball], (j-90));
int point;
{
point=vBOsize-1;
draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]);
}
}
}*/
// Swap buffers
glfwSwapBuffers();
} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
glfwGetWindowParam( GLFW_OPENED ) );
// Cleanup VBO and shader
glDeleteProgram(programIDs[0]);
glDeleteProgram(programIDs[1]);
// CleanVBOs(vaoObjects, vBOs, vBOsize+1, iBOs, tex_2d);
std::cout << "Cleaning done, terminating..\n";
// Close OpenGL window and terminate GLFW
glfwTerminate();
return 0;
}
void GlRasterStateInterface::BindRasterState( SRasterState const &refNewState, bool bForce )
{
bForce = true;
SRasterState rNewState = refNewState;
SRasterState overridden;
GetOverrideMergedRasterState(rNewState, overridden);
SRasterState &rLast = mLastState;
bool bAlphaTestChanged = ( overridden.GetAlphaTest() != rLast.GetAlphaTest() );
// bool bTextureModeChanged = ( overridden.GetTextureMode() != rLast.GetTextureMode() );
// bool bTextureActiveChanged = ( overridden.GetTextureActive()!= rLast.GetTextureActive() );
bool bBlendingChanged = ( overridden.GetBlending() != rLast.GetBlending() );
bool bDepthTestChanged = ( overridden.GetDepthTest() != rLast.GetDepthTest() );
//bool bStencilModeChanged = ( overridden.GetStencilID() != rLast.GetStencilID() );
bool bShadeModelChanged = ( overridden.GetShadeModel() != rLast.GetShadeModel() );
bool bCullTestChanged = ( overridden.GetCullTest() != rLast.GetCullTest() );
bool bScissorTestChanged = ( overridden.GetScissorTest() != rLast.GetScissorTest() );
GL_ERRORCHECK();
if( true )
{
glDisable( GL_CULL_FACE );
}
else if( bCullTestChanged || bForce )
{
switch( overridden.GetCullTest() )
{
case ECULLTEST_OFF:
glDisable( GL_CULL_FACE );
break;
case ECULLTEST_PASS_FRONT:
glCullFace( GL_BACK );
glFrontFace( GL_CCW );
glEnable( GL_CULL_FACE );
break;
case ECULLTEST_PASS_BACK:
glCullFace( GL_FRONT );
glFrontFace( GL_CCW );
glEnable( GL_CULL_FACE );
break;
}
}
//////////////////////////////
/*#if( _BUILD_LEVEL > 1 )
if( IsPickState() )
{
bBlendingChanged = true;
bDepthTestChanged = true;
bShadeModelChanged = true;
//bTextureModeChanged = true;
bAlphaTestChanged = true;
overridden.SetBlending( EBLENDING_OFF );
overridden.SetAlphaTest( EALPHATEST_OFF, 0 );
overridden.SetDepthTest( EDEPTHTEST_LEQUALS );
overridden.SetShadeModel( ESHADEMODEL_FLAT );
//overridden.SetTextureMode( ETEXMODE_OFF );
}
#endif*/
//////////////////////////////
GL_ERRORCHECK();
/////////////////////////////////////////////////
glDepthMask( overridden.GetZWriteMask() );
glColorMask( overridden.GetRGBWriteMask(), overridden.GetRGBWriteMask(), overridden.GetRGBWriteMask(), overridden.GetAWriteMask() );
// glDepthMask( GL_TRUE );
// glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
/////////////////////////////////////////////////
if( true )
{
glDisable( GL_STENCIL_TEST );
}
/////////////////////////////////////////////////
// Win32 GL Alpha
if( false )
{
//glDisable( GL_ALPHA_TEST );
}
else if( bAlphaTestChanged || bForce )
{
static const F32 frecip = 1.0f / 15.0f;
F32 fAlphaRef = frecip * (F32) overridden.muAlphaRef;
switch( overridden.muAlphaTest )
{ case EALPHATEST_OFF:
//glDisable( GL_ALPHA_TEST );
GL_ERRORCHECK();
break;
case EALPHATEST_GREATER:
//glEnable( GL_ALPHA_TEST );
//glAlphaFunc( GL_GREATER, fAlphaRef );
GL_ERRORCHECK();
break;
case EALPHATEST_LESS:
//glEnable( GL_ALPHA_TEST );
//glAlphaFunc( GL_LESS, fAlphaRef );
GL_ERRORCHECK();
break;
}
}
/////////////////////////////////////////////////
// Win32 GL Depth
if( false )
{
glDisable( GL_DEPTH_TEST );
}
else if( bDepthTestChanged || bForce )
{
GL_ERRORCHECK();
switch( overridden.GetDepthTest() )
{
case EDEPTHTEST_OFF:
glDisable( GL_DEPTH_TEST );
break;
case EDEPTHTEST_LESS:
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_LESS );
break;
case EDEPTHTEST_LEQUALS:
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_LEQUAL );
break;
case EDEPTHTEST_GREATER:
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_GREATER );
break;
case EDEPTHTEST_GEQUALS:
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_GEQUAL );
break;
case EDEPTHTEST_EQUALS:
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_EQUAL );
break;
case EDEPTHTEST_ALWAYS:
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_ALWAYS );
break;
default:
OrkAssert( false );
break;
}
GL_ERRORCHECK();
}
/////////////////////////////////////////////////
if( false )
{
glDisable( GL_SCISSOR_TEST );
}
else if( bScissorTestChanged || bForce )
{
GL_ERRORCHECK();
switch( overridden.GetScissorTest() )
{
case ESCISSORTEST_OFF:
// glDisable( GL_SCISSOR_TEST );
break;
case ESCISSORTEST_ON:
// glEnable( GL_SCISSOR_TEST );
break;
}
GL_ERRORCHECK();
}
/////////////////////////////////////////////////
if( false )
{
glDisable( GL_BLEND );
}
else if( bBlendingChanged || bForce )
{
//glDisable( GL_BLEND );
//glEnable( GL_BLEND );
//glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
switch( overridden.GetBlending() )
{
case EBLENDING_OFF:
glDisable( GL_BLEND );
break;
case EBLENDING_DSTALPHA:
glEnable( GL_BLEND );
glBlendFunc( GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA );
break;
case EBLENDING_ALPHA:
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
//glBlendFunc( GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA );
break;
case EBLENDING_ADDITIVE:
glEnable( GL_BLEND );
glBlendFunc( GL_ONE, GL_ONE );
break;
case EBLENDING_SUBTRACTIVE:
glEnable( GL_BLEND );
glBlendFunc( GL_ZERO, GL_ONE_MINUS_SRC_COLOR );
break;
case EBLENDING_ALPHA_ADDITIVE:
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE );
break;
case EBLENDING_ALPHA_SUBTRACTIVE:
glEnable( GL_BLEND );
glBlendFunc( GL_ZERO, GL_ONE_MINUS_SRC_ALPHA );
break;
case EBLENDING_MODULATE:
glEnable( GL_BLEND );
glBlendFunc( GL_ZERO, GL_SRC_ALPHA );
break;
default :
OrkAssert( false );
break;
}
}
GL_ERRORCHECK();
if( false )
{
//glShadeModel( GL_FLAT );
}
else if( bShadeModelChanged || bForce )
{
switch( overridden.GetShadeModel() )
{
case ESHADEMODEL_FLAT:
//glShadeModel( GL_FLAT );
break;
case ESHADEMODEL_SMOOTH:
//glShadeModel( GL_SMOOTH );
break;
default:
break;
}
}
GL_ERRORCHECK();
u32 upolyoffset = overridden.GetPolyOffset();
if( false ) //0 == upolyoffset )
{
glDisable( GL_POLYGON_OFFSET_FILL );
}
else
{
glEnable( GL_POLYGON_OFFSET_FILL );
glPolygonOffset( -1.0f, float(upolyoffset) );
}
}
void app_update_and_render(App *app)
{
app->current_scene = (int)(app->elapsed_time / 20.0f) % NUM_SCENES;
Scene scene = app->scenes[app->current_scene];
float model_scale = animate_model_scale(app->elapsed_time);
float aspect_ratio = app->window_width / (float)app->window_height;
mat4 mat_projection = perspective(scene.fov, aspect_ratio, scene.z_near, scene.z_far);
mat4 mat_cube_model = rotateX(PI / 2.0f) * scale(model_scale);
mat4 mat_view = animate_camera(app->elapsed_time);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDepthRangef(0.0, 1.0);
glClearDepthf(1.0f);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendEquation(GL_FUNC_ADD);
////////////////
// Draw backdrop
glDepthMask(GL_FALSE);
glUseProgram(app->program_backdrop);
glBindBuffer(GL_ARRAY_BUFFER, app->vbo_quad);
attribfv(backdrop, position, 2, 0);
uniform3fv(backdrop, sun_dir, scene.sun_dir);
uniform2f(backdrop, screen_size, app->window_width, app->window_height);
uniform1f(backdrop, inv_tan_fov, 1.0f / (scene.fov / 2.0f));
uniformm4(backdrop, view, mat_view);
glDrawArrays(GL_TRIANGLES, 0, 6);
glDepthMask(GL_TRUE);
//////////////////////////
// Draw tessellated sphere
glUseProgram(app->program_mapping);
glBindBuffer(GL_ARRAY_BUFFER, app->vbo_cube);
attribfv(mapping, position, 3, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, scene.heightmap);
uniform1i(mapping, heightmap, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_CUBE_MAP, scene.diffusemap);
uniform1i(mapping, diffusemap, 1);
uniform1f(mapping, height_scale, scene.height_scale);
uniform1f(mapping, use_mip, scene.use_mip ? 1.0f : 0.0f);
uniform1f(mapping, max_lod_coverage, scene.max_lod_coverage);
uniform2f(mapping, screen_size, app->window_width, app->window_height);
uniformm4(mapping, model, mat_cube_model);
uniformm4(mapping, view, mat_view);
uniformm4(mapping, projection, mat_projection);
glPatchParameteri(GL_PATCH_VERTICES, VERTICES_PER_PATCH);
glDrawArrays(GL_PATCHES, 0, NUM_PATCHES * VERTICES_PER_PATCH);
}
void drawCam(Player *p, PlayerVisual* pV) {
int i;
float up[3] = { 0, 0, 1 };
Visual *d = & pV->display;
float reflectivity = getReflectivity();
// compute shadow color based on glocal constant & reflectivity
for(i = 0; i < 4; i++)
gCurrentShadowColor[i] = gShadowColor[i] * (1 - reflectivity);
glColor3f(0.0, 1.0, 0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
doPerspective(gSettingsCache.fov, (float) d->vp_w / (float) d->vp_h,
gSettingsCache.znear, box2_Diameter(& game2->level->boundingBox) * 6.5f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
doLookAt(p->camera->cam, p->camera->target, up);
glDisable(GL_LIGHTING); // initial config at frame start
glDisable(GL_BLEND); // initial config at frame start
// disable writes to alpha
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
/* skybox */
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f );
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
/* skybox done */
/* floor */
if(reflectivity == 0) {
// draw floor to fb and stencil (set to 1),
// using alpha-blending
// TODO: draw floor alpha to fb
video_Shader_Setup(& gWorld->floor_shader);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
glStencilFunc(GL_ALWAYS, 1, 255);
glEnable(GL_STENCIL_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
nebu_Mesh_DrawGeometry( gWorld->floor );
glDisable(GL_BLEND);
glDisable(GL_STENCIL_TEST);
video_Shader_Cleanup(& gWorld->floor_shader);
} else {
/* reflections */
/* first draw reflector to stencil */
/* and reflector alpha to fb */
video_Shader_Setup(& gWorld->floor_shader);
// store only reflector alpha in framebuffer
glDepthMask(GL_FALSE);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
glStencilFunc(GL_ALWAYS, 1, 255);
glEnable(GL_STENCIL_TEST);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
// glEnable(GL_ALPHA_TEST);
// glAlphaFunc(GL_GREATER, 0.1f);
nebu_Mesh_DrawGeometry( gWorld->floor );
// glDisable(GL_ALPHA_TEST);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDepthMask(GL_TRUE);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilFunc(GL_EQUAL, 1, 255);
video_Shader_Cleanup(& gWorld->floor_shader);
/* then draw world & skybox reflected, where stencil is set */
/* protect the alpha buffer */
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
isRenderingReflection = 1; // hack: reverse lighting
glPushMatrix();
glScalef(1,1,-1);
glCullFace(GL_FRONT); // reverse culling
// clip skybox & world to floor plane
glEnable(GL_CLIP_PLANE0);
{
double plane[] = { 0, 0, 1, 0 };
glClipPlane(GL_CLIP_PLANE0, plane);
}
drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f );
drawWorld(p, pV);
glDisable(GL_CLIP_PLANE0);
glCullFace(GL_BACK);
glPopMatrix();
isRenderingReflection = 0; // hack: normal lighting
/* then blend the skybox into the scene, where stencil is set */
/* modulate with the destination alpha */
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f );
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
/* then blend reflector into the scene */
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1, 1, 1, 1 - reflectivity);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilFunc(GL_ALWAYS, 1, 255);
video_Shader_Setup(& gWorld->floor_shader);
nebu_Mesh_DrawGeometry( gWorld->floor );
video_Shader_Cleanup(& gWorld->floor_shader);
glDisable(GL_STENCIL_TEST);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
}
/* floor done */
/* planar shadows */
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
if(reflectivity != 1) // there are no shadows on perfect mirrors
drawPlanarShadows(p);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
/* planar shadows done */
drawWorld(p, pV);
/* transparent stuff */
/* draw the glow around the other players: */
if (gSettingsCache.show_glow == 1) {
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
for (i = 0; i < game->players; i++)
{
if (p != game->player + i && PLAYER_IS_ACTIVE(game->player + i))
{
drawGlow(p->camera, game->player + i, gPlayerVisuals + i,
d, TRAIL_HEIGHT * 4);
}
}
glDisable(GL_BLEND);
}
}
/*!****************************************************************************
@Function InitView
@Return bool true if no error occured
@Description Code in InitView() will be called by PVRShell upon
initialization or after a change in the rendering context.
Used to initialize variables that are dependant on the rendering
context (e.g. textures, vertex buffers, etc.)
******************************************************************************/
bool OGLES2LightMap::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
m_Models[0].LoadVbos();
m_Models[1].LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Clamp the shadow texture to edge (not repeat).
glBindTexture(GL_TEXTURE_2D, m_uiShadowTex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Set the sampler2D uniforms to corresponding texture units
glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sBasetex"), 0);
glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sReflect"), 1);
glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sShadow"), 2);
// Is the scene rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Calculate the projection and view matrices
*/
m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), CAM_NEAR, CAM_FAR, PVRTMat4::OGL, bRotate);
m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 150), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0));
// Defines the shadow matrix and stores it, shadow matrix for shadow texture mapping
PVRTVec3 vLightFrom = PVRTVec3( 85, -85, 100);
PVRTVec3 vLightTo = PVRTVec3(0, 0, -25);
PVRTVec3 vLightUp = PVRTVec3(0, 1, 0);
m_mShadowViewProj = PVRTMat4::LookAtRH(vLightFrom, vLightTo, vLightUp);
// Project the shadow from a point (near and far clipping plane are not important here)
PVRTMat4 mShadowProj;
mShadowProj = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, 1, 1, 2, PVRTMat4::OGL);
m_mShadowViewProj = mShadowProj * m_mShadowViewProj;
glUniformMatrix4fv(m_ShaderProgram.auiLoc[eShadowProj], 1, GL_FALSE, m_mShadowViewProj.ptr());
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
return true;
}
void SCSChannelManagerAlphaOnly::merge() {
bool isFixedFunction = true;
setupProjectiveTexture(isFixedFunction);
glEnable(GL_ALPHA_TEST);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glDepthMask(GL_TRUE);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
std::vector<Channel> channels = occupied();
for (std::vector<Channel>::const_iterator c = channels.begin(); c!=channels.end(); ++c) {
setupTexEnv(*c);
scissor->recall(*c);
scissor->enableScissor();
const std::vector<Primitive*> primitives = getPrimitives(*c);
for (std::vector<Primitive*>::const_iterator j = primitives.begin(); j != primitives.end(); ++j) {
glCullFace((*j)->getOperation() == Intersection ? GL_BACK : GL_FRONT);
RenderData* primitiveData = getRenderData(*j);
GLubyte id = primitiveData->bufferId.a;
// Here is an interesting bug, which happened on an ATI HD4670, but actually
// might happen on every hardware. I am not sure whether it can be solved
// correctly.
// Problem is that in optimized mode with some compilers (VC6, Visual Studio 2003
// in particular), when setting the alpha func as follows:
// glAlphaFunc(GL_EQUAL, static_cast<float>(id) / 255.0f);
// the division is optimized as multiplication with 1.0f/255.0f.
// This is a fine and valid optimization. Unfortunately, the results
// are not exactly the same as the direct division for some ids.
// Which is apparently what the ATI driver is doing internally.
// So with comparison with GL_EQUAL fails.
// Fortunately the OpenGL standard enforces that the mapping of color byte
// values to float fragment values be done by division. So if the
// solution found below (just working at double precision) proves
// to work once, it should work forever, such that a precompiling
// lookup table containing the correct alpha reference values is
// not required. However a bad feeling remains.
// The SCSChannelManagerFragmentProgram path implemented below should fix this.
double alpha = static_cast<double>(id) / 255.0;
GLfloat fAlpha = static_cast<float>(alpha);
glAlphaFunc(GL_EQUAL, fAlpha);
(*j)->render();
}
}
scissor->disableScissor();
glDisable(GL_ALPHA_TEST);
glDisable(GL_CULL_FACE);
glDepthFunc(GL_LEQUAL);
resetProjectiveTexture(isFixedFunction);
clear();
}
void display(){
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glViewport(0, 0, glwidth, glheight);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(1.5, (double)glwidth / (double)glheight, 1.0, 1000.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(150.0,100.0,-200.0,
0.0,0.0,0.0,
0.0,1.0,0.0);
glMultMatrixd(Rotate);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, gold_diff);
glPushMatrix();
glTranslated(sin(t),cos(t),-3.);
glRotatef(90, 1.0f, 0.0f, 0.0f);
glutSolidSphere(.3,20,20);
glPopMatrix();
glutSolidSphere(1.5,20,20);
glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, red_light);
if(!colormask_on){
glColorMask(0,0,0,0);
glDepthMask(0);
}
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_STENCIL_TEST);
glStencilMask(~0);
if(frontcull){
glCullFace(GL_FRONT);
glStencilFunc(GL_ALWAYS, 1, ~0);
glStencilOp(GL_REPLACE, GL_KEEP, GL_REPLACE);
/* glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); */
/* glStencilOp(GL_KEEP, GL_INCR, GL_KEEP); */
glPushMatrix();
glTranslated(sin(t),cos(t),-3);
glRotatef(90, 1.0f, 0.0f, 0.0f);
/* glRotatef(90, 0.0f, 0.0f, 1.0f); */
cylinder(.3,100,20);
glPopMatrix();
}
if(backcull){
glCullFace(GL_BACK);
glStencilFunc(GL_ALWAYS, 1, ~0);
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
/* glStencilOp(GL_KEEP, GL_DECR, GL_KEEP); */
glPushMatrix();
glTranslated(sin(t),cos(t),-3.);
glRotatef(90, 1.0f, 0.0f, 0.0f);
/* glRotatef(90, 0.0f, 0.0f, 1.0f); */
cylinder(.3,100,20);
glPopMatrix();
}
glDisable(GL_CULL_FACE);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDepthMask(GL_TRUE);
glStencilFunc(GL_EQUAL, 1, ~0);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glDisable(GL_DEPTH_TEST);
glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,black_light);
glBegin(GL_QUADS);
glVertex2i(-10, -10);
glVertex2i(-10, 10);
glVertex2i(10, 10);
glVertex2i(10, -10);
glEnd();
glEnable(GL_DEPTH_TEST);
/* glEnable(GL_DEPTH_TEST); */
glDisable(GL_STENCIL_TEST);
console();
t+=1e-2;
glFinish();
glutSwapBuffers();
}
void InitGL( void )//__END_INIT__@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@___BEGIN_INIT__
{
//==========================================================================
#ifdef WIN32
#include "cpp/setPixelFormat.cpp"
#include "headerFiles/glext_Init_B.cpp"
//-------------------------------------
SetVSyncState(true);
#endif
//==========================================================================================================================================================================
//====================================================================================================================
glGenTextures(1, &shadowMap_2D);
glBindTexture(GL_TEXTURE_2D, shadowMap_2D);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GL_BGRA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
//--------------------------------------------------------------------------------------------------------------------
glGenFramebuffers(1, &fboId_2D);
glBindFramebuffer(GL_FRAMEBUFFER, fboId_2D);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, shadowMap_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
//######################################################################################################________SHADERS
//######################################################################################################________SHADERS
//================================================================
//====================================================================================
#include "_MODEL_FOLDERS_/cube/cube_Init.cpp"
//====================================================================================
//===================================================================================================================
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glAlphaFunc(GL_GREATER, 0.1);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
//=====================================================================================================================
}//__END_INIT__@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@___END_INIT__
void PrelightPipeline::DrawLight(const std::shared_ptr<Pass> &pass, const std::shared_ptr<SceneNode> &node)
{
auto light = node->GetComponent<Light>();
auto camPtr = m_CurrentCamera->GetComponent<Camera>();
auto camPos = m_CurrentCamera->GetWorldPosition();
auto mesh = light->GetMesh();
auto worldMatrix = node->GetWorldMatrix();
Shader::Ptr shader = nullptr;
if (light->GetType() == LightType::POINT)
{
float camNear = (camPtr->GetFrustum().GetWorldSpaceCorners()[0] - camPos).Length();
if (SphereBounds(node->GetWorldPosition(), light->GetRadius() + camNear).IsInsideFast(camPos))
{
glDisable(GL_DEPTH_TEST);
glCullFace(GL_FRONT);
}
else
{
glEnable(GL_DEPTH_TEST);
glCullFace(GL_BACK);
}
worldMatrix.AppendScale(Vector4(light->GetRadius(), 0.0f));
shader = pass->GetShader(ShaderType::POINT_LIGHT);
}
else if (light->GetType() == LightType::SPOT)
{
auto coneCenter = node->GetWorldPosition();
auto coneDir = worldMatrix.Multiply(Vector4(0, 1, 0, 0)).Normalized();
float camNear = (camPtr->GetFrustum().GetWorldSpaceCorners()[0] - camPos).Length();
float theta = light->GetOutterAngle() * 0.5f;
float height = light->GetRadius();
float extra = camNear / std::sin(theta);
coneCenter = coneCenter - coneDir * extra;
height += camNear + extra;
if (PointInCone(coneCenter, coneDir, height, theta, camPos))
{
glDisable(GL_DEPTH_TEST);
glCullFace(GL_FRONT);
}
else
{
glEnable(GL_DEPTH_TEST);
glCullFace(GL_BACK);
}
shader = pass->GetShader(ShaderType::SPOT_LIGHT);
}
else
{
glEnable(GL_DEPTH_TEST);
glCullFace(GL_BACK);
shader = pass->GetShader(ShaderType::DIR_LIGHT);
}
if (shader == nullptr)
{
LOGW << "Shader for light " << node->GetName() << " not found!";
return;
}
shader->Bind();
shader->BindCamera(m_CurrentCamera);
shader->BindMatrix(Matrix4::WORLD_MATRIX, worldMatrix);
shader->BindLight(node);
shader->BindMesh(mesh);
for (unsigned int i = 0; i < pass->GetTextureCount(true); i++)
{
auto ptr = pass->GetTextureAt(i, true);
shader->BindTexture(ptr->GetName(), ptr);
}
glDrawElements(GL_TRIANGLES, mesh->Indices.Data.size(), GL_UNSIGNED_INT, 0);
shader->UnBind();
m_DrawCall++;
}
void StateBlock::restore(long stateOverrideBits)
{
CC_ASSERT(_defaultState);
// If there is no state to restore (i.e. no non-default state), do nothing.
// if (_defaultState->_bits == 0)
if ( (stateOverrideBits | _defaultState->_bits) == stateOverrideBits)
{
return;
}
// Restore any state that is not overridden and is not default
if (!(stateOverrideBits & RS_BLEND) && (_defaultState->_bits & RS_BLEND))
{
glEnable(GL_BLEND);
_defaultState->_bits &= ~RS_BLEND;
_defaultState->_blendEnabled = true;
}
if (!(stateOverrideBits & RS_BLEND_FUNC) && (_defaultState->_bits & RS_BLEND_FUNC))
{
GL::blendFunc(GL_ONE, GL_ZERO);
_defaultState->_bits &= ~RS_BLEND_FUNC;
_defaultState->_blendSrc = BLEND_ONE;
_defaultState->_blendDst = BLEND_ZERO;
}
if (!(stateOverrideBits & RS_CULL_FACE) && (_defaultState->_bits & RS_CULL_FACE))
{
glDisable(GL_CULL_FACE);
_defaultState->_bits &= ~RS_CULL_FACE;
_defaultState->_cullFaceEnabled = false;
}
if (!(stateOverrideBits & RS_CULL_FACE_SIDE) && (_defaultState->_bits & RS_CULL_FACE_SIDE))
{
glCullFace((GLenum)GL_BACK);
_defaultState->_bits &= ~RS_CULL_FACE_SIDE;
_defaultState->_cullFaceSide = CULL_FACE_SIDE_BACK;
}
if (!(stateOverrideBits & RS_FRONT_FACE) && (_defaultState->_bits & RS_FRONT_FACE))
{
glFrontFace((GLenum)GL_CCW);
_defaultState->_bits &= ~RS_FRONT_FACE;
_defaultState->_frontFace = FRONT_FACE_CCW;
}
if (!(stateOverrideBits & RS_DEPTH_TEST) && (_defaultState->_bits & RS_DEPTH_TEST))
{
glEnable(GL_DEPTH_TEST);
_defaultState->_bits &= ~RS_DEPTH_TEST;
_defaultState->_depthTestEnabled = true;
}
if (!(stateOverrideBits & RS_DEPTH_WRITE) && (_defaultState->_bits & RS_DEPTH_WRITE))
{
glDepthMask(GL_FALSE);
_defaultState->_bits &= ~RS_DEPTH_WRITE;
_defaultState->_depthWriteEnabled = false;
}
if (!(stateOverrideBits & RS_DEPTH_FUNC) && (_defaultState->_bits & RS_DEPTH_FUNC))
{
glDepthFunc((GLenum)GL_LESS);
_defaultState->_bits &= ~RS_DEPTH_FUNC;
_defaultState->_depthFunction = DEPTH_LESS;
}
// if (!(stateOverrideBits & RS_STENCIL_TEST) && (_defaultState->_bits & RS_STENCIL_TEST))
// {
// glDisable(GL_STENCIL_TEST);
// _defaultState->_bits &= ~RS_STENCIL_TEST;
// _defaultState->_stencilTestEnabled = false;
// }
// if (!(stateOverrideBits & RS_STENCIL_WRITE) && (_defaultState->_bits & RS_STENCIL_WRITE))
// {
// glStencilMask(RS_ALL_ONES);
// _defaultState->_bits &= ~RS_STENCIL_WRITE;
// _defaultState->_stencilWrite = RS_ALL_ONES;
// }
// if (!(stateOverrideBits & RS_STENCIL_FUNC) && (_defaultState->_bits & RS_STENCIL_FUNC))
// {
// glStencilFunc((GLenum)RenderState::STENCIL_ALWAYS, 0, RS_ALL_ONES);
// _defaultState->_bits &= ~RS_STENCIL_FUNC;
// _defaultState->_stencilFunction = RenderState::STENCIL_ALWAYS;
// _defaultState->_stencilFunctionRef = 0;
// _defaultState->_stencilFunctionMask = RS_ALL_ONES;
// }
// if (!(stateOverrideBits & RS_STENCIL_OP) && (_defaultState->_bits & RS_STENCIL_OP))
// {
// glStencilOp((GLenum)RenderState::STENCIL_OP_KEEP, (GLenum)RenderState::STENCIL_OP_KEEP, (GLenum)RenderState::STENCIL_OP_KEEP);
// _defaultState->_bits &= ~RS_STENCIL_OP;
// _defaultState->_stencilOpSfail = RenderState::STENCIL_OP_KEEP;
// _defaultState->_stencilOpDpfail = RenderState::STENCIL_OP_KEEP;
// _defaultState->_stencilOpDppass = RenderState::STENCIL_OP_KEEP;
// }
}
void PrelightPipeline::Execute(const std::shared_ptr<SceneManager> &sceneManager)
{
// pre
m_DrawCall = 0;
m_CurrentCamera = nullptr;
m_CurrentShader = nullptr;
SortPassByIndex();
// find visible nodes, 1 cam 1 query
std::unordered_map<std::string, RenderQuery::Ptr> queries;
for (auto pair : m_PassMap)
{
auto pass = pair.second;
auto camNode = pass->GetCameraNode();
if (camNode == nullptr)
{
LOGW << "Camera for pass " + pass->GetName() + " not found!";
continue;
}
auto it = queries.find(camNode->GetName());
if (it != queries.end())
continue;
RenderQuery::Ptr query = RenderQuery::Create();
sceneManager->GetRenderQuery(camNode->GetComponent<Camera>()->GetFrustum(), query);
query->Sort(camNode->GetWorldPosition(), false);
queries.emplace(camNode->GetName(), query);
}
// draw passes
for (unsigned int i = 0; i < m_SortedPasses.size(); i++)
{
auto passName = m_SortedPasses[i];
auto pass = m_PassMap[passName];
auto drawMode = pass->GetDrawMode();
m_CurrentCamera = pass->GetCameraNode();
m_CurrentShader = pass->GetFirstShader();
if (m_CurrentCamera == nullptr)
continue;
auto query = queries[m_CurrentCamera->GetName()];
pass->Bind();
if (drawMode == DrawMode::RENDERABLE)
{
for (const auto &node : query->OpaqueNodes)
DrawRenderable(pass, node);
}
else if (drawMode == DrawMode::LIGHT)
{
glDepthMask(GL_FALSE);
for (const auto &node : query->LightNodes)
DrawLight(pass, node);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glCullFace(GL_BACK);
}
else
{
DrawQuad(pass);
}
pass->UnBind();
}
// post
m_CurrentCamera = nullptr;
m_CurrentShader = nullptr;
}
void CCTextureFontPage::renderText3D(const char *text, const uint length,
const float x, const float y, const float z,
const float height, const bool centeredX) const
{
#if defined PROFILEON
CCProfiler profile( "CCTextureFontPage::renderText3D()" );
#endif
// TODO: I draw these wrong, please fix me to work with back face culling
glCullFace( GL_FRONT );
ASSERT( length < MAX_TEXT_LENGTH );
bindTexturePage();
// Find out our width so we can center the text
int lineIndex = 0;
CCPoint lineSize[MAX_TEXT_LINES];
static CCPoint charSize[MAX_TEXT_LINES][MAX_TEXT_LENGTH];
int characterIndex = 0;
for( uint i=0; i<length; ++i )
{
char character = text[i];
if( character == '\n' )
{
lineIndex++;
characterIndex = 0;
ASSERT( lineIndex < MAX_TEXT_LINES );
}
else
{
const Letter *letter = getLetter( character );
if( letter != NULL )
{
CCPoint &size = charSize[lineIndex][characterIndex];
size.x = letter->size.width * height;
size.y = letter->size.height * height;
lineSize[lineIndex].x += size.x;
lineSize[lineIndex].y = MAX( lineSize[lineIndex].y, size.y );
characterIndex++;
}
}
}
CCPoint start( x, y );
if( centeredX )
{
start.x -= lineSize[0].x * 0.5f;
}
start.y += lineSize[0].y * 0.5f;
static CCVector3 currentStart, currentEnd;
currentStart.x = start.x;
currentStart.y = start.y;
currentStart.z = -z;
currentEnd.z = z;
CCSetTexCoords( texCoords );
lineIndex = 0;
characterIndex = 0;
for( uint i=0; i<length; ++i )
{
char character = text[i];
if( character == '\n' )
{
currentStart.x = start.x;
currentStart.y -= lineSize[lineIndex].y;
lineIndex++;
characterIndex = 0;
}
else
{
const Letter *letter = getLetter( character );
if( letter != NULL )
{
CCPoint &size = charSize[lineIndex][characterIndex];
// Calculate end point
currentEnd.x = currentStart.x + size.x;
currentEnd.y = currentStart.y - size.y;
texCoords[0] = letter->start.x;
texCoords[1] = letter->start.y;
texCoords[2] = letter->end.x;
texCoords[3] = letter->start.y;
texCoords[4] = letter->start.x;
texCoords[5] = letter->end.y;
texCoords[6] = letter->end.x;
texCoords[7] = letter->end.y;
CCRenderSquare( currentStart, currentEnd );
currentStart.x += size.x;
characterIndex++;
}
}
}
glCullFace( GL_BACK );
}
// ------------------------------------------------------------------------------------------
//! Function would be called on the global initialization step.
//! @returns Non-negative value if the operation succeeded.
GDAPI IResult IGraphicsOpenGL::OnRuntimeInitialize()
{
// _CheckNotInitialized();
ConsoleDevice->Log(GD_DLOG_CAT ": going to initialize graphics devices...");
IResult const _BaseResult = IGraphicsOpenGLPlatform::OnRuntimeInitialize();
if (IFailed(_BaseResult))
return _BaseResult;
// Loading OpenGL core profile methods.
glewExperimental = GL_TRUE;
glewInit();
#if GD_DEBUG
if (GLEW_ARB_debug_output)
{
// We have some good debugging extension running, so we do not need to check for OpenGL
// errors after every single OpenGL API function call.
// http://www.opengl.org/registry/specs/ARB/debug_output.txt
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
glDebugMessageCallbackARB([](GLenum const Source, GLenum const Type, GLuint const ID, GLenum const Severity
, GLsizei const Length, GLchar const* const Message, CHandle const UserParam)
{
CStr glDebugSeverity;
switch (Severity)
{
default: glDebugSeverity = "Unknown severity"; break;
case GL_DEBUG_SEVERITY_HIGH_ARB: glDebugSeverity = "High priority"; break;
case GL_DEBUG_SEVERITY_MEDIUM_ARB: glDebugSeverity = "Medium priority"; break;
case GL_DEBUG_SEVERITY_LOW_ARB: glDebugSeverity = "Low priority"; break;
}
CStr glDebugErrorType;
switch (Type)
{
default: glDebugErrorType = "something"; break;
case GL_DEBUG_TYPE_OTHER_ARB: glDebugErrorType = "other issue"; break;
case GL_DEBUG_TYPE_ERROR_ARB: glDebugErrorType = "error"; break;
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB: glDebugErrorType = "deprecated behavior issue"; break;
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB: glDebugErrorType = "undefined behavior issue"; break;
case GL_DEBUG_TYPE_PORTABILITY_ARB: glDebugErrorType = "portability issue"; break;
case GL_DEBUG_TYPE_PERFORMANCE_ARB: glDebugErrorType = "performance issue"; break;
}
CStr glDebugErrorSource;
switch (Source)
{
default: glDebugErrorSource = "unknown location"; break;
case GL_DEBUG_SOURCE_API_ARB: glDebugErrorSource = "API call"; break;
case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB: glDebugErrorSource = "window system API all"; break;
case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB: glDebugErrorSource = "shader compiler"; break;
case GL_DEBUG_SOURCE_THIRD_PARTY_ARB: glDebugErrorSource = "third party API"; break;
case GL_DEBUG_SOURCE_APPLICATION_ARB: glDebugErrorSource = "application"; break;
case GL_DEBUG_SOURCE_OTHER_ARB: glDebugErrorSource = "other"; break;
}
GD_NOT_USED_L(UserParam, Length);
switch (Severity)
{
default:
case GL_DEBUG_SEVERITY_LOW_ARB: // Possibly, this is not an error: e.g. a log from NVidia driver.
ConsoleDevice->LogFormat(GD_DLOG_CAT ": ... debug callback:\n\t%s %s #%x in %s:\n\t%s"
, glDebugSeverity, glDebugErrorType, ID, glDebugErrorSource, Message
);
break;
case GL_DEBUG_SEVERITY_HIGH_ARB:
case GL_DEBUG_SEVERITY_MEDIUM_ARB: // This is some kind of warning or error.
ConsoleDevice->LogErrorFormat(GD_DLOG_CAT ": ... debug callback:\n\t%s %s #%x in %s:\n\t%s"
, glDebugSeverity, glDebugErrorType, ID, glDebugErrorSource, Message
);
GD_ASSERT_FALSE("Some issue inside OpenGL code.");
// break;
}
}, nullptr);
}
else
{
ConsoleDevice->LogError(GD_DLOG_CAT ": ... no 'ARB_debug_output' extension was found. No log or error checking for OpenGL code "
"would be provided.");
}
#endif // if GD_DEBUG
// Enabling the back-face cooling.
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
// We are using m_Left-handed math and clockwise triangles.
glFrontFace(GL_CW);
// Initially setting up the view-port and depth.
glEnable(GL_DEPTH_TEST);
glClearDepth(1.0f);
glClearColor(0.3f, 0.275f, 1.0f, 1.0f);
glViewport(0, 0, GfxResolutionSelected->Width, GfxResolutionSelected->Height);
ConsoleDevice->Log(GD_DLOG_CAT ": ... initialized.");
return IResult::Ok;
}
int main () {
GLFWwindow* window = NULL;
const GLubyte* renderer;
const GLubyte* version;
GLuint shader_programme;
GLuint vao;
//
// Start OpenGL using helper libraries
// --------------------------------------------------------------------------
if (!glfwInit ()) {
fprintf (stderr, "ERROR: could not start GLFW3\n");
return 1;
}
// change to 3.2 if on Apple OS X
glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint (GLFW_SAMPLES, msaa);
window = glfwCreateWindow (gl_width, gl_height, "Textured Mesh", NULL, NULL);
if (!window) {
fprintf (stderr, "ERROR: opening OS window\n");
return 1;
}
glfwMakeContextCurrent (window);
glewExperimental = GL_TRUE;
glewInit ();
/* get version info */
renderer = glGetString (GL_RENDERER); /* get renderer string */
version = glGetString (GL_VERSION); /* version as a string */
printf ("Renderer: %s\n", renderer);
printf ("OpenGL version supported %s\n", version);
int point_count = 0;
//
// Set up vertex buffers and vertex array object
// --------------------------------------------------------------------------
{
GLfloat* vp = NULL; // array of vertex points
GLfloat* vn = NULL; // array of vertex normals (we haven't used these yet)
GLfloat* vt = NULL; // array of texture coordinates (or these)
//assert (load_obj_file ("cube.obj", vp, vt, vn, point_count));
assert (load_obj_file ("monkey.obj", vp, vt, vn, point_count));
GLuint points_vbo, texcoord_vbo, normal_vbo;
glGenBuffers (1, &points_vbo);
glBindBuffer (GL_ARRAY_BUFFER, points_vbo);
glBufferData (GL_ARRAY_BUFFER, sizeof (float) * 3 * point_count,
vp, GL_STATIC_DRAW);
glGenBuffers (1, &texcoord_vbo);
glBindBuffer (GL_ARRAY_BUFFER, texcoord_vbo);
glBufferData (GL_ARRAY_BUFFER, sizeof (float) * 2 * point_count,
vt, GL_STATIC_DRAW);
glGenBuffers (1, &normal_vbo);
glBindBuffer (GL_ARRAY_BUFFER, normal_vbo);
glBufferData (GL_ARRAY_BUFFER, sizeof (float) * 3 * point_count,
vn, GL_STATIC_DRAW);
glGenVertexArrays (1, &vao);
glBindVertexArray (vao);
glEnableVertexAttribArray (0);
glBindBuffer (GL_ARRAY_BUFFER, points_vbo);
glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray (1);
glBindBuffer (GL_ARRAY_BUFFER, texcoord_vbo);
glVertexAttribPointer (1, 2, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray (2);
glBindBuffer (GL_ARRAY_BUFFER, normal_vbo);
glVertexAttribPointer (2, 3, GL_FLOAT, GL_FALSE, 0, NULL);
free (vp);
free (vn);
free (vt);
}
//
// Load shaders from files
// --------------------------------------------------------------------------
{
char* vertex_shader_str;
char* fragment_shader_str;
// allocate some memory to store shader strings
vertex_shader_str = (char*)malloc (81920);
fragment_shader_str = (char*)malloc (81920);
// load shader strings from text files
assert (parse_file_into_str ("teapot.vert", vertex_shader_str, 81920));
assert (parse_file_into_str ("teapot.frag", fragment_shader_str, 81920));
GLuint vs, fs;
vs = glCreateShader (GL_VERTEX_SHADER);
fs = glCreateShader (GL_FRAGMENT_SHADER);
glShaderSource (vs, 1, (const char**)&vertex_shader_str, NULL);
glShaderSource (fs, 1, (const char**)&fragment_shader_str, NULL);
// free memory
free (vertex_shader_str);
free (fragment_shader_str);
int params = -1;
glCompileShader (vs);
glGetShaderiv (vs, GL_COMPILE_STATUS, ¶ms);
if (GL_TRUE != params) {
printf ("ERROR: GL shader index %i (teapot.vert) did not compile\n", vs);
int max_length = 2048;
int actual_length = 0;
char log[2048];
glGetShaderInfoLog (vs, max_length, &actual_length, log);
printf ("shader info log for GL index %u\n%s\n", vs, log);
}
glCompileShader (fs);
glGetShaderiv (fs, GL_COMPILE_STATUS, ¶ms);
if (GL_TRUE != params) {
printf ("ERROR: GL shader index %i (teapot.frag) did not compile\n", fs);
int max_length = 2048;
int actual_length = 0;
char log[2048];
glGetShaderInfoLog (fs, max_length, &actual_length, log);
printf ("shader info log for GL index %u\n%s\n", vs, log);
}
shader_programme = glCreateProgram ();
glAttachShader (shader_programme, fs);
glAttachShader (shader_programme, vs);
glBindAttribLocation (shader_programme, 0, "vp");
glBindAttribLocation (shader_programme, 1, "vt");
glBindAttribLocation (shader_programme, 2, "vn");
glLinkProgram (shader_programme);
glGetProgramiv (shader_programme, GL_LINK_STATUS, ¶ms);
if (GL_TRUE != params) {
printf ("ERROR: could not link shader programme GL index %u\n", shader_programme);
int max_length = 2048;
int actual_length = 0;
char log[2048];
glGetProgramInfoLog (shader_programme, max_length, &actual_length, log);
printf ("program info log for GL index %u\n%s\n", shader_programme, log);
}
/* TODO NOTE: you should check for errors and print logs after compiling and also linking shaders */
}
//
// Create some matrices
// --------------------------------------------------------------------------
mat4 M, V, P;
M = identity_mat4 ();//scale (identity_mat4 (), vec3 (0.05, 0.05, 0.05));
vec3 cam_pos (0.0, 5.0, 5.0);
vec3 targ_pos (0.0, 0.0, 0.0);
vec3 up = normalise (vec3 (0.0, 1.0, -1.0));
V = look_at (cam_pos, targ_pos, up);
P = perspective (67.0f, (float)gl_width / (float)gl_height, 0.1, 10.0);
int M_loc = glGetUniformLocation (shader_programme, "M");
int V_loc = glGetUniformLocation (shader_programme, "V");
int P_loc = glGetUniformLocation (shader_programme, "P");
int ol_loc = glGetUniformLocation (shader_programme, "ol_mode");
int sm_loc = glGetUniformLocation (shader_programme, "sm_shaded");
// send matrix values to shader immediately
glUseProgram (shader_programme);
glUniformMatrix4fv (M_loc, 1, GL_FALSE, M.m);
glUniformMatrix4fv (V_loc, 1, GL_FALSE, V.m);
glUniformMatrix4fv (P_loc, 1, GL_FALSE, P.m);
glUniform1f (ol_loc, 0.0f);
glUniform1f (sm_loc, 0.0f);
//
// Start rendering
// --------------------------------------------------------------------------
// tell GL to only draw onto a pixel if the fragment is closer to the viewer
glEnable (GL_DEPTH_TEST); // enable depth-testing
glDepthFunc (GL_LESS); // depth-testing interprets a smaller value as "closer"
glDepthFunc (GL_LESS); // depth-testing is to use a "less than" function
glEnable (GL_CULL_FACE); // enable culling of faces
glCullFace (GL_BACK);
glFrontFace (GL_CCW);
glClearColor (0.04, 0.04, 0.75, 1.0);
bool multi_pass = true;
GLuint fb, c_tex, d_tex;;
{
// fb
glGenFramebuffers (1, &fb);
glBindFramebuffer (GL_FRAMEBUFFER, fb);
glGenTextures (1, &c_tex);
glGenTextures (1, &d_tex);
glActiveTexture (GL_TEXTURE0);
glBindTexture (GL_TEXTURE_2D, c_tex);
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, gl_width, gl_height, 0, GL_RGBA,
GL_UNSIGNED_BYTE, NULL);
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);
glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
c_tex, 0);
glBindTexture (GL_TEXTURE_2D, d_tex);
glTexImage2D (GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, gl_width, gl_height, 0,
GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
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);
glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
d_tex, 0);
glBindFramebuffer (GL_FRAMEBUFFER, 0);
}
GLuint quad_vao;
{
float quad_pts[] = {-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0};
GLuint quad_vbo;
glGenBuffers (1, &quad_vbo);
glGenVertexArrays (1, &quad_vao);
glBindVertexArray (quad_vao);
glEnableVertexAttribArray (0);
glBindBuffer (GL_ARRAY_BUFFER, quad_vbo);
glBufferData (GL_ARRAY_BUFFER, 8 * sizeof (float), quad_pts, GL_STATIC_DRAW);
glVertexAttribPointer (0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
}
GLuint post_sp;
{
char* vertex_shader_str;
char* fragment_shader_str;
// allocate some memory to store shader strings
vertex_shader_str = (char*)malloc (81920);
fragment_shader_str = (char*)malloc (81920);
// load shader strings from text files
assert (parse_file_into_str ("post.vert", vertex_shader_str, 81920));
assert (parse_file_into_str ("post.frag", fragment_shader_str, 81920));
GLuint vs, fs;
vs = glCreateShader (GL_VERTEX_SHADER);
fs = glCreateShader (GL_FRAGMENT_SHADER);
glShaderSource (vs, 1, (const char**)&vertex_shader_str, NULL);
glShaderSource (fs, 1, (const char**)&fragment_shader_str, NULL);
// free memory
free (vertex_shader_str);
free (fragment_shader_str);
int params = -1;
glCompileShader (vs);
glGetShaderiv (vs, GL_COMPILE_STATUS, ¶ms);
if (GL_TRUE != params) {
printf ("ERROR: GL shader index %i (post.vert) did not compile\n", vs);
int max_length = 2048;
int actual_length = 0;
char log[2048];
glGetShaderInfoLog (vs, max_length, &actual_length, log);
printf ("shader info log for GL index %u\n%s\n", vs, log);
}
glCompileShader (fs);
glGetShaderiv (fs, GL_COMPILE_STATUS, ¶ms);
if (GL_TRUE != params) {
printf ("ERROR: GL shader index %i (post.frag) did not compile\n", fs);
int max_length = 2048;
int actual_length = 0;
char log[2048];
glGetShaderInfoLog (fs, max_length, &actual_length, log);
printf ("shader info log for GL index %u\n%s\n", vs, log);
}
post_sp = glCreateProgram ();
glAttachShader (post_sp, fs);
glAttachShader (post_sp, vs);
glBindAttribLocation (post_sp, 0, "vp");
glLinkProgram (post_sp);
glGetProgramiv (post_sp, GL_LINK_STATUS, ¶ms);
if (GL_TRUE != params) {
printf ("ERROR: could not link shader programme GL index %u\n", post_sp);
int max_length = 2048;
int actual_length = 0;
char log[2048];
glGetProgramInfoLog (post_sp, max_length, &actual_length, log);
printf ("program info log for GL index %u\n%s\n", post_sp, log);
}
}
double a = 0.0f;
double prev = glfwGetTime ();
while (!glfwWindowShouldClose (window)) {
if (multi_pass) {
glBindFramebuffer (GL_FRAMEBUFFER, fb);
}
glViewport (0, 0, gl_width, gl_height);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glActiveTexture (GL_TEXTURE0);
glBindTexture (GL_TEXTURE_2D, 0);
double curr = glfwGetTime ();
double elapsed = curr - prev;
prev = curr;
glUseProgram (shader_programme);
glBindVertexArray (vao);
a += elapsed * 50.0f;
//float ang = (float)sin (a);
M = rotate_y_deg (identity_mat4 (), a);
glUniformMatrix4fv (M_loc, 1, GL_FALSE, M.m);
glUniform1f (sm_loc, 1.0f); // smooth shaded or not (exception is flat-shaded, they might not be great
// if non-cube anyway due to scaling)
if (!multi_pass) {
glFrontFace (GL_CW);
glUniform1f (ol_loc, 1.0f);
glDrawArrays (GL_TRIANGLES, 0, point_count);
}
glFrontFace (GL_CCW);
glUniform1f (ol_loc, 0.0f);
glDrawArrays (GL_TRIANGLES, 0, point_count);
/* this just updates window events and keyboard input events (not used yet) */
if (multi_pass) {
glFlush ();
glFinish ();
glBindFramebuffer (GL_FRAMEBUFFER, 0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport (0, 0, gl_width, gl_height);
glUseProgram (post_sp);
glActiveTexture (GL_TEXTURE0);
glBindTexture (GL_TEXTURE_2D, d_tex);
glBindVertexArray (quad_vao);
glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
}
glfwPollEvents ();
glfwSwapBuffers (window);
}
return 0;
}
static void drawAllViews(void)
{
const GLfloat light_position[4] = {0.0f, 8.0f, 8.0f, 1.0f};
const GLfloat light_diffuse[4] = {1.0f, 1.0f, 1.0f, 1.0f};
const GLfloat light_specular[4] = {1.0f, 1.0f, 1.0f, 1.0f};
const GLfloat light_ambient[4] = {0.2f, 0.2f, 0.3f, 1.0f};
double aspect;
// Calculate aspect of window
if (height > 0)
aspect = (double) width / (double) height;
else
aspect = 1.0;
// Clear screen
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Enable scissor test
glEnable(GL_SCISSOR_TEST);
// Enable depth test
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
// ** ORTHOGONAL VIEWS **
// For orthogonal views, use wireframe rendering
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// Enable line anti-aliasing
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Setup orthogonal projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-3.0 * aspect, 3.0 * aspect, -3.0, 3.0, 1.0, 50.0);
// Upper left view (TOP VIEW)
glViewport(0, height / 2, width / 2, height / 2);
glScissor(0, height / 2, width / 2, height / 2);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0f, 10.0f, 1e-3f, // Eye-position (above)
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f); // Up-vector
drawGrid(0.5, 12);
drawScene();
// Lower left view (FRONT VIEW)
glViewport(0, 0, width / 2, height / 2);
glScissor(0, 0, width / 2, height / 2);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0f, 0.0f, 10.0f, // Eye-position (in front of)
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f); // Up-vector
drawGrid(0.5, 12);
drawScene();
// Lower right view (SIDE VIEW)
glViewport(width / 2, 0, width / 2, height / 2);
glScissor(width / 2, 0, width / 2, height / 2);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(10.0f, 0.0f, 0.0f, // Eye-position (to the right)
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f); // Up-vector
drawGrid(0.5, 12);
drawScene();
// Disable line anti-aliasing
glDisable(GL_LINE_SMOOTH);
glDisable(GL_BLEND);
// ** PERSPECTIVE VIEW **
// For perspective view, use solid rendering
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Enable face culling (faster rendering)
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
// Setup perspective projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(65.0f, aspect, 1.0f, 50.0f);
// Upper right view (PERSPECTIVE VIEW)
glViewport(width / 2, height / 2, width / 2, height / 2);
glScissor(width / 2, height / 2, width / 2, height / 2);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(3.0f, 1.5f, 3.0f, // Eye-position
0.0f, 0.0f, 0.0f, // View-point
0.0f, 1.0f, 0.0f); // Up-vector
// Configure and enable light source 1
glLightfv(GL_LIGHT1, GL_POSITION, light_position);
glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular);
glEnable(GL_LIGHT1);
glEnable(GL_LIGHTING);
// Draw scene
drawScene();
// Disable lighting
glDisable(GL_LIGHTING);
// Disable face culling
glDisable(GL_CULL_FACE);
// Disable depth test
glDisable(GL_DEPTH_TEST);
// Disable scissor test
glDisable(GL_SCISSOR_TEST);
// Draw a border around the active view
if (active_view > 0 && active_view != 2)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 2.0, 0.0, 2.0, 0.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef((GLfloat) ((active_view - 1) & 1), (GLfloat) (1 - (active_view - 1) / 2), 0.0f);
glColor3f(1.0f, 1.0f, 0.6f);
glBegin(GL_LINE_STRIP);
glVertex2i(0, 0);
glVertex2i(1, 0);
glVertex2i(1, 1);
glVertex2i(0, 1);
glVertex2i(0, 0);
glEnd();
}
}
/*!****************************************************************************
@Function InitView
@Return bool true if no error occured
@Description Code in InitView() will be called by PVRShell upon
initialization or after a change in the rendering context.
Used to initialize variables that are dependant on the rendering
context (e.g. textures, vertex buffers, etc.)
******************************************************************************/
bool OGLES2PVRScopeRemote::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Take our initial vert shader source
{
CPVRTResourceFile VertShaderFile(c_szVertShaderSrcFile);
m_pszVertShader = new char[VertShaderFile.Size() + 1];
strncpy(m_pszVertShader, (char*)VertShaderFile.DataPtr(), VertShaderFile.Size());
m_pszVertShader[VertShaderFile.Size()] = 0;
}
// Take our initial frag shader source
{
CPVRTResourceFile FragShaderFile(c_szFragShaderSrcFile);
m_pszFragShader = new char[FragShaderFile.Size() + 1];
strncpy(m_pszFragShader, (char*)FragShaderFile.DataPtr(), FragShaderFile.Size());
m_pszFragShader[FragShaderFile.Size()] = 0;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr, m_pszFragShader, m_pszVertShader))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Is the screen rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Calculate the projection and view matrices
*/
m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), CAM_NEAR, CAM_FAR, PVRTMat4::OGL, bRotate);
m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 75), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0));
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
return true;
}
static Bool
tdPaintWindowWithDepth (CompWindow *w,
const WindowPaintAttrib *attrib,
const CompTransform *transform,
Region region,
unsigned int mask)
{
//Bool wasCulled;
Bool status;
int wx, wy, ww, wh;
int bevel, cull, cullInv, temp;
CompScreen *s = w->screen;
CompVector point, tPoint;
unsigned short c[4];
TD_SCREEN (s);
TD_WINDOW (w);
CUBE_SCREEN (s);
//wasCulled = glIsEnabled (GL_CULL_FACE);
wx = w->attrib.x - w->input.left;
wy = w->attrib.y - w->input.top;
ww = w->width + w->input.left + w->input.right;
wh = w->height + w->input.top + w->input.bottom;
const BananaValue *
option_bevel = bananaGetOption (bananaIndex,
"bevel",
s->screenNum);
bevel = option_bevel->i;
glGetIntegerv (GL_CULL_FACE_MODE, &cull);
cullInv = (cull == GL_BACK)? GL_FRONT : GL_BACK;
if (ww && wh && !(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK) &&
((cs->paintOrder == FTB && tdw->ftb) ||
(cs->paintOrder == BTF && !tdw->ftb)))
{
/* Paint window depth. */
glPushMatrix ();
glLoadIdentity ();
if (cs->paintOrder == BTF)
glCullFace (cullInv);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (w->id == display.activeWindow)
{
const BananaValue *
option_width_color = bananaGetOption (bananaIndex,
"width_color",
s->screenNum);
stringToColor (option_width_color->s, c);
}
else
{
const BananaValue *
option_width_color_inactive = bananaGetOption (bananaIndex,
"width_color_inactive",
s->screenNum);
stringToColor (option_width_color_inactive->s, c);
}
temp = c[3] * w->paint.opacity;
temp /= 0xffff;
glColor4us (c[0], c[1], c[2], temp);
point.z = 0.0f;
point.w = 1.0f;
glBegin (GL_QUADS);
/* Top */
ADDQUAD (wx + ww - dobevel ("bevel_topleft", bevel), wy + 0.01,
wx + dobevel ("bevel_topright", bevel), wy + 0.01);
/* Bottom */
ADDQUAD (
wx + dobevel ("bevel_bottomleft", bevel), wy + wh - 0.01,
wx + ww - dobevel ("bevel_bottomright", bevel), wy + wh - 0.01);
/* Left */
ADDQUAD (wx + 0.01, wy + dobevel ("bevel_topleft", bevel),
wx + 0.01, wy + wh - dobevel ("bevel_bottomleft", bevel));
/* Right */
ADDQUAD (wx + ww - 0.01, wy + wh - dobevel ("bevel_topright", bevel),
wx + ww - 0.01, wy + dobevel ("bevel_bottomright", bevel));
const BananaValue *
option_bevel_topleft = bananaGetOption (bananaIndex,
"bevel_topleft",
s->screenNum);
/* Top left bevel */
if (option_bevel_topleft->b)
{
ADDBEVELQUAD (wx + bevel / 2.0f,
wy + bevel - bevel / 1.2f,
wx, wy + bevel,
&tds->bTransform, transform);
ADDBEVELQUAD (wx + bevel / 2.0f,
wy + bevel - bevel / 1.2f,
wx + bevel, wy,
transform, &tds->bTransform);
}
const BananaValue *
option_bevel_bottomleft = bananaGetOption (bananaIndex,
"bevel_bottomleft",
s->screenNum);
/* Bottom left bevel */
if (option_bevel_bottomleft->b)
{
ADDBEVELQUAD (wx + bevel / 2.0f,
wy + wh - bevel + bevel / 1.2f,
wx, wy + wh - bevel,
transform, &tds->bTransform);
ADDBEVELQUAD (wx + bevel / 2.0f,
wy + wh - bevel + bevel / 1.2f,
wx + bevel, wy + wh,
&tds->bTransform, transform);
}
const BananaValue *
option_bevel_bottomright = bananaGetOption (bananaIndex,
"bevel_bottomright",
s->screenNum);
/* Bottom right bevel */
if (option_bevel_bottomright->b)
{
ADDBEVELQUAD (wx + ww - bevel / 2.0f,
wy + wh - bevel + bevel / 1.2f,
wx + ww - bevel, wy + wh,
transform, &tds->bTransform);
ADDBEVELQUAD (wx + ww - bevel / 2.0f,
wy + wh - bevel + bevel / 1.2f,
wx + ww, wy + wh - bevel,
&tds->bTransform, transform);
}
const BananaValue *
option_bevel_topright = bananaGetOption (bananaIndex,
"bevel_topright",
s->screenNum);
/* Top right bevel */
if (option_bevel_topright->b)
{
ADDBEVELQUAD (wx + ww - bevel, wy,
wx + ww - bevel / 2.0f,
wy + bevel - bevel / 1.2f,
transform, &tds->bTransform);
ADDBEVELQUAD (wx + ww, wy + bevel,
wx + ww - bevel / 2.0f,
wy + bevel - bevel / 1.2f,
&tds->bTransform, transform);
}
glEnd ();
glColor4usv (defaultColor);
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glPopMatrix ();
if (cs->paintOrder == BTF)
glCullFace (cull);
}
UNWRAP(tds, s, paintWindow);
if (cs->paintOrder == BTF)
status = (*s->paintWindow) (w, attrib, transform, region, mask);
else
status = (*s->paintWindow) (w, attrib, &tds->bTransform, region,
mask | PAINT_WINDOW_TRANSFORMED_MASK);
WRAP (tds, s, paintWindow, tdPaintWindow);
return status;
}
/**
* Dibuje el modelo definido por el archivo knight.obj 1 disponible en webasignatura. El
* formato del archivo OBJ se encuentra definido en el anexo I de este documento. Cada
* triángulo del modelo debe ser dibujado usando un tono de gris randómico en sus vértices.
* Nota: Para parsear el archivo obj, puede utilizar las funciones fgets (definida en stdio.h),
* strcmp, strtok (definidas en string.h), atof y atoi (definidas en stdlib.h).
*/
int main(int argc, char* argv[])
{
// Crear una ventana de 500x500 pixels:
int cw = 900;
int ch = 900;
cg_init(cw, ch, NULL);
#ifdef WIN32
freopen( "CON", "w", stdout );
freopen( "CON", "w", stderr );
#endif
printf("GL Version: %s\n", glGetString(GL_VERSION));
// Actualizar la pantalla:
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glViewport(0,0,cw, ch);
glFrustum(-1,1,-1,1,1,1000);
//Habilito la iluminación del pipeline estático de OpenGL.
glEnable(GL_LIGHTING);
//Creo un Vec4 para representar el color (RGBA) y la Intensidad de la luz.
//P.e.: (1,1,1,1) = Luz Blanca intensa, (0.5,0.5,0.5,1) = Luz blanca tenue, (0.5,0,0,1) = Luz roja tenue.
float l0[] = {1.0f,1.0f,1.0f,1.0f};
//Creo un Vec4 para representar el color (RGBA) y la intensidad de la iluminación ambiente de la luz
float la[] = {0.10f,0.10f,0.10f,1.0f};
//Creo un Vec4 para representar la posición de la luz. El cuarto elemento representa el tipo de luz: 1=puntual, 0=direccional
float l0p[]= {1.0f,1.0f,1.0f,1.0f};
//Creo un Vec4 para representar el color (RGBA) y la intensidad especular de la luz
float ls[] = {1.0f,1.0f,1.0f,1.0f};
//Cargo la intesidad ambiente de la Luz Nro 0 del pipline estático.
glLightfv(GL_LIGHT0, GL_AMBIENT, la);
//Cargo la intesidad difusa de la Luz Nro 0 del pipline estático.
glLightfv(GL_LIGHT0, GL_DIFFUSE, l0);
//Cargo la posición de la Luz Nro 0 del pipline estático.
glLightfv(GL_LIGHT0, GL_POSITION, l0p);
//Cargo la intesidad especular de la Luz Nro 0 del pipline estático.
glLightfv(GL_LIGHT0, GL_SPECULAR, ls);
//Prendo la Luz nro 0 del pipline estático. Hay 8 luces, representadas por las constantes GL_LIGHT0 a GL_LIGHT7
//Por defecto está todas apagadas al inicio.
glEnable(GL_LIGHT0);
//Creo un Vec4 para representar el color difuso(RGBA) del material del objeto a dibujar.
float cyan[] = {1.0f, 0.0f, 1.0f, 1.f};
//Cargo el color difuso del la cara de adelante del objeto a dibujar.
glMaterialfv(GL_FRONT, GL_DIFFUSE, cyan);
//Cargo el color especular del la cara de adelante del objeto a dibujar.
glMaterialfv(GL_FRONT, GL_SPECULAR, ls);
//Cargo el coeficiente especular de la cara de adelante del objeto a dibujar.
glMateriali(GL_FRONT, GL_SHININESS, 32);
float ang = 0.0f;
float pitch = 0.0f;
float ang_vel = 1.0f;
Obj* obj = obj_load("Models/knight.obj");
printf("num of faces %d\n", obj->numfaces); // delete
printf("num of vertices %d\n", obj->numverts); // delete
char done = 0;
char wireframe = 0;
char bfc = 0;
glEnable(GL_DEPTH_TEST);
char zbuff = 1;
unsigned char key_pressed[1024];
memset(key_pressed, 0, 1024);
while (!done)
{
SDL_Event event;
while(SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_KEYDOWN:
key_pressed[event.key.keysym.sym] = 1;
if (event.key.keysym.sym == SDLK_z)
{
zbuff = !zbuff;
if(zbuff)
glEnable(GL_DEPTH_TEST);
else
glDisable(GL_DEPTH_TEST);
break;
}
else if (event.key.keysym.sym == SDLK_m)
{
wireframe = !wireframe;
if(wireframe)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
break;
}
else if (event.key.keysym.sym == SDLK_b)
{
bfc = !bfc;
if(bfc)
{
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
}
else
glDisable(GL_CULL_FACE);
break;
}
else if (event.key.keysym.sym != SDLK_ESCAPE)
break;
case SDL_QUIT : done = 1;break;
case SDL_KEYUP: key_pressed[event.key.keysym.sym] = 0;
}
}
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -50.0f);
glRotatef(pitch, 1.0f, 0.0f, 0.0f);
glRotatef(ang, 0.0f, 1.0f, 0.0f);
glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);
if(key_pressed[SDLK_RIGHT]) ang += ang_vel;
if(key_pressed[SDLK_LEFT]) ang -= ang_vel;
if(key_pressed[SDLK_UP]) pitch += ang_vel;
if(key_pressed[SDLK_DOWN]) pitch -= ang_vel;
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
obj_render(obj);
cg_repaint();
}
obj_free(obj);
// Liberar recursos:
cg_close();
// Ejemplo del modulo de Manejo de Memoria (MM):
int* pint = (int *)cg_malloc(10*sizeof(int));
printf("pint is a pointer: %p\n", pint);
cg_free(pint); // olvidarse de liberar este objeto produce un mensaje
return 0;
}
static void pie_DrawShadows(void)
{
const float width = pie_GetVideoBufferWidth();
const float height = pie_GetVideoBufferHeight();
GLenum op_depth_pass_front = GL_INCR, op_depth_pass_back = GL_DECR;
pie_SetTexturePage(TEXPAGE_NONE);
glPushMatrix();
pie_SetAlphaTest(false);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDepthFunc(GL_LESS);
glDepthMask(GL_FALSE);
glEnable(GL_STENCIL_TEST);
// Check if we have the required extensions
if (GLEE_EXT_stencil_wrap)
{
op_depth_pass_front = GL_INCR_WRAP_EXT;
op_depth_pass_back = GL_DECR_WRAP_EXT;
}
// generic 1-pass version
if (GLEE_EXT_stencil_two_side)
{
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
glDisable(GL_CULL_FACE);
glStencilMask(~0);
glActiveStencilFaceEXT(GL_BACK);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back);
glStencilFunc(GL_ALWAYS, 0, ~0);
glActiveStencilFaceEXT(GL_FRONT);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front);
glStencilFunc(GL_ALWAYS, 0, ~0);
pie_ShadowDrawLoop();
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
}
// check for ATI-specific 1-pass version
else if (GLEE_ATI_separate_stencil)
{
glDisable(GL_CULL_FACE);
glStencilMask(~0);
glStencilOpSeparateATI(GL_BACK, GL_KEEP, GL_KEEP, op_depth_pass_back);
glStencilOpSeparateATI(GL_FRONT, GL_KEEP, GL_KEEP, op_depth_pass_front);
glStencilFunc(GL_ALWAYS, 0, ~0);
pie_ShadowDrawLoop();
}
// fall back to default 2-pass version
else
{
glStencilMask(~0);
glStencilFunc(GL_ALWAYS, 0, ~0);
glEnable(GL_CULL_FACE);
// Setup stencil for front-facing polygons
glCullFace(GL_BACK);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front);
pie_ShadowDrawLoop();
// Setup stencil for back-facing polygons
glCullFace(GL_FRONT);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back);
pie_ShadowDrawLoop();
}
pie_SetRendMode(REND_ALPHA);
glEnable(GL_CULL_FACE);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilMask(~0);
glStencilFunc(GL_LESS, 0, ~0);
glColor4f(0, 0, 0, 0.5);
pie_PerspectiveEnd();
glLoadIdentity();
glDisable(GL_DEPTH_TEST);
glBegin(GL_TRIANGLE_STRIP);
glVertex2f(0, 0);
glVertex2f(width, 0);
glVertex2f(0, height);
glVertex2f(width, height);
glEnd();
pie_PerspectiveBegin();
pie_SetRendMode(REND_OPAQUE);
glDisable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glPopMatrix();
nb_scshapes = 0;
}
