static void noise_render() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
material* noise_mat = asset_get(P("./noise.mat"));
GLuint handle = shader_program_handle(material_get_entry(noise_mat, 0)->program);
GLuint random_tex = texture_handle(asset_get(P("$CORANGE/textures/random.dds")));
glUseProgram(handle);
glActiveTexture(GL_TEXTURE0 + 0 );
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, random_tex);
glUniform1i(glGetUniformLocation(handle, "noise_texture"), 0);
glUniform1f(glGetUniformLocation(handle, "time"), shader_time);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-1.0, -1.0, 0.0f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(1.0, -1.0, 0.0f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(1.0, 1.0, 0.0f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-1.0, 1.0, 0.0f);
glEnd();
glActiveTexture(GL_TEXTURE0 + 0 );
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glUseProgram(0);
}
static void reset_game() {
/* Set the starting level to demo.level */
current_level = asset_get(P("./levels/demo.level"));
level_score = 0;
level_time = 0.0;
/* New main character entity */
character* main_char = entity_get("main_char");
main_char->position = vec2_mul( vec2_new(20, 20), TILE_SIZE);
main_char->velocity = vec2_zero();
/* We can create multiple entities using a name format string like printf */
entities_new("coin_id_%i", COIN_COUNT, coin);
/* Get an array of pointers to all coin entities */
coin* coins[COIN_COUNT];
entities_get(coins, NULL, coin);
/* Set all the coin initial positions */
for(int i = 0; i < COIN_COUNT; i++) {
coins[i]->position = vec2_mul(coin_positions[i], TILE_SIZE);
}
/* Deactivate victory and new game UI elements */
ui_button* victory = ui_elem_get("victory");
ui_button* new_game = ui_elem_get("new_game");
victory->active = false;
new_game->active = false;
}
void coin_render(coin* c, vec2 camera_position) {
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(camera_position.x - graphics_viewport_width() / 2,
camera_position.x + graphics_viewport_width() / 2,
-camera_position.y + graphics_viewport_height() / 2,
-camera_position.y - graphics_viewport_height() / 2
, 0, 1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
texture* coin_tex = asset_get(P("./tiles/coin.dds"));
glBindTexture(GL_TEXTURE_2D, *coin_tex);
glBegin(GL_QUADS);
glTexCoord2f(0, 1); glVertex3f(c->position.x, c->position.y + 32, 0);
glTexCoord2f(1, 1); glVertex3f(c->position.x + 32, c->position.y + 32, 0);
glTexCoord2f(1, 0); glVertex3f(c->position.x + 32, c->position.y, 0);
glTexCoord2f(0, 0); glVertex3f(c->position.x, c->position.y, 0);
glEnd();
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
void sea_event(SDL_Event event) {
camera* cam = entity_get("camera");
light* sun = entity_get("sun");
switch(event.type) {
case SDL_KEYUP:
if (event.key.keysym.sym == SDLK_SPACE) {
char ball_name[20];
sprintf(ball_name, "ball_%i", ball_count);
ball_count++;
physics_object* ball = entity_new(ball_name, physics_object);
ball->renderable = asset_get("./resources/ball.obj");
ball->collision_body = collision_body_new_sphere(sphere_new(v3_zero(), 1));
ball->position = cam->position;
ball->scale = v3(0.5, 0.5, 0.5);
ball->velocity = v3_mul(v3_normalize(v3_sub(cam->target, cam->position)), 75);
}
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_WHEELUP) {
cam->position = v3_sub(cam->position, v3_normalize(cam->position));
}
if (event.button.button == SDL_BUTTON_WHEELDOWN) {
cam->position = v3_add(cam->position, v3_normalize(cam->position));
}
break;
case SDL_MOUSEMOTION:
mouse_x = event.motion.xrel;
mouse_y = event.motion.yrel;
break;
}
}
shader_program* prog_load_file(char* filename) {
shader_program* sp = shader_program_new();
SDL_RWops* file = SDL_RWFromFile(filename, "r");
if(file == NULL) {
error("Could not load file %s", filename);
}
char line[1024];
while(SDL_RWreadline(file, line, 1024)) {
char type[256];
char path[1024];
if (sscanf(line, "%256s : %1024s", type, path) == 2) {
if(!asset_loaded(path)) {
load_file(path);
}
shader* s = asset_get(path);
shader_program_attach_shader(sp, s);
}
}
SDL_RWclose(file);
shader_program_link(sp);
shader_program_print_log(sp);
int error = 0;
glGetProgramiv(*sp, GL_LINK_STATUS, &error);
if (error == GL_FALSE) {
error("Linking Error on Shader Program %s.", filename);
}
return sp;
}
void character_render(character* c, vector2 camera_position) {
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(camera_position.x - graphics_viewport_width() / 2,
camera_position.x + graphics_viewport_width() / 2,
-camera_position.y + graphics_viewport_height() / 2,
-camera_position.y - graphics_viewport_height() / 2
, -1, 1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
/* Conditional as to if we render flap or normal icon */
texture* character_tex;
if (c->flap_timer > 0.0) {
character_tex = asset_get("./tiles/character_flap.dds");
} else {
character_tex = asset_get("./tiles/character.dds");
}
glBindTexture(GL_TEXTURE_2D, *character_tex);
/* Swaps the direction of the uvs when facing the opposite direction */
if (c->facing_left) {
glBegin(GL_TRIANGLES);
glTexCoord2f(1, 1); glVertex3f(c->position.x, c->position.y + 32, 0);
glTexCoord2f(1, 0); glVertex3f(c->position.x, c->position.y, 0);
glTexCoord2f(0, 0); glVertex3f(c->position.x + 32, c->position.y, 0);
glTexCoord2f(1, 1); glVertex3f(c->position.x, c->position.y + 32, 0);
glTexCoord2f(0, 1); glVertex3f(c->position.x + 32, c->position.y + 32, 0);
glTexCoord2f(0, 0);glVertex3f(c->position.x + 32, c->position.y, 0);
glEnd();
} else {
glBegin(GL_TRIANGLES);
glTexCoord2f(0, 1); glVertex3f(c->position.x, c->position.y + 32, 0);
glTexCoord2f(0, 0); glVertex3f(c->position.x, c->position.y, 0);
glTexCoord2f(1, 0); glVertex3f(c->position.x + 32, c->position.y, 0);
glTexCoord2f(0, 1); glVertex3f(c->position.x, c->position.y + 32, 0);
glTexCoord2f(1, 1); glVertex3f(c->position.x + 32, c->position.y + 32, 0);
glTexCoord2f(1, 0);glVertex3f(c->position.x + 32, c->position.y, 0);
glEnd();
}
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
void marching_cubes_init() {
const int full_size = width * height * depth;
/* Point rendering data */
vec4* point_data = malloc(sizeof(vec4) * full_size);
if(point_data == NULL) {
error("Not enough memory!");
}
int x, y, z;
for(x = 0; x < width; x++)
for(y = 0; y < height; y++)
for(z = 0; z < depth; z++) {
int id = x + y * width + z * width * height;
vec4 position = vec4_new(x, y, z, 1);
point_data[id] = position;
}
glGenBuffers(1, &point_positions);
glBindBuffer(GL_ARRAY_BUFFER, point_positions);
glBufferData(GL_ARRAY_BUFFER, sizeof(vec4) * full_size, point_data, GL_STATIC_DRAW);
free(point_data);
vec4* point_color_data = malloc(sizeof(vec4) * full_size);
memset(point_color_data, 0, sizeof(vec4) * full_size);
glGenBuffers(1, &point_colors);
glBindBuffer(GL_ARRAY_BUFFER, point_colors);
glBufferData(GL_ARRAY_BUFFER, sizeof(vec4) * full_size, point_color_data, GL_DYNAMIC_COPY);
free(point_color_data);
point_color_buffer = kernel_memory_from_glbuffer(point_colors);
/* OpenCL volume */
volume = kernel_memory_allocate(sizeof(float) * full_size);
/* Vertex stuff */
vec4* vertex_pos_data = malloc(sizeof(vec4) * MAX_VERTS);
memset(vertex_pos_data, 0, sizeof(vec4) * MAX_VERTS);
glGenBuffers(1, &vertex_positions);
glBindBuffer(GL_ARRAY_BUFFER, vertex_positions);
glBufferData(GL_ARRAY_BUFFER, sizeof(vec4) * MAX_VERTS, vertex_pos_data, GL_DYNAMIC_COPY);
free(vertex_pos_data);
vertex_positions_buffer = kernel_memory_from_glbuffer(vertex_positions);
vec4* vertex_norm_data = malloc(sizeof(vec4) * MAX_VERTS);
memset(vertex_norm_data, 0, sizeof(vec4) * MAX_VERTS);
glGenBuffers(1, &vertex_normals);
glBindBuffer(GL_ARRAY_BUFFER, vertex_normals);
glBufferData(GL_ARRAY_BUFFER, sizeof(vec4) * MAX_VERTS, vertex_norm_data, GL_DYNAMIC_COPY);
free(vertex_norm_data);
vertex_normals_buffer = kernel_memory_from_glbuffer(vertex_normals);
vertex_index = kernel_memory_allocate(sizeof(int));
/* Kernels */
kernel_program* marching_cubes = asset_get(P("./kernels/marching_cubes.cl"));
write_point = kernel_program_get_kernel(marching_cubes, "write_point");
kernel_set_argument(write_point, 0, sizeof(kernel_memory), &volume);
kernel_set_argument(write_point, 4, sizeof(int), (void*)&width);
kernel_set_argument(write_point, 5, sizeof(int), (void*)&height);
kernel_set_argument(write_point, 6, sizeof(int), (void*)&depth);
write_metaball = kernel_program_get_kernel(marching_cubes, "write_metaball");
kernel_set_argument(write_metaball, 0, sizeof(kernel_memory), &volume);
write_metaballs = kernel_program_get_kernel(marching_cubes, "write_metaballs");
kernel_set_argument(write_metaballs, 0, sizeof(kernel_memory), &volume);
write_clear = kernel_program_get_kernel(marching_cubes, "write_clear");
kernel_set_argument(write_clear, 0, sizeof(kernel_memory), &volume);
write_point_color_back = kernel_program_get_kernel(marching_cubes, "write_point_color_back");
kernel_set_argument(write_point_color_back, 0, sizeof(kernel_memory), &volume);
kernel_set_argument(write_point_color_back, 1, sizeof(kernel_memory), &point_color_buffer);
construct_surface = kernel_program_get_kernel(marching_cubes, "construct_surface");
kernel_set_argument(construct_surface, 0, sizeof(kernel_memory), &volume);
generate_normals = kernel_program_get_kernel(marching_cubes, "generate_flat_normals");
generate_normals_smooth = kernel_program_get_kernel(marching_cubes, "generate_smooth_normals");
}
void sea_init() {
graphics_viewport_set_dimensions(1280, 720);
graphics_viewport_set_title("Sea");
camera* cam = entity_new("camera", camera);
cam->position = v3(50.0, 50.0, 50.0);
cam->target = v3(0, 5, 0);
cam->near_clip = 0.1;
light* sun = entity_new("sun", light);
light_set_type(sun, light_type_spot);
sun->position = v3(20,23,16);
sun->ambient_color = v3(0.5, 0.5, 0.5);
sun->diffuse_color = v3(1.0, 0.894, 0.811);
sun->specular_color = v3_mul(v3(1.0, 0.894, 0.811), 4);
sun->power = 5;
light* backlight = entity_new("backlight", light);
light_set_type(backlight, light_type_point);
backlight->position = v3(-22,10,-13);
backlight->ambient_color = v3(0.2, 0.2, 0.2);
backlight->diffuse_color = v3(0.729, 0.729, 1.0);
backlight->specular_color = v3_mul(v3(0.729, 0.729, 1.0), 1);
backlight->power = 2;
shadow_mapper_init(sun);
forward_renderer_init();
forward_renderer_set_camera(cam);
forward_renderer_set_shadow_light(sun);
forward_renderer_set_shadow_texture( shadow_mapper_depth_texture() );
forward_renderer_add_light(sun);
forward_renderer_add_light(backlight);
load_folder("./resources/");
texture* noise1 = asset_get("./resources/noise1.dds");
texture* noise2 = asset_get("./resources/noise2.dds");
texture* noise3 = asset_get("./resources/noise3.dds");
texture* noise4 = asset_get("./resources/noise4.dds");
texture* noise5 = asset_get("./resources/noise5.dds");
texture* skydome_tex = asset_get("./resources/skybox_cloud_10.dds");
texture* water_calm = asset_get("./resources/water_calm.dds");
texture* water_foam = asset_get("./resources/water_foam.dds");
material* seaplane_mat = asset_get("./resources/seaplane.mat");
material_set_property(seaplane_mat, "tex_noise1", noise1, mat_type_texture);
material_set_property(seaplane_mat, "tex_noise2", noise2, mat_type_texture);
material_set_property(seaplane_mat, "tex_noise3", noise3, mat_type_texture);
material_set_property(seaplane_mat, "tex_noise4", noise4, mat_type_texture);
material_set_property(seaplane_mat, "tex_noise5", noise5, mat_type_texture);
material_set_property(seaplane_mat, "tex_skybox", skydome_tex, mat_type_texture);
material_set_property(seaplane_mat, "tex_calm_water", water_calm, mat_type_texture);
material_set_property(seaplane_mat, "tex_foam_water", water_foam, mat_type_texture);
renderable* r_seaplane = asset_get("./resources/seaplane.obj");
renderable_set_material(r_seaplane, seaplane_mat);
static_object* s_seaplane = entity_new("seaplane", static_object);
s_seaplane->renderable = r_seaplane;
s_seaplane->scale = v3(3,1,3);
static_object* skydome = entity_new("skydome", static_object);
skydome->renderable = asset_get("./resources/skydome.obj");
renderable_set_material(skydome->renderable, asset_get("./resources/skydome.mat"));
skydome->position = v3(0, -512, 0);
skydome->scale = v3(1024, 1024, 1024);
load_folder("./resources/corvette/");
renderable* r_corvette = asset_get("./resources/corvette/corvette.obj");
multi_material* m_corvette = asset_get("./resources/corvette/corvette.mmat");
renderable_set_multi_material(r_corvette, m_corvette);
static_object* s_corvette = entity_new("corvette", static_object);
s_corvette->renderable = r_corvette;
s_corvette->collision_body = collision_body_new_mesh(asset_get("./resources/corvette/corvette.col"));
s_corvette->scale = v3(1.5, 1.5, 1.5);
s_corvette->position = v3(0, 0.5, 0);
static_object* center_sphere = entity_new("center_sphere", static_object);
center_sphere->position = v3(0, 5, 0);
center_sphere->renderable = asset_get("./resources/ball.obj");
center_sphere->collision_body = collision_body_new_sphere(sphere_new(v3_zero(), 1.0f));
ui_button* framerate = ui_elem_new("framerate", ui_button);
ui_button_move(framerate, v2(10,10));
ui_button_resize(framerate, v2(30,25));
ui_button_set_label(framerate, "FRAMERATE");
ui_button_disable(framerate);
}
static int load_resources(void* unused) {
load_folder("./resources/terrain/");
load_folder("./resources/vegetation/");
static_object* skydome = entity_new("skydome", static_object);
skydome->renderable = asset_get("./resources/terrain/skydome.obj");
renderable_set_material(skydome->renderable, asset_get("./resources/terrain/skydome.mat"));
skydome->position = v3(512, 0, 512);
skydome->scale = v3(1024, 1024, 1024);
landscape* world = entity_new("world", landscape);
world->terrain = asset_get("./resources/terrain/heightmap.raw");
world->normalmap = asset_get("./resources/terrain/normalsmap.dds");
world->colormap = asset_get("./resources/terrain/colormap.dds");
world->attributemap = asset_get("./resources/terrain/attributemap.dds");
landscape_set_surface(world, 0, asset_get("./resources/terrain/grass.dds"),
asset_get("./resources/terrain/grass_nm.dds"),
asset_get("./resources/terrain/grass_far.dds"),
asset_get("./resources/terrain/grass_far_nm.dds"));
landscape_set_surface(world, 1, asset_get("./resources/terrain/grass2.dds"),
asset_get("./resources/terrain/grass2_nm.dds"),
asset_get("./resources/terrain/grass_far.dds"),
asset_get("./resources/terrain/grass_far_nm.dds"));
landscape_set_surface(world, 2, asset_get("./resources/terrain/earth.dds"),
asset_get("./resources/terrain/earth_nm.dds"),
asset_get("./resources/terrain/earth_far.dds"),
asset_get("./resources/terrain/earth_far_nm.dds"));
landscape_set_surface(world, 3, asset_get("./resources/terrain/rock.dds"),
asset_get("./resources/terrain/rock_nm.dds"),
asset_get("./resources/terrain/rock_far.dds"),
asset_get("./resources/terrain/rock_far_nm.dds"));
vegetation_init();
vegetation_add_type(asset_get("./resources/terrain/heightmap.raw"),
asset_get("./resources/vegetation/grass.obj"),
4.0);
ui_button* loading = ui_elem_get("loading");
ui_spinner* load_spinner = ui_elem_get("load_spinner");
ui_button* framerate = ui_elem_get("framerate");
ui_button* wireframe = ui_elem_get("wireframe");
ui_button* freecam = ui_elem_get("freecam");
loading->active = false;
load_spinner->active = false;
framerate->active = true;
wireframe->active = true;
freecam->active = true;
loading_resources = false;
return 1;
}
void particles_init() {
particle_positions = malloc(sizeof(vector4) * particle_count);
particle_velocities = malloc(sizeof(vector4) * particle_count);
particle_lifetimes = malloc(sizeof(float) * particle_count);
particle_randoms = malloc(sizeof(vector4) * particle_count);
srand(time(NULL));
for(int i = 0; i < particle_count; i++) {
particle_lifetimes[i] = 999;
particle_positions[i] = v4(0,0,0,0);
particle_velocities[i] = v4(0,0,0,0);
float rx = ((float)rand() / RAND_MAX) * 2 - 1;
float ry = ((float)rand() / RAND_MAX) * 2 + 0.5;
float rz = ((float)rand() / RAND_MAX) * 2 - 1;
float rm = (float)rand() / RAND_MAX;
vector3 rand = v3_mul(v3_normalize(v3(rx, ry, rz)), rm * 2);
particle_randoms[i] = v4(rand.x, rand.y, rand.z, 0);
}
glGenBuffers(1, &positions_buffer);
glBindBuffer(GL_ARRAY_BUFFER, positions_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(vector4) * particle_count, particle_positions, GL_DYNAMIC_COPY);
glGenBuffers(1, &velocities_buffer);
glBindBuffer(GL_ARRAY_BUFFER, velocities_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(vector4) * particle_count, particle_velocities, GL_DYNAMIC_COPY);
glGenBuffers(1, &lifetimes_buffer);
glBindBuffer(GL_ARRAY_BUFFER, lifetimes_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * particle_count, particle_lifetimes, GL_DYNAMIC_COPY);
glGenBuffers(1, &randoms_buffer);
glBindBuffer(GL_ARRAY_BUFFER, randoms_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(vector4) * particle_count, particle_randoms, GL_DYNAMIC_COPY);
#ifdef OPEN_GL_CPU
#ifndef CPU_ONLY
k_particle_positions = kernel_memory_allocate(sizeof(vector4) * particle_count);
k_particle_velocities = kernel_memory_allocate(sizeof(vector4) * particle_count);
k_particle_lifetimes = kernel_memory_allocate(sizeof(float) * particle_count);
k_particle_randoms = kernel_memory_allocate(sizeof(vector4) * particle_count);
kernel_memory_write(k_particle_positions, sizeof(vector4) * particle_count, particle_positions);
kernel_memory_write(k_particle_velocities, sizeof(vector4) * particle_count, particle_velocities);
kernel_memory_write(k_particle_lifetimes, sizeof(float) * particle_count, particle_lifetimes);
kernel_memory_write(k_particle_randoms, sizeof(vector4) * particle_count, particle_randoms);
#endif
#else
k_particle_positions = kernel_memory_from_glbuffer(positions_buffer);
k_particle_velocities = kernel_memory_from_glbuffer(velocities_buffer);
k_particle_lifetimes = kernel_memory_from_glbuffer(lifetimes_buffer);
k_particle_randoms = kernel_memory_from_glbuffer(randoms_buffer);
#endif
kernel_program* program = asset_get("./kernels/particles.cl");
float max_life = 60.0;
float min_velocity = 0.5;
#ifndef CPU_ONLY
k_update = kernel_program_get_kernel(program, "particle_update");
kernel_set_argument(k_update, 0, sizeof(kernel_memory), &k_particle_positions);
kernel_set_argument(k_update, 1, sizeof(kernel_memory), &k_particle_velocities);
kernel_set_argument(k_update, 2, sizeof(kernel_memory), &k_particle_lifetimes);
kernel_set_argument(k_update, 3, sizeof(kernel_memory), &k_particle_randoms);
kernel_set_argument(k_update, 4, sizeof(cl_float), &max_life);
kernel_set_argument(k_update, 5, sizeof(cl_float), &min_velocity);
kernel_set_argument(k_update, 9, sizeof(cl_int), &particle_count);
#endif
}
asset* asset_get_as_type(fpath path, type_id type) {
/* TODO: Type checking */
return asset_get(path);
}
void deferred_renderer_init() {
num_lights = 0;
EXPOSURE = 0.0;
EXPOSURE_SPEED = 1.0;
EXPOSURE_TARGET = 0.4;
COLOR_CORRECTION = asset_load_get("$CORANGE/resources/identity.lut");
RANDOM = asset_load_get("$CORANGE/resources/random.dds");
ENVIRONMENT = asset_load_get("$CORANGE/resources/envmap.dds");
VIGNETTING = asset_load_get("$CORANGE/resources/vignetting.dds");
load_folder("$CORANGE/shaders/deferred/");
PROGRAM_STATIC = asset_get("$CORANGE/shaders/deferred/static.prog");
PROGRAM_ANIMATED = asset_get("$CORANGE/shaders/deferred/animated.prog");
PROGRAM_CLEAR = asset_get("$CORANGE/shaders/deferred/clear.prog");
PROGRAM_SSAO = asset_get("$CORANGE/shaders/deferred/ssao.prog");
PROGRAM_TONEMAP = asset_get("$CORANGE/shaders/deferred/tonemap.prog");
PROGRAM_COMPOSE = asset_get("$CORANGE/shaders/deferred/compose.prog");
PROGRAM_POST = asset_get("$CORANGE/shaders/deferred/post.prog");
PROGRAM_UI = asset_get("$CORANGE/shaders/deferred/ui.prog");
NORMAL = glGetAttribLocation(shader_program_handle(PROGRAM_STATIC), "normal");
TANGENT = glGetAttribLocation(shader_program_handle(PROGRAM_STATIC), "tangent");
BINORMAL = glGetAttribLocation(shader_program_handle(PROGRAM_STATIC), "binormal");
NORMAL_ANIMATED = glGetAttribLocation(shader_program_handle(PROGRAM_ANIMATED), "normal");
TANGENT_ANIMATED = glGetAttribLocation(shader_program_handle(PROGRAM_ANIMATED), "tangent");
BINORMAL_ANIMATED = glGetAttribLocation(shader_program_handle(PROGRAM_ANIMATED), "binormal");
BONE_INDICIES = glGetAttribLocation(shader_program_handle(PROGRAM_ANIMATED), "bone_indicies");
BONE_WEIGHTS = glGetAttribLocation(shader_program_handle(PROGRAM_ANIMATED), "bone_weights");
int viewport_width = graphics_viewport_width();
int viewport_height = graphics_viewport_height();
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glGenRenderbuffers(1, &diffuse_buffer);
glBindRenderbuffer(GL_RENDERBUFFER, diffuse_buffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA, viewport_width, viewport_height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, diffuse_buffer);
glGenRenderbuffers(1, &positions_buffer);
glBindRenderbuffer(GL_RENDERBUFFER, positions_buffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32F, viewport_width, viewport_height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_RENDERBUFFER, positions_buffer);
glGenRenderbuffers(1, &normals_buffer);
glBindRenderbuffer(GL_RENDERBUFFER, normals_buffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA16F, viewport_width, viewport_height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_RENDERBUFFER, normals_buffer);
glGenRenderbuffers(1, &depth_buffer);
glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, viewport_width, viewport_height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_buffer);
glGenTextures(1, &diffuse_texture);
glBindTexture(GL_TEXTURE_2D, diffuse_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, viewport_width, viewport_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_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, diffuse_texture, 0);
glGenTextures(1, &positions_texture);
glBindTexture(GL_TEXTURE_2D, positions_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, viewport_width, viewport_height, 0, GL_RGBA, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_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_ATTACHMENT1, GL_TEXTURE_2D, positions_texture, 0);
glGenTextures(1, &normals_texture);
glBindTexture(GL_TEXTURE_2D, normals_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, viewport_width, viewport_height, 0, GL_RGBA, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_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_ATTACHMENT2, GL_TEXTURE_2D, normals_texture, 0);
glGenTextures(1, &depth_texture);
glBindTexture(GL_TEXTURE_2D, depth_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, viewport_width, viewport_height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_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, depth_texture, 0);
glGenFramebuffers(1, &ssao_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, ssao_fbo);
glGenRenderbuffers(1, &ssao_buffer);
glBindRenderbuffer(GL_RENDERBUFFER, ssao_buffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA, viewport_width / 2, viewport_height / 2);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, ssao_buffer);
glGenTextures(1, &ssao_texture);
glBindTexture(GL_TEXTURE_2D, ssao_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, viewport_width / 2, viewport_height / 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
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, ssao_texture, 0);
glGenFramebuffers(1, &hdr_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, hdr_fbo);
glGenRenderbuffers(1, &hdr_buffer);
glBindRenderbuffer(GL_RENDERBUFFER, hdr_buffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA16F, viewport_width, viewport_height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, ldr_buffer);
glGenTextures(1, &hdr_texture);
glBindTexture(GL_TEXTURE_2D, hdr_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, viewport_width, viewport_height, 0, GL_RGBA, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_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, hdr_texture, 0);
glGenFramebuffers(1, &ldr_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, ldr_fbo);
glGenRenderbuffers(1, &ldr_buffer);
glBindRenderbuffer(GL_RENDERBUFFER, ldr_buffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA, viewport_width, viewport_height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, ldr_buffer);
glGenTextures(1, &ldr_texture);
glBindTexture(GL_TEXTURE_2D, ldr_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, viewport_width, viewport_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
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, ldr_texture, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
void sea_init() {
graphics_viewport_set_dimensions(1280, 720);
graphics_viewport_set_title("Sea");
camera* cam = entity_new("camera", camera);
cam->position = vec3_new(50.0, 50.0, 50.0);
cam->target = vec3_new(0, 5, 0);
cam->near_clip = 0.1;
light* sun = entity_new("sun", light);
light_set_type(sun, light_type_spot);
sun->position = vec3_new(20,23,16);
sun->ambient_color = vec3_new(0.5, 0.5, 0.5);
sun->diffuse_color = vec3_new(1.0, 0.894, 0.811);
sun->specular_color = vec3_mul(vec3_new(1.0, 0.894, 0.811), 4);
sun->power = 5;
light* backlight = entity_new("backlight", light);
light_set_type(backlight, light_type_point);
backlight->position = vec3_new(-22,10,-13);
backlight->ambient_color = vec3_new(0.2, 0.2, 0.2);
backlight->diffuse_color = vec3_new(0.729, 0.729, 1.0);
backlight->specular_color = vec3_mul(vec3_new(0.729, 0.729, 1.0), 1);
backlight->power = 2;
shadow_mapper_init(sun);
forward_renderer_init();
forward_renderer_set_camera(cam);
forward_renderer_set_shadow_light(sun);
forward_renderer_set_shadow_texture( shadow_mapper_depth_texture() );
forward_renderer_add_light(sun);
forward_renderer_add_light(backlight);
folder_load(P("./resources/"));
renderable* r_seaplane = asset_get(P("./resources/seaplane.obj"));
r_seaplane->material = asset_hndl_new(P("./resources/seaplane.mat"));
static_object* s_seaplane = entity_new("seaplane", static_object);
s_seaplane->renderable = asset_hndl_new_ptr(r_seaplane);
s_seaplane->scale = vec3_new(3,1,3);
renderable* r_skydome = asset_get(P("./resources/skydome.obj"));
r_skydome->material = asset_hndl_new_load(P("$CORANGE/shaders/skydome.mat"));
static_object* skydome = entity_new("skydome", static_object);
skydome->renderable = asset_hndl_new_ptr(r_skydome);
skydome->position = vec3_new(0, -512, 0);
skydome->scale = vec3_new(1024, 1024, 1024);
folder_load(P("./resources/corvette/"));
renderable* r_corvette = asset_get(P("./resources/corvette/corvette.obj"));
r_corvette->material = asset_hndl_new_load(P("./resources/corvette/corvette.mat"));
static_object* s_corvette = entity_new("corvette", static_object);
s_corvette->renderable = asset_hndl_new_ptr(r_corvette);
//s_corvette->collision_body = collision_body_new_mesh(asset_get("./resources/corvette/corvette.col"));
s_corvette->scale = vec3_new(1.5, 1.5, 1.5);
s_corvette->position = vec3_new(0, 0.5, 0);
static_object* center_sphere = entity_new("center_sphere", static_object);
center_sphere->position = vec3_new(0, 5, 0);
//center_sphere->renderable = asset_get("./resources/ball.obj");
//center_sphere->collision_body = collision_body_new_sphere(sphere_new(v3_zero(), 1.0f));
ui_button* framerate = ui_elem_new("framerate", ui_button);
ui_button_move(framerate, vec2_new(10,10));
ui_button_resize(framerate, vec2_new(30,25));
ui_button_set_label(framerate, "FRAMERATE");
ui_button_disable(framerate);
}
void metaballs_init() {
graphics_viewport_set_title("Metaballs");
graphics_viewport_set_dimensions(1280, 720);
graphics_set_multisamples(16);
#ifdef OPEN_GL_CPU
kernels_init_with_cpu();
#else
kernels_init_with_opengl();
#endif
asset_manager_handler(kernel_program, "cl", cl_load_file, kernel_program_delete);
load_folder("./kernels/");
particles_init();
load_folder("./resources/podium/");
load_folder("./resources/particles/");
renderable* r_podium = asset_get("./resources/podium/podium.obj");
renderable_set_material(r_podium, asset_get("./resources/podium/podium.mat"));
static_object* s_podium = entity_new("podium", static_object);
s_podium->renderable = r_podium;
s_podium->position = v3(32, 10, 32);
camera* cam = entity_new("camera", camera);
cam->position = v3(50, 50, 50);
cam->target = v3(32, 20, 32);
light* sun = entity_new("sun", light);
sun->position = v3(50,40,50);
sun->ambient_color = v3(0.5, 0.5, 0.5);
sun->diffuse_color = v3_mul(v3_one(), 2);
sun->specular_color = v3_mul(v3_one(), 5);
light_set_type(sun, light_type_spot);
ui_button* framerate = ui_elem_new("framerate", ui_button);
ui_button_move(framerate, v2(10,10));
ui_button_resize(framerate, v2(30,25));
ui_button_set_label(framerate, "");
ui_button_disable(framerate);
ui_button* score = ui_elem_new("score", ui_button);
ui_button_move(score, v2(50, 10));
#ifdef VOLUME_RENDERER
ui_button_resize(score, v2(125, 25));
ui_button_set_label(score, "Volume Renderer");
#endif
#ifdef MARCHING_CUBES
ui_button_resize(score, v2(120, 25));
ui_button_set_label(score, "Marching Cubes");
#endif
#ifndef VOLUME_RENDERER
#ifndef MARCHING_CUBES
ui_button_resize(score, v2(80, 25));
ui_button_set_label(score, "Particles");
#endif
#endif
ui_button_disable(score);
#ifdef VOLUME_RENDERER
volume_renderer_init();
volume_renderer_set_camera(cam);
volume_renderer_set_light(sun);
#endif
#ifdef MARCHING_CUBES
shadow_mapper_init(sun);
forward_renderer_init();
forward_renderer_set_camera(cam);
forward_renderer_set_shadow_light(sun);
forward_renderer_set_shadow_texture( shadow_mapper_depth_texture() );
forward_renderer_add_light(sun);
marching_cubes_init();
#endif
}
static texture* tile_get_texture(int tiletype) {
texture* t;
switch(tiletype) {
case tiletype_none: t = asset_get(P("./tiles/tile_sky.dds")); break;
case tiletype_air: t = asset_get(P("./tiles/tile_sky.dds")); break;
case tiletype_dirt: t = asset_get(P("./tiles/tile_dirt.dds")); break;
case tiletype_dirt_rock: t = asset_get(P("./tiles/tile_dirt_rock.dds")); break;
case tiletype_dirt_overhang: t = asset_get(P("./tiles/tile_dirt_overhang.dds")); break;
case tiletype_surface: t = asset_get(P("./tiles/tile_surface.dds")); break;
case tiletype_grass: t = asset_get(P("./tiles/tile_grass.dds")); break;
case tiletype_grass_rock1: t = asset_get(P("./tiles/tile_grass_rock1.dds")); break;
case tiletype_grass_rock2: t = asset_get(P("./tiles/tile_grass_rock2.dds")); break;
case tiletype_grass_tree: t = asset_get(P("./tiles/tile_grass_tree.dds")); break;
case tiletype_tree: t = asset_get(P("./tiles/tile_tree.dds")); break;
case tiletype_tree_top: t = asset_get(P("./tiles/tile_tree_top.dds")); break;
case tiletype_tree_top_left: t = asset_get(P("./tiles/tile_tree_top_left.dds")); break;
case tiletype_tree_top_right: t = asset_get(P("./tiles/tile_tree_top_right.dds")); break;
case tiletype_tree_topest: t = asset_get(P("./tiles/tile_tree_topest.dds")); break;
case tiletype_tree_bot_left: t = asset_get(P("./tiles/tile_tree_bot_left.dds")); break;
case tiletype_tree_bot_right: t = asset_get(P("./tiles/tile_tree_bot_right.dds")); break;
case tiletype_tree_junc_left: t = asset_get(P("./tiles/tile_tree_junc_left.dds")); break;
case tiletype_tree_junc_right: t = asset_get(P("./tiles/tile_tree_junc_right.dds")); break;
case tiletype_tree_turn_left: t = asset_get(P("./tiles/tile_tree_turn_left.dds")); break;
case tiletype_tree_turn_right: t = asset_get(P("./tiles/tile_tree_turn_right.dds")); break;
case tiletype_tree_side: t = asset_get(P("./tiles/tile_tree_side.dds")); break;
case tiletype_house_bot_left: t = asset_get(P("./tiles/tile_house_bot_left.dds")); break;
case tiletype_house_bot_right: t = asset_get(P("./tiles/tile_house_bot_right.dds")); break;
case tiletype_house_top_left: t = asset_get(P("./tiles/tile_house_top_left.dds")); break;
case tiletype_house_top_right: t = asset_get(P("./tiles/tile_house_top_right.dds")); break;
default: t = NULL;
}
return t;
}
