GLXContext CL_OpenGLWindowProvider_GLX::create_context_glx_1_3_helper(GLXContext shared_context, int major_version, int minor_version, const CL_OpenGLWindowDescription &gldesc, ptr_glXCreateContextAttribs glXCreateContextAttribs) { std::vector<int> int_attributes; int_attributes.push_back(0x2091); // GLX_CONTEXT_MAJOR_VERSION_ARB int_attributes.push_back(major_version); int_attributes.push_back(0x2092); // GLX_CONTEXT_MINOR_VERSION_ARB int_attributes.push_back(minor_version); // Layer plane does not exist on GLX - http://www.opengl.org/registry/specs/ARB/glx_create_context.txt //int_attributes.push_back(0x2093); // GLX_CONTEXT_LAYER_PLANE_ARB //int_attributes.push_back(gldesc.get_layer_plane()); int_attributes.push_back(0x2094); // GLX_CONTEXT_FLAGS_ARB int flags = 0; if (gldesc.get_debug()) flags |= 0x1; // GLX_CONTEXT_DEBUG_BIT_ARB if (gldesc.get_forward_compatible()) // GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB flags |= 0x2; int_attributes.push_back(flags); int_attributes.push_back(0x9126); // GLX_CONTEXT_PROFILE_MASK_ARB flags = 0; if (gldesc.get_core_profile()) flags |= 0x1; // GLX_CONTEXT_CORE_PROFILE_BIT_ARB if (gldesc.get_compatibility_profile()) // GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB flags |= 0x2; int_attributes.push_back(flags); int_attributes.push_back(None); cl_ctxErrorOccurred = false; GLXContext context_gl3 = glXCreateContextAttribs(x11_window.get_display(), fbconfig, shared_context, True, &int_attributes[0]); if (cl_ctxErrorOccurred) { if (context_gl3) { glx.glXDestroyContext(x11_window.get_display(), context_gl3); context_gl3 = 0; } } return context_gl3; }
GLXContext CL_OpenGLWindowProvider_GLX::create_context_glx_1_2(const CL_OpenGLWindowDescription &gl_desc, GLXContext shared_context) { if (gl_desc.get_allow_lower_versions() == false) throw CL_Exception("GLX 1.2 does not support opengl version selection."); GLXContext context; context = glx.glXCreateContext(x11_window.get_display(), opengl_visual_info, shared_context, GL_TRUE); if(context == NULL) throw CL_Exception("glXCreateContext failed"); return context; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; CL_OpenGLWindowDescription desc; desc.set_title("ClanLib Light Surface Example"); desc.set_size(CL_Size(900, 700), true); desc.set_multisampling(4); desc.set_allow_resize(true); desc.set_depth_size(16); CL_DisplayWindow window(desc); // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); // Connect a keyboard handler to on_key_up() CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); // Set up GUI CL_String theme; if (CL_FileHelp::file_exists("../../../Resources/GUIThemeAero/theme.css")) theme = "../../../Resources/GUIThemeAero"; else if (CL_FileHelp::file_exists("../../../Resources/GUIThemeBasic/theme.css")) theme = "../../../Resources/GUIThemeBasic"; else throw CL_Exception("No themes found"); CL_GUIWindowManagerTexture wm(window); CL_GUIManager gui(wm, theme); // Get the graphic context CL_GraphicContext gc = window.get_gc(); // Deleted automatically by the GUI Options *options = new Options(gui, CL_Rect(8, 8, CL_Size(340, 600))); options->request_repaint(); // Setup graphic store GraphicStore graphic_store(gc); scene.gs = &graphic_store; // Prepare the display gc.set_map_mode(cl_user_projection); CL_PolygonRasterizer polygon_rasterizer; polygon_rasterizer.set_culled(true); polygon_rasterizer.set_face_cull_mode(cl_cull_back); polygon_rasterizer.set_front_face(cl_face_side_clockwise); gc.set_polygon_rasterizer(polygon_rasterizer); create_scene(gc); CL_Font font(gc, "tahoma", 24); graphic_store.image_grid = CL_Image(gc, "../../Display_Render/Blend/Resources/grid.png"); FramerateCounter framerate_counter; unsigned int time_last = CL_System::get_time(); // Run until someone presses escape while (!quit) { framerate_counter.frame_shown(); unsigned int time_now = CL_System::get_time(); time_delta = time_now - time_last; time_last = time_now; // Copy direction options light_distant->rotation_y = options->light_direction_heading; light_distant->rotation_x = options->light_direction_pitch; // Set material options float shininess = options->material_shininess; // Convert shininess from a percentage, using Lightwave 3d's method shininess = shininess / 100.0f; shininess = pow(2, (10.0f * shininess) + 2); teapot->model.SetMaterial( shininess, // material_shininess CL_Vec4f(options->material_emission_color.r, options->material_emission_color.g, options->material_emission_color.b, options->material_emission_color.a), // material_emission CL_Vec4f(options->material_ambient_color.r, options->material_ambient_color.g, options->material_ambient_color.b, options->material_ambient_color.a), // material_ambient CL_Vec4f(options->material_specular_color.r, options->material_specular_color.g, options->material_specular_color.b, options->material_specular_color.a) //material_specular ); rotate_teapot(); calculate_matricies(gc); update_light(gc, options); polygon_rasterizer.set_culled(true); gc.set_polygon_rasterizer(polygon_rasterizer); render(gc); gc.set_modelview(CL_Mat4f::identity()); gc.set_map_mode(cl_map_2d_upper_left); polygon_rasterizer.set_culled(false); gc.set_polygon_rasterizer(polygon_rasterizer); CL_String fps(cl_format("%1 fps", framerate_counter.get_framerate())); font.draw_text(gc, 16-2, gc.get_height()-16-2, fps, CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f)); font.draw_text(gc, 16, gc.get_height()-16-2, fps, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); wm.process(); wm.draw_windows(gc); // Use flip(1) to lock the fps window.flip(0); // This call processes user input and other events CL_KeepAlive::process(); } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; CL_OpenGLWindowDescription desc; desc.set_title("ClanLib Geometry Shader Example"); desc.set_size(CL_Size(900, 700), true); desc.set_multisampling(0); desc.set_allow_resize(false); desc.set_depth_size(16); desc.set_version(3, 2, false); CL_DisplayWindow window(desc); // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); // Connect a keyboard handler to on_key_up() CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); // Get the graphic context CL_GraphicContext gc = window.get_gc(); // Setup graphic store GraphicStore graphic_store(gc); scene.gs = &graphic_store; // Prepare the display gc.set_map_mode(cl_user_projection); CL_PolygonRasterizer polygon_rasterizer; polygon_rasterizer.set_culled(false); polygon_rasterizer.set_face_cull_mode(cl_cull_back); polygon_rasterizer.set_front_face(cl_face_side_clockwise); gc.set_polygon_rasterizer(polygon_rasterizer); create_scene(gc); camera_angle = 0.0f; CL_Font font(gc, "tahoma", 24); FramerateCounter framerate_counter; unsigned int time_last = CL_System::get_time(); // Run until someone presses escape while (!quit) { framerate_counter.frame_shown(); unsigned int time_now = CL_System::get_time(); time_delta = time_now - time_last; time_last = time_now; control_camera(); calculate_matricies(gc); gc.set_polygon_rasterizer(polygon_rasterizer); gc.clear_depth(1.0f); // ** If enabling below, change the graphic from alpha_ball2.png to alpha_ball.png in graphic_store.cpp //render_depth_buffer(gc); // Render to depth buffer first, to fake sorting the particles render(gc); // Render scene gc.set_modelview(CL_Mat4f::identity()); gc.set_map_mode(cl_map_2d_upper_left); CL_String fps(cl_format("fps = %1", framerate_counter.get_framerate())); font.draw_text(gc, 16-2, gc.get_height()-16-2, fps, CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f)); font.draw_text(gc, 16, gc.get_height()-16-2, fps, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); CL_String info(cl_format("Drawing %1 particles", ParticleObject::num_points)); font.draw_text(gc, 16, 30, info); // Use flip(1) to lock the fps window.flip(0); // This call processes user input and other events CL_KeepAlive::process(); } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; try { CL_OpenGLWindowDescription desc; desc.set_title("ClanLib AnimCursor Test"); desc.set_size(CL_Size(800, 600), true); CL_DisplayWindow window(desc); // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); // Connect a keyboard handler to on_key_up() CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); // Get the graphic context CL_GraphicContext gc = window.get_gc(); CL_Font font = CL_Font(gc, "Tahoma", 20); CL_PixelBuffer pacman("pacman.png"); CL_SpriteDescription description; CL_Size size(22, 22); for (int frame_cnt=0; frame_cnt < 6; frame_cnt++) { CL_PixelBuffer frame(size.width, size.height, cl_rgba8); pacman.convert(frame, size, CL_Rect((frame_cnt * 28) + 4, 4, size)); description.add_frame(frame); description.set_frame_delay(frame_cnt, 0.1); } CL_Point hotspot(0,0); CL_Cursor cursor(window, description, hotspot); window.set_cursor(cursor); // Run until someone presses escape while (!quit) { gc.clear(CL_Colorf(0.0f,0.0f,0.5f)); font.draw_text(gc, 32, 32, "Observe the animated cursor"); // Flip the display, showing on the screen what we have drawed // since last call to flip() window.flip(1); // This call processes user input and other events CL_KeepAlive::process(); } } catch(CL_Exception& exception) { // Create a console window for text-output if not available CL_ConsoleWindow console("Console", 80, 200); CL_Console::write_line("Exception caught:"); CL_Console::write_line(exception.message); // Display the stack trace (if available) std::vector<CL_String> stacktrace = exception.get_stack_trace(); int size = stacktrace.size(); if (size > 0) { CL_Console::write_line("Stack Trace:"); for (int cnt=0; cnt < size; cnt++) { CL_Console::write_line(stacktrace[cnt]); } } console.display_close_message(); return -1; } return 0; }
int App::start(const std::vector<CL_String> &args) { CL_OpenGLWindowDescription description; description.set_title("NightVision Shader"); description.set_size(CL_Size(1024, 768), true); CL_DisplayWindow window(description); CL_InputDevice keyboard = window.get_ic().get_keyboard(); CL_GraphicContext gc = window.get_gc(); CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); CL_Slot slot_window_close = window.sig_window_close().connect(this, &App::window_close); // Create offscreen texture CL_Texture texture_offscreen(gc, gc.get_width(), gc.get_height()); texture_offscreen.set_min_filter(cl_filter_nearest); texture_offscreen.set_mag_filter(cl_filter_nearest); CL_Texture texture_mask(gc, gc.get_width(), gc.get_height()); texture_mask.set_min_filter(cl_filter_nearest); texture_mask.set_mag_filter(cl_filter_nearest); // Create offscreen framebuffer CL_FrameBuffer framebuffer_offscreen(gc); framebuffer_offscreen.attach_color_buffer(0, texture_offscreen); CL_FrameBuffer framebuffer_mask(gc); framebuffer_mask.attach_color_buffer(0, texture_mask); CL_Image background(gc, "../PostProcessing/Resources/background.png"); CL_Image ball(gc, "../PostProcessing/Resources/ball.png"); ball.set_alignment(origin_center); CL_Texture noise_texture(gc, "Resources/noise_texture_0001.png"); noise_texture.set_wrap_mode(cl_wrap_repeat, cl_wrap_repeat); // Load and link shaders CL_ProgramObject shader = CL_ProgramObject::load(gc, "Resources/vertex_shader.glsl", "Resources/fragment_shader.glsl"); shader.bind_attribute_location(0, "Position"); shader.bind_attribute_location(2, "TexCoord0"); if (!shader.link()) throw CL_Exception("Unable to link shader program: Error:" + shader.get_info_log()); quit = false; float amount = 0.0f; float timer = 0.0f; float scale = 1.0f; CL_Font font(gc, "tahoma", 32); // Shader based on: http://www.geeks3d.com/20091009/shader-library-night-vision-post-processing-filter-glsl/ elapsedTime = 0.0f; // seconds luminanceThreshold = 0.2f; colorAmplification = 4.0f; effectCoverage = 0.65f; // Render the mask gc.set_frame_buffer(framebuffer_mask); gc.clear(); for (float offset=0.0f; offset<=1.0f; offset+=0.01f) { CL_Draw::circle(gc, gc.get_width() / 2.0f, gc.get_height() / 2.0f, 400.0f - offset * 64.0f, CL_Colorf(offset, offset, offset, 1.0f)); } gc.reset_frame_buffer(); unsigned int startTime = CL_System::get_time(); while (!quit) { timer = (CL_System::get_time() - startTime) / 1000.0f; elapsedTime = timer; // Render standard image to offscreen buffer gc.set_frame_buffer(framebuffer_offscreen); background.draw(gc, 0, 0); ball.draw(gc, gc.get_width() / 2 + 200 * sinf(timer / 2.0f), gc.get_height() / 2 + 200 * cosf(timer / 2.0f)); gc.reset_frame_buffer(); render_night_vision(gc, texture_offscreen, texture_mask, noise_texture, shader); const int gap = 32; font.draw_text(gc, 10, 64+gap*0, CL_String("luminanceThreshold : " + CL_StringHelp::float_to_text(luminanceThreshold) + " (Press Q,W)" )); font.draw_text(gc, 10, 64+gap*1, CL_String("colorAmplification : " + CL_StringHelp::float_to_text(colorAmplification) + " (Press A,S)" )); font.draw_text(gc, 10, 64+gap*2, CL_String("effectCoverage : " + CL_StringHelp::float_to_text(effectCoverage) + " (Press Z,X)" )); window.flip(); CL_System::sleep(10); CL_KeepAlive::process(); } return 0; }
GLXContext CL_OpenGLWindowProvider_GLX::create_context_glx_1_3(const CL_OpenGLWindowDescription &gl_desc, GLXContext shared_context) { GLXContext context; context = glx.glXCreateNewContext(x11_window.get_display(), fbconfig, GLX_RGBA_TYPE, shared_context, True); if(context == NULL) throw CL_Exception("glXCreateContext failed"); ptr_glXCreateContextAttribs glXCreateContextAttribs = NULL; if (is_glx_extension_supported("GLX_ARB_create_context")) { if (glx.glXGetProcAddressARB) glXCreateContextAttribs = (ptr_glXCreateContextAttribs) glx.glXGetProcAddressARB((GLubyte*) "glXCreateContextAttribsARB"); if (glx.glXGetProcAddress) glXCreateContextAttribs = (ptr_glXCreateContextAttribs) glx.glXGetProcAddress((GLubyte*) "glXCreateContextAttribsARB"); } if (glXCreateContextAttribs) { // Install an X error handler so the application won't exit if GL 3.0 context allocation fails. // // Note this error handler is global. All display connections in all threads // of a process use the same error handler, so be sure to guard against other // threads issuing X commands while this code is running. int (*oldHandler)(Display*, XErrorEvent*) = XSetErrorHandler(&cl_ctxErrorHandler); GLXContext context_gl3 = 0; int gl_major = gl_desc.get_version_major(); int gl_minor = gl_desc.get_version_minor(); if (gl_desc.get_allow_lower_versions() == false) { context_gl3 = create_context_glx_1_3_helper(shared_context, gl_major, gl_minor, gl_desc, glXCreateContextAttribs); if (!context_gl3) throw CL_Exception(cl_format("This application requires OpenGL %1.%2 or above. Try updating your drivers, or upgrade to a newer graphics card.", gl_major, gl_minor)); } else { static const char opengl_version_list[] = { // Clanlib supported version pairs 4,1, 4,0, 3,3, 3,2, 3,1, 3,0, 0,0, // End of list }; const char *opengl_version_list_ptr = opengl_version_list; do { int major = *(opengl_version_list_ptr++); if (major == 0) break; int minor = *(opengl_version_list_ptr++); // Find the appropriate version in the list if (major > gl_major) continue; if (major == gl_major) { if (minor > gl_minor) continue; } context_gl3 = create_context_glx_1_3_helper(shared_context, gl_major, gl_minor, gl_desc, glXCreateContextAttribs); }while(!context_gl3); } // Restore the original error handler XSetErrorHandler( oldHandler ); if (context_gl3) { glx.glXDestroyContext(x11_window.get_display(), context); context = context_gl3; } } return context; }
int App::start(const std::vector<CL_String> &args) { CL_OpenGLWindowDescription description; description.set_title("Guassian Blur Shader"); description.set_size(CL_Size(1024, 768), true); CL_DisplayWindow window(description); CL_InputDevice keyboard = window.get_ic().get_keyboard(); CL_GraphicContext gc = window.get_gc(); CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); CL_Slot slot_window_close = window.sig_window_close().connect(this, &App::window_close); // Create offscreen texture CL_Texture texture_offscreen(gc, gc.get_width(), gc.get_height()); texture_offscreen.set_min_filter(cl_filter_nearest); texture_offscreen.set_mag_filter(cl_filter_nearest); CL_Texture texture_offscreen2(gc, gc.get_width(), gc.get_height()); texture_offscreen2.set_min_filter(cl_filter_nearest); texture_offscreen2.set_mag_filter(cl_filter_nearest); // Create offscreen framebuffer CL_FrameBuffer framebuffer_offscreen(gc); framebuffer_offscreen.attach_color_buffer(0, texture_offscreen); CL_FrameBuffer framebuffer_offscreen2(gc); framebuffer_offscreen2.attach_color_buffer(0, texture_offscreen2); CL_Image background(gc, "../PostProcessing/Resources/background.png"); CL_Image ball(gc, "../PostProcessing/Resources/ball.png"); ball.set_alignment(origin_center); // Load and link shaders CL_ProgramObject shader = CL_ProgramObject::load(gc, "Resources/vertex_shader.glsl", "Resources/fragment_shader.glsl"); shader.bind_attribute_location(0, "Position"); shader.bind_attribute_location(2, "TexCoord0"); if (!shader.link()) throw CL_Exception("Unable to link shader program: Error:" + shader.get_info_log()); quit = false; float amount = 0.0f; float timer = 0.0f; float scale = 1.0f; CL_Font font(gc, "tahoma", 32); blur = 1.0f; unsigned int startTime = CL_System::get_time(); while (!quit) { timer = (CL_System::get_time() - startTime) / 1000.0f; // Render standard image to offscreen buffer gc.set_frame_buffer(framebuffer_offscreen); background.draw(gc, 0, 0); ball.draw(gc, gc.get_width() / 2 + 200 * sinf(timer / 2.0f), gc.get_height() / 2 + 200 * cosf(timer / 2.0f)); gc.reset_frame_buffer(); gc.set_frame_buffer(framebuffer_offscreen2); render_gaussian_blur(gc, blur, texture_offscreen, shader, 1.0f / texture_offscreen2.get_width(), 0.0f); gc.reset_frame_buffer(); render_gaussian_blur(gc, blur, texture_offscreen2, shader, 0.0f, 1.0f / texture_offscreen2.get_height()); CL_String text( "Press 1 to 9 to control blur amount. Currently it is :" + CL_StringHelp::float_to_text(blur) ); font.draw_text(gc, 10, 64, text); window.flip(); CL_System::sleep(10); CL_KeepAlive::process(); } return 0; }
int App::start(const std::vector<CL_String> &args) { CL_OpenGLWindowDescription description; description.set_title("GLSL Test"); description.set_size(CL_Size(1024, 768), true); CL_DisplayWindow window(description); CL_InputDevice keyboard = window.get_ic().get_keyboard(); CL_GraphicContext gc = window.get_gc(); CL_Slot slot_window_close = window.sig_window_close().connect(this, &App::window_close); // Load and link shaders CL_ProgramObject shader = CL_ProgramObject::load(gc, "Resources/vertex_shader.glsl", "Resources/fragment_shader.glsl"); shader.bind_attribute_location(0, "Position"); if (!shader.link()) throw CL_Exception("Unable to link shader program: Error:" + shader.get_info_log()); quit = false; while (!keyboard.get_keycode(CL_KEY_ESCAPE) && !quit ) { gc.clear(); gc.set_program_object(shader, cl_program_matrix_modelview_projection); //shader.set_uniform1i("SourceTexture", 0); int xpos = 0; int size = 16; int gap = size + 2; //-------- Test 1 CL_Mat2f matrix2_a = CL_Mat2f(3, 1, 2, 4); CL_Mat2f matrix2_b = CL_Mat2f(-3, 7, 2, 5); CL_Mat2f matrix2_result = CL_Mat2f::multiply(matrix2_a, matrix2_b); CL_Mat2f matrix2_a_temp = matrix2_a; if (CL_Mat2i(matrix2_result) != CL_Mat2i(matrix2_a * matrix2_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 1); shader.set_uniform_matrix("matrix2_a", matrix2_a); shader.set_uniform_matrix("matrix2_b", matrix2_b); shader.set_uniform_matrix("matrix2_result", matrix2_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 2 CL_Mat3f matrix3_a = CL_Mat3f(3, 1, 2, 4, 5 ,6, 4, 2, 1); CL_Mat3f matrix3_b = CL_Mat3f(4, 7, 2, 5, 3, 5, 2, 9, 3); CL_Mat3f matrix3_result = CL_Mat3f::multiply(matrix3_a, matrix3_b); CL_Mat3f matrix3_a_temp = matrix3_a; if (CL_Mat3i(matrix3_result) != CL_Mat3i(matrix3_a * matrix3_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 2); shader.set_uniform_matrix("matrix3_a", matrix3_a); shader.set_uniform_matrix("matrix3_b", matrix3_b); shader.set_uniform_matrix("matrix3_result", matrix3_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 3 static float test_a_values[] = {3, 1, 2, 4, 5 ,6, 4, 2, 1, 4, 6, 7, 6, 3, 7, 2}; static float test_b_values[] = {4, 7, 2, 5, 3, 5, 2, 9, 3, 3, 6, 9, 2, 4, 6, 2}; CL_Mat4f matrix4_a = CL_Mat4f(test_a_values); CL_Mat4f matrix4_b = CL_Mat4f(test_b_values); CL_Mat4f matrix4_result = CL_Mat4f::multiply(matrix4_a, matrix4_b); CL_Mat4f matrix4_a_temp = matrix4_a; if (CL_Mat4i(matrix4_result) != CL_Mat4i(matrix4_a * matrix4_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 3); shader.set_uniform_matrix("matrix4_a", matrix4_a); shader.set_uniform_matrix("matrix4_b", matrix4_b); shader.set_uniform_matrix("matrix4_result", matrix4_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 4 matrix2_result = CL_Mat2f::subtract(matrix2_a, matrix2_b); matrix2_a_temp = matrix2_a; if (CL_Mat2i(matrix2_result) != CL_Mat2i(matrix2_a - matrix2_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 4); shader.set_uniform_matrix("matrix2_a", matrix2_a); shader.set_uniform_matrix("matrix2_b", matrix2_b); shader.set_uniform_matrix("matrix2_result", matrix2_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 5 matrix3_result = CL_Mat3f::subtract(matrix3_a, matrix3_b); matrix3_a_temp = matrix3_a; if (CL_Mat3i(matrix3_result) != CL_Mat3i(matrix3_a - matrix3_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 5); shader.set_uniform_matrix("matrix3_a", matrix3_a); shader.set_uniform_matrix("matrix3_b", matrix3_b); shader.set_uniform_matrix("matrix3_result", matrix3_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 6 matrix4_result = CL_Mat4f::subtract(matrix4_a, matrix4_b); matrix4_a_temp = matrix4_a; if (CL_Mat4i(matrix4_result) != CL_Mat4i(matrix4_a - matrix4_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 6); shader.set_uniform_matrix("matrix4_a", matrix4_a); shader.set_uniform_matrix("matrix4_b", matrix4_b); shader.set_uniform_matrix("matrix4_result", matrix4_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 7 CL_Vec2f vector2_a(2,3); CL_Vec2f vector2_result = vector2_a * matrix2_a; shader.set_uniform1i("test_id", 7); shader.set_uniform_matrix("matrix2_a", matrix2_a); shader.set_uniform2f("vector2_a", vector2_a); shader.set_uniform2f("vector2_result", vector2_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 8 vector2_result = matrix2_a * vector2_a; shader.set_uniform1i("test_id", 8); shader.set_uniform_matrix("matrix2_a", matrix2_a); shader.set_uniform2f("vector2_a", vector2_a); shader.set_uniform2f("vector2_result", vector2_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 9 CL_Vec3f vector3_a(3,5,6); CL_Vec3f vector3_result = vector3_a * matrix3_a; shader.set_uniform1i("test_id", 9); shader.set_uniform_matrix("matrix3_a", matrix3_a); shader.set_uniform3f("vector3_a", vector3_a); shader.set_uniform3f("vector3_result", vector3_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 10 vector3_result = matrix3_a * vector3_a; shader.set_uniform1i("test_id", 10); shader.set_uniform_matrix("matrix3_a", matrix3_a); shader.set_uniform3f("vector3_a", vector3_a); shader.set_uniform3f("vector3_result", vector3_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 11 CL_Vec4f vector4_a(4,3,5,6); CL_Vec4f vector4_result = vector4_a * matrix4_a; shader.set_uniform1i("test_id", 11); shader.set_uniform_matrix("matrix4_a", matrix4_a); shader.set_uniform4f("vector4_a", vector4_a); shader.set_uniform4f("vector4_result", vector4_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 12 vector4_result = matrix4_a * vector4_a; shader.set_uniform1i("test_id", 12); shader.set_uniform_matrix("matrix4_a", matrix4_a); shader.set_uniform4f("vector4_a", vector4_a); shader.set_uniform4f("vector4_result", vector4_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; gc.reset_program_object(); window.flip(); CL_System::sleep(10); CL_KeepAlive::process(); } return 0; }
void mainloop() { CL_OpenGLWindowDescription desc; desc.set_size( CL_Size( 1024, 768 ), true ); CL_DisplayWindow wnd(desc); CL_GraphicContext gc = wnd.get_gc(); glMatrixMode(GL_PROJECTION); //hello // gluPerspective(45, //view angle // 1.0, //aspect ratio // 10.0, //near clip // 200.0);//far clip GLfloat matrix[16]; glhPerspectivef2(matrix, 45, 1.0, 10.0, 200.0 ); glLoadMatrixf( matrix ); glMatrixMode(GL_MODELVIEW); cube c; float rotateBy; CL_Font font(gc, "Helvetica", 24); GUI gui(&wnd); while( true ) { rotateBy += 1; glEnable(GL_CULL_FACE); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); glTranslatef(0,0,-50); glRotatef(rotateBy,1,1,0); glBegin(GL_QUADS); c.redraw(); glEnd(); glPopMatrix(); glDisable( GL_CULL_FACE ); CL_Draw::line(gc, 0, 0, 100, 100, CL_Colorf( 1.0f ,1.0f ,1.0f )); font.draw_text( gc, 100, 100, "bla bla bla", CL_Colorf( 1.0f, 1.0f, 1.0f )); gui.run(&wnd); wnd.flip(); CL_System::sleep( 10 ); CL_KeepAlive::process(); } }
ortho() : pump_factor_(4) { // glVertexPointer(4, GL_FLOAT, 0, ptr); //glEnableClientState( GL_VERTEX_ARRAY ); // glColorPointer( //std::ifstream is( "cryistal-castle-hidden-ramp.txt" ); // std::ifstream is( "house1.txt" ); //std::ifstream is( "cryistal-castle-tree-wave.txt" ); // assert( is.good() ); // height_fields_ = crystal_bits::load_crystal(is, pump_factor_); // std::cout << "hf: " << height_fields_.size() << "\n"; // // // // scene_static_.init_solid(height_fields_); // // scene_static_.init_solid_from_crystal(is, pump_factor_); // scene_static_.init_planes(); // uint64_t scene_hash = scene_static_.hash(); // // try { // std::ifstream is( "ff.bin" ); // // // light_static_ = light_static( is, scene_hash ); // } catch( std::runtime_error x ) { // // std::cerr << "load failed. recreating. error:\n" << x.what() << std::endl; // // light_static_ = setup_formfactors(scene_static_.planes(), scene_static_.solid()); // } // // if( !false ) { // std::ofstream os( "ff.bin" ); // light_static_.write(os, scene_hash); // } // // // light_dynamic_ = light_dynamic(scene_static_.planes().size() ); CL_OpenGLWindowDescription desc; desc.set_size( CL_Size( 1024, 768 ), true ); desc.set_depth_size(16); //std::cout << "depth: " << desc.get_depth_size(); wnd_ = CL_DisplayWindow(desc); CL_GraphicContext_GL gc = wnd_.get_gc(); // //CL_Mat4f proj = CL_Mat4f::ortho( 0, 1024, 0, 768, 100, -100 ); gc.set_active(); #ifdef TEST_OPENCL try { init_opencl(); } catch( cl::Error x ) { // std::array<void*, 256> bt; // //void *bt[256]; // // size_t size = backtrace( bt.data(), bt.size() ); // char **strings = backtrace_symbols( bt.data(), size ); // std::cout << "backtrace: " << size << "\n"; // for( size_t i = 0; i < size; ++i ) { // std::cout << i << " " << strings[i] << "\n"; // } // free( strings ); std::cerr << "opencl initialization failed\ncall: " << x.what() << "\nerror code: " << cl_str_error( x.err() ) << "\n"; throw; } #endif // throw 0; glMatrixMode(GL_PROJECTION); //hello CL_Mat4f proj = CL_Mat4f::perspective( 60, 1.5, 2, 200 ); // CL_Mat4f proj = CL_Mat4f::ortho( -20.0 * pump_factor_, 20.0 * pump_factor_, -15.0 * pump_factor_, 15.0 * pump_factor_, 0, 200 ); //CL_Mat4f proj = CL_Mat4f::ortho( -40, 40, -30, 30, 0, 200 ); glLoadMatrixf( proj.matrix ); //CL_Texture tex(gc, 64, 64 ); struct texel { GLubyte col[3]; GLubyte alpha; texel() { col[0] = 128; col[1] = 128; col[2] = 128; alpha = 255; } }; std::array<texel,64 * 64> tex_data; glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 0.0); // glGenTextures(1, &texName); // glBindTexture(GL_TEXTURE_2D, texName); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex_data.data()); // gc.set_map_mode(cl_user_projection); // gc.set_projection(proj); // // gc.flush_batcher(); // glMatrixMode(GL_PROJECTION); glMatrixMode(GL_MODELVIEW); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthFunc(GL_LESS); glEnable(GL_TEXTURE_2D); glShadeModel(GL_FLAT); }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; CL_OpenGLWindowDescription desc; desc.set_title("ClanLib Shadow Example"); desc.set_size(CL_Size(640, 640), true); desc.set_multisampling(4); desc.set_depth_size(16); CL_DisplayWindow window(desc); #ifdef _DEBUG //struct aiLogStream stream; //stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL); //aiAttachLogStream(&stream); //stream = aiGetPredefinedLogStream(aiDefaultLogStream_FILE,"assimp_log.txt"); //aiAttachLogStream(&stream); #endif aiSetImportPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE,89.53f); // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); // Connect a keyboard handler to on_key_up() CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); // Get the graphic context CL_GraphicContext gc = window.get_gc(); GraphicStore graphic_store(gc); scene.gs = &graphic_store; // Prepare the display gc.set_map_mode(cl_user_projection); CL_PolygonRasterizer polygon_rasterizer; polygon_rasterizer.set_culled(true); polygon_rasterizer.set_face_cull_mode(cl_cull_back); polygon_rasterizer.set_front_face(cl_face_side_clockwise); gc.set_polygon_rasterizer(polygon_rasterizer); create_scene(gc); CL_FrameBuffer framebuffer(gc); CL_Texture new_depth_texture(gc, CL_Size(1024, 1024), cl_depth_component); new_depth_texture.set_wrap_mode(cl_wrap_clamp_to_edge, cl_wrap_clamp_to_edge, cl_wrap_clamp_to_edge); framebuffer.attach_depth_buffer(new_depth_texture); scene.gs->texture_shadow = new_depth_texture; camera_angle = 0.0f; CL_Font font(gc, "tahoma", 24); FramerateCounter framerate_counter; unsigned int time_last = CL_System::get_time(); // Run until someone presses escape while (!quit) { framerate_counter.frame_shown(); unsigned int time_now = CL_System::get_time(); time_delta = time_now - time_last; time_last = time_now; rotate_teapot(); control_camera(); update_light(gc); calculate_matricies(gc); render_from_lightsource(gc, framebuffer); render_from_camera(gc, framebuffer); gc.set_modelview(CL_Mat4f::identity()); gc.set_map_mode(cl_map_2d_upper_left); CL_String fps(cl_format("%1 fps", framerate_counter.get_framerate())); font.draw_text(gc, 16-2, gc.get_height()-16-2, fps, CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f)); font.draw_text(gc, 16, gc.get_height()-16-2, fps, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); // Use flip(1) to lock the fps window.flip(0); // This call processes user input and other events CL_KeepAlive::process(); } aiDetachAllLogStreams(); return 0; }