/*
struct shader_struct {
GLuint shader_program;
int shadow_lights;
int noshadow_lights;
int nospecular_lights;
};*/
GLuint get_shader(int shadow_point_lights, int noshadow_point_lights, int nospecular_point_lights)
{
/*if (shadow_point_lights + noshadow_point_lights + nospecular_point_lights == 0) { //no lights are lighting this area up
nospecular_point_lights = 1; // make sure we have a fake light with zero intensity to match this...
}*/
unsigned int i;
//shadow_point_lights = 1;
for (i = 0; i < shader_objects.size(); i++) {
if (shader_objects[i]->shadow_lights == shadow_point_lights && shader_objects[i]->noshadow_lights == noshadow_point_lights && shader_objects[i]->nospecular_lights == nospecular_point_lights)
return shader_objects[i]->shader_program;
}
int max_lights = shadow_point_lights + noshadow_point_lights + nospecular_point_lights;
char shader_header[256];
if (max_lights){
sprintf(shader_header,"#define MAX_LIGHTS %i\n#define MAX_SHADOW_LIGHTS %i\n#define MAX_NOSHADOW_LIGHTS %i\n#define MAX_SIMPLE_LIGHTS %i\nuniform mat4 light_position[MAX_LIGHTS];\nuniform mat3 light_properties[MAX_LIGHTS];\n",
shadow_point_lights + noshadow_point_lights + nospecular_point_lights,
shadow_point_lights, noshadow_point_lights, nospecular_point_lights);
} else {
sprintf(shader_header,"#define MAX_LIGHTS %i\n#define MAX_SHADOW_LIGHTS %i\n#define MAX_NOSHADOW_LIGHTS %i\n#define MAX_SIMPLE_LIGHTS %i\nuniform mat4 light_position[1];\nuniform mat3 light_properties[1];\n",
shadow_point_lights + noshadow_point_lights + nospecular_point_lights,
shadow_point_lights, noshadow_point_lights, nospecular_point_lights);
}
printf("shader header: %s \n\n", shader_header);
GLuint shader_program = load_shaders("C:\\bin\\january_2016_jam\\3d_spaceman_sim\\triangle.v.glsl", "C:\\bin\\january_2016_jam\\3d_spaceman_sim\\triangle.f2.glsl", shader_header);
struct shader_struct * new_shader_struct = (struct shader_struct *) malloc(sizeof(struct shader_struct));
new_shader_struct->noshadow_lights = noshadow_point_lights;
new_shader_struct->nospecular_lights = nospecular_point_lights;
new_shader_struct->shadow_lights = shadow_point_lights;
new_shader_struct->shader_program = shader_program;
shader_objects.push_back(new_shader_struct);
return shader_program;
}
void onKey(int key, int action)
{
if (action == 1)
{
switch (key)
{
case GLFW_KEY_KP_ADD: dmap_depth += 0.1f;
break;
case GLFW_KEY_KP_SUBTRACT: dmap_depth -= 0.1f;
break;
case 'F': enable_fog = !enable_fog;
break;
case 'D': enable_displacement = !enable_displacement;
break;
case 'W': wireframe = !wireframe;
break;
case 'P': paused = !paused;
break;
case 'R':
load_shaders();
break;
default:
break;
};
}
}
void shadowmapping_app::onKey(int key, int action)
{
if (action)
{
switch (key)
{
case 'Q':
focal_distance *= 1.1f;
break;
case'A':
focal_distance /= 1.1f;
break;
case 'W':
focal_depth *= 1.1f;
break;
case 'S':
focal_depth /= 1.1f;
break;
case 'R':
load_shaders();
break;
case 'P':
paused = !paused;
break;
}
}
}
void subroutines_app::startup()
{
load_shaders();
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
}
void stereo_app::onKey(int key, int action)
{
if (action)
{
switch (key)
{
case '1':
mode = RENDER_FULL;
break;
case '2':
mode = RENDER_LIGHT;
break;
case '3':
mode = RENDER_DEPTH;
break;
case 'Z':
separation += 0.05f;
break;
case 'X':
separation -= 0.05f;
break;
case 'R':
load_shaders();
break;
case 'P':
paused = !paused;
break;
}
}
}
virtual void startup()
{
static const GLubyte toon_tex_data[] =
{
0x44, 0x00, 0x00, 0x00,
0x88, 0x00, 0x00, 0x00,
0xCC, 0x00, 0x00, 0x00,
0xFF, 0x00, 0x00, 0x00
};
glGenTextures(1, &tex_toon);
glBindTexture(GL_TEXTURE_1D, tex_toon);
glTexStorage1D(GL_TEXTURE_1D, 1, GL_RGB8, sizeof(toon_tex_data) / 4);
glTexSubImage1D(GL_TEXTURE_1D, 0,
0, sizeof(toon_tex_data) / 4,
GL_RGBA, GL_UNSIGNED_BYTE,
toon_tex_data);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
object.load("media/objects/torus_nrms_tc.sbm");
load_shaders();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
}
void onKey(int key, int action)
{
if (!action)
return;
switch (key)
{
case '1':
case '2':
case '3':
mode = key - '1';
break;
case 'R':
load_shaders();
break;
case 'M':
mode = (mode + 1) % 3;
break;
case GLFW_KEY_KP_ADD:
exposure *= 1.1f;
break;
case GLFW_KEY_KP_SUBTRACT:
exposure /= 1.1f;
break;
}
}
void shadowmapping_app::startup()
{
load_shaders();
int i;
static const char * const object_names[] =
{
"media/objects/dragon.sbm",
"media/objects/sphere.sbm",
"media/objects/cube.sbm",
"media/objects/cube.sbm",
"media/objects/cube.sbm",
};
static const vmath::vec4 object_colors[] =
{
vmath::vec4(1.0f, 0.7f, 0.8f, 1.0f),
vmath::vec4(0.7f, 0.8f, 1.0f, 1.0f),
vmath::vec4(0.3f, 0.9f, 0.4f, 1.0f),
vmath::vec4(0.6f, 0.4f, 0.9f, 1.0f),
vmath::vec4(0.8f, 0.2f, 0.1f, 1.0f),
};
for (i = 0; i < OBJECT_COUNT; i++)
{
objects[i].obj.load(object_names[i]);
objects[i].diffuse_albedo = object_colors[i];
}
glGenFramebuffers(1, &depth_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, depth_fbo);
glGenTextures(1, &depth_tex);
glBindTexture(GL_TEXTURE_2D, depth_tex);
glTexStorage2D(GL_TEXTURE_2D, 11, GL_DEPTH_COMPONENT32F, FBO_SIZE, FBO_SIZE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glGenTextures(1, &color_tex);
glBindTexture(GL_TEXTURE_2D, color_tex);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, FBO_SIZE, FBO_SIZE);
glGenTextures(1, &temp_tex);
glBindTexture(GL_TEXTURE_2D, temp_tex);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, FBO_SIZE, FBO_SIZE);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_tex, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, color_tex, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glEnable(GL_DEPTH_TEST);
glGenVertexArrays(1, &quad_vao);
glBindVertexArray(quad_vao);
}
void assignment1_app::startup()
{
load_shaders();
glGenVertexArrays(1, &cube_vao); //glGenVertexArrays(n, &array) returns n vertex array object names in arrays
glBindVertexArray(cube_vao); //glBindVertexArray(array) binds the vertex array object with name array.
#pragma region Cube Pos Buffer
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glBufferData(GL_ARRAY_BUFFER,
sizeof(cube_data),
cube_data,
GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
#pragma endregion
#pragma region Cube Color Buffer
glGenBuffers(1, &colorBuffer);
glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
glBufferData(GL_ARRAY_BUFFER,
sizeof(color_data),
color_data,
GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
#pragma endregion
#pragma region Cube Normals Buffer
glGenBuffers(1, &normalsBuffer);
glBindBuffer(GL_ARRAY_BUFFER, normalsBuffer);
glBufferData(GL_ARRAY_BUFFER,
sizeof(normals_data),
normals_data,
GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
#pragma endregion
#pragma region Buffer For Uniform Block
glGenBuffers(1, &uniforms_buffer);
glBindBuffer(GL_UNIFORM_BUFFER, uniforms_buffer);
glBufferData(GL_UNIFORM_BUFFER, sizeof(uniforms_block), NULL, GL_DYNAMIC_DRAW);
#pragma endregion
useUniformColor = falseVec;
glGenVertexArrays(1, &sphere_vao);
glBindVertexArray(sphere_vao);
object.load("bin\\media\\objects\\sphere.sbm");
#pragma region OPENGL Settings
glEnable(GL_CULL_FACE); // Use face culling to see into the room.
glFrontFace(GL_CW); //glFrontFace(GLenum mode) In a scene composed entirely of opaque closed surfaces, back-facing polygons are never visible.
glEnable(GL_DEPTH_TEST); //glEnable(GLenum cap) glEnable and glDisable enable and disable various capabilities.
glDepthFunc(GL_LEQUAL); //glDepthFunc(GLenum func) specifies the function used to compare each incoming pixel depth value with the depth value present in the depth buffer.
#pragma endregion
}
void cubicfilter_app::startup()
{
load_shaders();
glGenVertexArrays(1, &dummy_vao);
glBindVertexArray(dummy_vao);
source_tex = sb7::ktx::file::load("media/textures/baboon.ktx");
}
void Shader::create(const std::string& name, Owner location){
init();
load_shaders(name,location);
compile_shaders();
link_shaders();
get_attributes();
get_uniforms();
}
void mirrorclamp_app::startup()
{
overlay.init(80, 50);
input_texture = sb7::ktx::file::load("media/textures/flare.ktx");
load_shaders();
glGenVertexArrays(1, &dummy_vao);
}
Effect_technique* Effect_provider::load_technique(const rapidjson::Value& technique_node, const std::string& constant_buffer_code,
const std::string& sampler_code, const Shader_data_layout& data_layout_descriptions) const
{
Effect_technique* technique = new Effect_technique(rendering_tool_.device().create_shader_program());
std::string vertex_input_name;
const rapidjson::Value* shaders_node;
for (auto n = technique_node.MemberBegin(); n != technique_node.MemberEnd(); ++n)
{
const std::string node_name = n->name.GetString();
const rapidjson::Value& node_value = n->value;
if (node_name== "input")
{
vertex_input_name = node_value.GetString();
}
else if (node_name == "shaders")
{
shaders_node = &node_value;
}
}
std::vector<Handle<Shader>> shaders;
if (!load_shaders(shaders, *shaders_node, constant_buffer_code, sampler_code, vertex_input_name, data_layout_descriptions))
{
delete technique;
return nullptr;
}
std::map<std::string, std::string> semantic_mapping;
// Vertex input layout
const auto& descriptions = data_layout_descriptions.descriptions();
auto vi = descriptions.find(vertex_input_name);
if (descriptions.end() != vi)
{
fill_semantic_mapping(semantic_mapping, vi->second);
}
std::string error_message;
if (!technique->program()->link(shaders, error_message, &semantic_mapping))
{
logging::error("Effect_provider::load_technique(): " + error_message);
delete technique;
return nullptr;
}
return technique;
}
void cullindirect_app::onKey(int key, int action)
{
if (action)
{
switch (key)
{
case 'R': load_shaders();
break;
}
}
}
void bumpmapping_app::startup()
{
load_shaders();
glActiveTexture(GL_TEXTURE0);
textures.color = sb7::ktx::file::load("media/textures/ladybug_co.ktx");
glActiveTexture(GL_TEXTURE1);
textures.normals = sb7::ktx::file::load("media/textures/ladybug_nm.ktx");
object.load("media/objects/ladybug.sbm");
}
virtual void onKey(int key, int action)
{
if (action)
{
switch (key)
{
case 'R': load_shaders();
break;
}
}
}
void subroutines_app::onKey(int key, int action)
{
if (action)
{
switch (key)
{
case 'R':
load_shaders();
break;
}
}
}
void blinnphong_app::onKey(int key, int action)
{
if (action)
{
switch (key)
{
case 'R':
load_shaders();
break;
}
}
}
void raytracer_app::onKey(int key, int action)
{
if (action)
{
switch (key)
{
case 27:
exit(0);
case '1'://GLFW_KEY_KP_ADD:
max_depth++;
if (max_depth > MAX_RECURSION_DEPTH)
max_depth = MAX_RECURSION_DEPTH;
break;
case '2'://GLFW_KEY_KP_SUBTRACT:
max_depth--;
if (max_depth < 1)
max_depth = 1;
break;
case 'P':
paused = !paused;
break;
case 'R':
load_shaders();
break;
case 'Q':
debug_mode = DEBUG_NONE;
break;
case 'W':
debug_mode = DEBUG_REFLECTED;
break;
case 'E':
debug_mode = DEBUG_REFRACTED;
break;
case 'S':
debug_mode = DEBUG_REFLECTED_COLOR;
break;
case 'D':
debug_mode = DEBUG_REFRACTED_COLOR;
break;
case 'A':
debug_depth++;
if (debug_depth > MAX_RECURSION_DEPTH)
debug_depth = MAX_RECURSION_DEPTH;
break;
case 'Z':
debug_depth--;
if (debug_depth < 0)
debug_depth = 0;
break;
}
}
}
shmup_game *
shmup_game_init()
{
ENetAddress e;
shmup_game *g;
g = malloc(sizeof(shmup_game));
glfwGetWindowSize(&g->window_width, &g->window_height);
g->render_type = 2;
g->quit = 0;
g->emitter = v2(g->window_width / 2, g->window_height / 2);
g->gravity = v2(0, -250);
g->bpool = bpool_new(8000);
g->bpool->tex[0] = SOIL_load_OGL_texture("./data/flare.tga",
SOIL_LOAD_AUTO,
SOIL_CREATE_NEW_ID, 0);
if(g->bpool->tex[0] == 0)
fprintf(stderr, "loading error: '%s'\n", SOIL_last_result());
g->bpool->tex[1] = SOIL_load_OGL_texture("./data/arrow.tga",
SOIL_LOAD_AUTO,
SOIL_CREATE_NEW_ID, 0);
if(g->bpool->tex[1] == 0)
fprintf(stderr, "loading error: '%s'\n", SOIL_last_result());
g->bpool->prog = load_shaders("./data/glsl/bullets.vsh",
"./data/glsl/bullets.fsh");
if (enet_initialize () != 0) {
fprintf (stderr, "An error occurred while initializing ENet.\n");
exit(EXIT_FAILURE);
}
if (g->network_type == SERVER) {
e.host = ENET_HOST_ANY;
e.port = 4000;
g->host = enet_host_create(&e, 4, 2, 0, 0);
} else {
g->host = enet_host_create(NULL, 4, 2, 0, 0);
}
g->player[0].pos = v2(g->window_width/2, g->window_height/2);
g->player[0].vel = v2zero;
g->player[0].acc = v2zero;
// fire(g, 1000, 0);
// fire(g, 1000, 1);
return g;
}
void cubicfilter_app::onKey(int key, int action)
{
if (action)
{
switch (key)
{
case 'R':
load_shaders();
break;
default:
break;
}
}
}
void blinnphong_app::startup()
{
load_shaders();
glGenBuffers(1, &uniforms_buffer);
glBindBuffer(GL_UNIFORM_BUFFER, uniforms_buffer);
glBufferData(GL_UNIFORM_BUFFER, sizeof(uniforms_block), NULL, GL_DYNAMIC_DRAW);
object.load("media/objects/sphere.sbm");
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
}
virtual void onKey(int key, int action)
{
if (action)
{
switch (key)
{
case 'R': load_shaders();
break;
case 'E':
envmap_index = (envmap_index + 1) % 3;
tex_envmap = envmaps[envmap_index];
break;
}
}
}
virtual void startup()
{
load_shaders();
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glPatchParameteri(GL_PATCH_VERTICES, 4);
glEnable(GL_CULL_FACE);
tex_displacement = sb6::ktx::file::load("media/textures/terragen1.ktx");
glActiveTexture(GL_TEXTURE1);
tex_color = sb6::ktx::file::load("media/textures/terragen_color.ktx");
}
void phonglighting_app::onKey(int key, int action)
{
if (action)
{
switch (key)
{
case 'R':
load_shaders();
break;
case 'V':
per_vertex = !per_vertex;
break;
}
}
}
void startup()
{
logo_texture = sb7::ktx::file::load("media/textures/gllogodistsmarray.ktx");
glBindTexture(GL_TEXTURE_2D_ARRAY, sdf_texture);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
sdf_texture = sb7::ktx::file::load("media/textures/chars-df-array.ktx");
glBindTexture(GL_TEXTURE_2D_ARRAY, sdf_texture);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glGenVertexArrays(1, &vao);
load_shaders();
}
void cullindirect_app::startup()
{
GLuint first, count;
object.load("media/objects/asteroids.sbm");
glGenBuffers(1, &buffers.parameters);
glBindBuffer(GL_PARAMETER_BUFFER_ARB, buffers.parameters);
glBufferStorage(GL_PARAMETER_BUFFER_ARB, 256, nullptr, 0);
glGenBuffers(1, &buffers.drawCandidates);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffers.drawCandidates);
CandidateDraw* pDraws = new CandidateDraw[CANDIDATE_COUNT];
int i;
for (i = 0; i < CANDIDATE_COUNT; i++)
{
object.get_sub_object_info(i % object.get_sub_object_count(), first, count);
pDraws[i].sphereCenter = vmath::vec3(0.0f);
pDraws[i].sphereRadius = 4.0f;
pDraws[i].firstVertex = first;
pDraws[i].vertexCount = count;
}
glBufferStorage(GL_SHADER_STORAGE_BUFFER, CANDIDATE_COUNT * sizeof(CandidateDraw), pDraws, 0);
delete [] pDraws;
glGenBuffers(1, &buffers.drawCommands);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffers.drawCommands);
glBufferStorage(GL_SHADER_STORAGE_BUFFER, CANDIDATE_COUNT * sizeof(DrawArraysIndirectCommand), nullptr, GL_MAP_READ_BIT);
glGenBuffers(1, &buffers.modelMatrices);
glBindBuffer(GL_UNIFORM_BUFFER, buffers.modelMatrices);
glBufferStorage(GL_UNIFORM_BUFFER, 1024 * sizeof(vmath::mat4), nullptr, GL_MAP_WRITE_BIT);
glGenBuffers(1, &buffers.transforms);
glBindBuffer(GL_UNIFORM_BUFFER, buffers.transforms);
glBufferStorage(GL_UNIFORM_BUFFER, sizeof(TransformBuffer), nullptr, GL_MAP_WRITE_BIT);
load_shaders();
overlay.init(128, 50);
texture = sb7::ktx::file::load("media/textures/rocks.ktx");
}
void Renderer::init()
{
//Initialize glfw
if (!glfwInit())
throw std::runtime_error("glfw failed");
_window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
if (!_window)
{
glfwTerminate();
return;
}
/* Make the window's context current */
glfwMakeContextCurrent(_window);
//Initialize glew. GLEW HAS TO BE STARTED THE CONTEXT IS SET!
if (glewInit() != GLEW_OK)
throw std::runtime_error("glewInit failed");
std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
std::cout << "Initializing shaders....." << std::endl;
// Enable depth test
//glEnable(GL_DEPTH_TEST);
// Accept fragment if it closer to the camera than the former one
//glDepthFunc(GL_LEQUAL);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
//Load shaders and get the handle for the uniform parameter
load_shaders("easy.vsh", "easy.psh");
//set_shader("easy");
_mvp = glGetUniformLocation(_shader_list.back(), "ModelViewProj");
_model = glGetUniformLocation(_shader_list.back(), "Model");
_it_model = glGetUniformLocation(_shader_list.back(), "ITModel");
_diffuse = glGetUniformLocation(_shader_list.back(), "diffuse");
_light_dir = glGetUniformLocation(_shader_list.back(), "light_dir");
//Set up a simple camera setting.
glm::mat4 view = glm::lookAt(glm::vec3(0,0,100), glm::vec3(0,0,0), glm::vec3(0,1,0));
glm::mat4 proj = glm::perspective(45.0f,4.0f/3.0f,0.0f,500.0f);
_view_proj_matrix = proj * view;
}
virtual void onKey(int key, int action)
{
if (action)
{
switch (key)
{
case 'R': load_shaders();
break;
case 'T':
tex_index++;
if (tex_index > 1)
tex_index = 0;
break;
}
}
}
void mirrorclamp_app::onKey(int key, int action)
{
if (action)
{
switch (key)
{
case 'M':
display_mode = display_mode + 1;
if (display_mode == MAX_MODE)
display_mode = CLAMP_TO_BORDER;
break;
case 'R':
load_shaders();
break;
}
}
}
