int frame_listener_test(float evt_time,float frame_time,int event_type)
{
tiny_timer+=frame_time;
camera_set_position(myCamera,
cos(tiny_timer / 10) * 1700,
2000,
sin(tiny_timer / 10) * 2100);
return 1;
}
void camera_set_zone(vec_t pos, float freezone,float elastic){
vec_t zone = vec_scale(vec_new(win_w/2,win_h/2),freezone);
vec_t newpos = cam_pos;
int lx = cam_pos.x - zone.x;
int rx = cam_pos.x + zone.x;
int by = cam_pos.y - zone.y;
int ty = cam_pos.y + zone.y;
if(pos.x < lx){
newpos.x -= (lx - pos.x)*elastic;
}
else if(pos.x > rx){
newpos.x += (pos.x - rx)*elastic;
}
if(pos.y < by){
newpos.y -= (by - pos.y)*elastic;
}else if (pos.y > ty){
newpos.y += (pos.y - ty)*elastic;
}
camera_set_position(newpos);
}
void init_graphic(void) {
global* global_handle = global_get_singleton();
config* config_handle = NULL;
config_alloc(&config_handle, "config/graphics.cfg");
int resx = config_get_int_value(config_handle, "resx");
int resy = config_get_int_value(config_handle, "resy");
int samples = config_get_int_value(config_handle, "msaa");
int windowed = config_get_int_value(config_handle, "windowed");
int vsync = config_get_int_value(config_handle, "vertical_sync");
config_free(&config_handle);
window* window_handle = NULL;
window_alloc(&window_handle, resx, resy, samples, !windowed, vsync, 1);
window_set_blend_mode(window_handle, WINDOW_BLEND_ALPHA);
window_set_clear_color(window_handle, 0.0f, 0.0f, 0.0f, 0.0f);
global_set(global_handle, GLOBAL_WINDOW, window_handle);
hl_render* hl_render_handle = NULL;
hl_render_alloc(&hl_render_handle);
global_set(global_handle, GLOBAL_HL_RENDER, hl_render_handle);
// effect* effect_motion_blur_handle = NULL;
// effect_alloc(&effect_motion_blur_handle, effect_motion_blur_init, effect_motion_blur_render, effect_motion_blur_config, effect_motion_blur_free, window_get_width(window_handle), window_get_height(window_handle));
// hl_render_add_effect(hl_render_handle, effect_motion_blur_handle, WINDOW_BLEND_ALPHA);
camera* camera_handle = NULL;
camera_alloc(&camera_handle);
camera_set_dimension(camera_handle, CAMERA_SIZE * (float) window_get_width(window_handle) / (float) window_get_height(window_handle), CAMERA_SIZE);
camera_set_position(camera_handle, 0.0f, 0.0f);
camera_update_matrices(camera_handle);
global_set(global_handle, GLOBAL_CAMERA, camera_handle);
shader* shader_texture_handle = NULL;
shader_alloc(&shader_texture_handle, SHADER_TEXTURE_VS, SHADER_TEXTURE_PS);
global_set(global_handle, GLOBAL_SHADER_TEXTURE, shader_texture_handle);
text* text_handle = NULL;
text_alloc(&text_handle, camera_handle, window_handle);
global_set(global_handle, GLOBAL_TEXT, text_handle);
input* input_handle = NULL;
input_alloc(&input_handle, window_handle);
global_set(global_handle, GLOBAL_INPUT, input_handle);
debug_draw* debug_draw_handle = NULL;
debug_draw_alloc(&debug_draw_handle, hl_render_handle);
global_set(global_handle, GLOBAL_DEBUG_DRAW, debug_draw_handle);
}
int main(int argc, char *argv[])
#endif
{
/* C90 requires all vars to be declared at top of function */
CoiHandle entity;
CoiHandle node;
CoiHandle light;
CoiHandle rendersystem;
CoiHandle renderwindow;
CoiHandle viewport;
CoiHandle plane;
CoiHandle plane_entity;
CoiHandle plane_node;
CoiHandle terrain_group;
CoiHandle terrain_iterator;
CoiHandle import_data;
CoiHandle image;
float direction[3];
float colour[4];
#if defined(LLCOI_TEST_USE_OPENINPUT)
// Openinput
oi_event evt;
char openinput_window_params[100];
unsigned int windowHnd = 0;
#if defined(PLATFORM_LINUX)
Display *disp;
Window win;
unsigned int scrn;
#endif
#endif //LLCOI_TEST_USE_OPENINPUT
keep_going = 1;
long loop_x = 0;
long loop_y = 0;
// setup
create_root("plugins.cfg", "ogre.cfg", "ogre.log");
if (!(restore_config() || show_config_dialog()))
{
return 1;
}
setup_resources("resources.cfg");
renderwindow = root_initialise(1, "Ogre Renderwindow");
set_default_num_mipmaps(5);
initialise_all_resource_groups();
create_scene_manager("OctreeSceneManager", "The SceneManager");
myCamera = create_camera(get_scene_manager(), "mycam");
camera_set_position(myCamera, 1683, 50, 2116);
camera_lookat(myCamera, 1963, -50, 1660);
camera_set_near_clip_distance(myCamera, 1);
camera_set_far_clip_distance(myCamera, 50000);
viewport = add_viewport(myCamera);
viewport_set_background_colour(viewport, 0, 0, 0);
camera_set_aspect_ratio(myCamera, 800, 600);
// entities
plane = create_plane_from_normal(0, 1, 0, 0);
mesh_manager_create_plane("ground", "General", plane, 1500, 1500, 20, 20, 1, 1, 5, 5, 0, 0, 1);
plane_entity = create_entity(get_scene_manager(), "plane", "ground");
entity_set_material_name(plane_entity, "Dev/Red");
plane_node = create_child_scene_node(get_scene_manager(), "planenode");
scene_node_attach_entity(plane_node, plane_entity);
entity = create_entity(get_scene_manager(), "OgreHead", "ogrehead.mesh");
node = create_child_scene_node(get_scene_manager(), "headNode");
scene_node_attach_entity(node, entity);
scene_manager_set_ambient_light_rgb(get_scene_manager(), 0.5f, 0.5f, 0.5f);
light = create_light(get_scene_manager(), "mainLight");
light_set_position(light, 20, 80, 50);
// terrain
create_terrain_global_options();
terrain_group = create_terrain_group(get_scene_manager(), ALIGN_X_Z, 513, 12000.0f);
terrain_group_set_filename_convention(terrain_group, "BasicTutorial3Terrain", "dat");
terrain_group_set_origin(terrain_group, 0, 0, 0);
// terrain defaults
terrain_global_options_set_max_pixel_error(8);
terrain_global_options_set_composite_map_distance(3000);
terrain_global_options_set_light_map_direction_vector3(light_get_derived_direction(light));
terrain_global_options_set_composite_map_ambient_colour(scene_manager_get_ambient_light(get_scene_manager()));// sm
terrain_global_options_set_composite_map_diffuse_colour(light_get_diffuse_colour(light));// light
import_data = terrain_group_get_default_import_settings(terrain_group);
terrain_group_import_data_set_terrain_size(import_data, 513);
terrain_group_import_data_set_world_size(import_data, 12000.0f);
terrain_group_import_data_set_input_scale(import_data, 600);
terrain_group_import_data_set_min_batch_size(import_data, 33);
terrain_group_import_data_set_max_batch_size(import_data, 65);
terrain_group_import_data_resize_layers(import_data, 3);
terrain_group_import_data_set_layer(import_data, 0, 100, "nvidia/dirt_grayrocky_diffusespecular.dds", "nvidia/dirt_grayrocky_normalheight.dds");
terrain_group_import_data_set_layer(import_data, 1, 30, "nvidia/grass_green-01_diffusespecular.dds", "nvidia/grass_green-01_normalheight.dds");
terrain_group_import_data_set_layer(import_data, 2, 200, "nvidia/growth_weirdfungus-03_diffusespecular.dds", "nvidia/growth_weirdfungus-03_normalheight.dds");
// define terrains
for (loop_x; loop_x <= 0; ++loop_x)
{
for (loop_y; loop_y <= 0; ++loop_y)
{
if (resource_exists(terrain_group_get_resource_group(terrain_group), terrain_group_generate_filename(terrain_group, loop_x, loop_y)))
{
terrain_group_define_terrain(terrain_group, loop_x, loop_y);
}
else
{
image = create_image();
image_load(image, "terrain.png");
if (loop_x % 2 != 0)
{
image_flip_around_y(image);
}
if (loop_y % 2 != 0)
{
image_flip_around_x(image);
}
terrain_group_define_terrain_image(terrain_group, loop_x, loop_y, image);
image_delete(image);
image = NULL;
}
}
}
terrain_group_load_all_terrains(terrain_group, 1);
// blend maps
/*
terrain_iterator = terrain_group_get_terrain_iterator(terrain_group);
while(terrain_iterator_has_more_elements(terrain_iterator))
{
CoiHandle terrain = terrain_iterator_get_next(terrain_iterator);
int blend_map_size = terrain_get_layer_blend_map_size(terrain);
CoiHandle blend_map_0 = terrain_get_layer_blend_map(terrain, 1);
CoiHandle blend_map_1 = terrain_get_layer_blend_map(terrain, 2);
float min_height_0 = 70;
float fade_dist_0 = 40;
float min_height_1 = 70;
float fade_dist_1 = 15;
float* blend_1 = terrain_layer_blend_map_get_blend_pointer(blend_map_1);
for(unsigned int y = 0; y < blend_map_size; ++y)
{
for(unsigned int x = 0; x < blend_map_size; ++x)
{
float tx, ty;
terrain_layer_blend_map_convert_image_to_terrain_space(x, y, &tx, &ty);
float height = terrain_get_height_at_terrain_position(tx, ty);
float val = (height - min_height_0) / fade_dist_0;
val = math_clamp_f(val, 0.0f, 1.0f);
val = (height - min_height_1) / fade_dist_1;
val = math_clamp_f(val, 0.0f, 1.0f);
*blend_1++ = val;
}
}
terrain_layer_blend_map_dirty(blend_map_0);
terrain_layer_blend_map_dirty(blend_map_1);
terrain_layer_blend_map_update(blend_map_0);
terrain_layer_blend_map_update(blend_map_1);
}
*/
terrain_group_free_temporary_resources(terrain_group);
// listeners
add_frame_listener(frame_listener_test,EVENT_FRAME_RENDERING_QUEUED|EVENT_FRAME_STARTED);
add_window_listener(renderwindow, window_event_listener_test);
input_manager = create_input_system(render_window_get_hwnd(renderwindow));
input_listener = create_input_listener();
keyboard = create_keyboard_object(input_manager, 1);
mouse = create_mouse_object(input_manager, 1);
attach_keyboard_listener(keyboard, input_listener);
attach_mouse_listener(mouse, input_listener);
add_key_pressed_listener(input_listener, key_pressed_test);
while(keep_going)
{
keyboard_capture(keyboard);
mouse_capture(mouse);
// Pump window messages for nice behaviour
pump_messages();
// Render a frame
render_one_frame();
if (render_window_closed(renderwindow))
{
keep_going = 0;
}
}
#if defined(LLCOI_TEST_USE_OPENINPUT)
windowHnd = render_window_get_hwnd(renderwindow);
#if defined(PLATFORM_LINUX)
disp = XOpenDisplay( NULL );
scrn = DefaultScreen(disp);
sprintf(openinput_window_params, "c:%u s:%u w:%u", (unsigned int)disp, (unsigned int)scrn, windowHnd);
#else
sprintf(openinput_window_params, "c:%u s:%u w:%u", 0, 0, windowHnd);
#endif
oi_init(openinput_window_params, 0);
log_message("***************************");
log_message("*** All Systems online! ***");
log_message("***************************");
//render_loop();
while (keep_going)
{
// ask oi to wait for events
oi_events_poll(&evt);
switch(evt.type)
{
case OI_QUIT:
// Quit
keep_going = 0;
break;
case OI_KEYDOWN:
// Keyboard button down
//WTF?? Better way to check this, please..
if(evt.key.keysym.sym == OIK_ESC)
keep_going = 0;
break;
default:
break;
}
// Pump window messages for nice behaviour
pump_messages();
// Render a frame
render_one_frame();
if (render_window_closed())
{
keep_going = 0;
}
}
oi_close();
#endif //LLCOI_TEST_USE_OPENINPUT
remove_window_listener(renderwindow);
destroy_keyboard_object(input_manager, keyboard);
destroy_mouse_object(input_manager, mouse);
destroy_input_system(input_manager);
release_engine();
return 0;
}
int main(void)
{
if(!glfwInit()) {
printf("Could not init GLFW");
getchar();
return -1;
}
glfwWindowHint(GLFW_SAMPLES, 4);
//Opengl 2.1
//glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
//glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
//Opengl 3.3
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // MacOS fix
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
if(window_init(&window, 640, 480, "Test")) {
fprintf( stderr, "Failed to open window.\n" );
getchar();
glfwTerminate();
};
window_set_size_callback(&window, window_size_callback);
glewExperimental = GL_TRUE; // Needed for core profile
if (glewInit() != GLEW_OK) {
fprintf(stderr, "Failed to initialize GLEW\n");
getchar();
glfwTerminate();
return -1;
}
//#clear errors GLEW may trigger
printError();
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
GLuint VertexArrayID;
glGenVertexArrays(1, &VertexArrayID);
glBindVertexArray(VertexArrayID);
//Load model
//----------
Model cube;
model_init(&cube);
model_set_data_length(&cube, sizeof(cube_vertex_data));
model_set_vertices(&cube, cube_vertex_data);
model_set_colors(&cube, cube_color_data);
model_set_uv_map(&cube, cube_uv_data);
model_set_texture(&cube, "./textures/bricks.dds");
model_bind(&cube);
//Create shaders
//--------------
GLuint vertexShader, fragmentShader;
loadShader(&vertexShader, GL_VERTEX_SHADER, mvpVertexShaderSource);
loadShader(&fragmentShader, GL_FRAGMENT_SHADER, fragmentShaderSource);
//Create program
//--------------
GLuint program;
createProgram(&program, vertexShader, fragmentShader);
// Enable z-buffer
// ---------------
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
// Enable culling
// --------------
glEnable(GL_CULL_FACE);
// Get MVP uniform
// ---------------
GLuint mvp_ul = glGetUniformLocation(program, "MVP");
// Model Matrix
// ------------
Mat4 s;
scale_m4(&s, 0.1f, 0.1f, 0.1f);
printf("Scale:\n");
print_m4(&s);
Mat4 r;
rotate_m4(&r, 0.0f, 1.0f, 0.0f, 0.0f);
printf("Rotate:\n");
print_m4(&r);
Mat4 t;
translate_m4(&t, 0.0f, 0.0f, 0.0f);
printf("Translate:\n");
print_m4(&t);
Mat4 rs;
printf("Rotated*Scaled:\n");
mul_m4(&rs, &r, &s);
print_m4(&rs);
Mat4 model;
printf("Model:\n");
mul_m4(&model, &t, &rs);
print_m4(&model);
// Camera
// ------
Vec3 pos;
Vec3 center;
Vec3 up;
Vec3 direction;
Vec3 right;
camera_init(&camera);
camera_set_fov(&camera, 1.0f);
camera_set_aspect(&camera, (float)window.width/(float)window.height);
Input input;
input_init(&input, &window, 0.5f, 0.5f, 0.8f, -5.7f, -2.7f);
do {
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glUseProgram(program);
input_get_data(&input, &pos, &direction, &right);
add_v3(¢er, &pos, &direction);
cross_v3(&up, &direction, &right);
camera_set_position(&camera, &pos);
camera_set_center(&camera, ¢er);
camera_set_up(&camera, &up);
// Mvp Matrix
// ----------
Mat4 vp;
camera_get_matrix(&camera, &vp);
Mat4 mvp;
mul_m4(&mvp, &vp, &model);
printf("Perspective:\n");
print_m4(&mvp);
// Set MVP transform
glUniformMatrix4fv(mvp_ul, 1, GL_TRUE, &mvp[0][0]);
model_render(&cube);
window_swap_buffers(&window);
glfwPollEvents();
} while(
glfwGetKey(window.handle, GLFW_KEY_ESCAPE ) != GLFW_PRESS &&
glfwWindowShouldClose(window.handle) == 0
);
// Dispose
// -------
model_dispose(&cube);
glDeleteVertexArrays(1, &VertexArrayID);
glDetachShader(program, fragmentShader);
glDetachShader(program, vertexShader);
glDeleteShader(fragmentShader);
glDeleteShader(vertexShader);
glDeleteProgram(program);
glfwTerminate();
return 0;
}
