Model_Impl::Model_Impl()
{
update_vbo = true;
material_shininess = 64.0f;
material_emission = CL_Vec4f(0.0f, 0.0f, 0.0f, 1.0f);
material_ambient = CL_Vec4f(0.9f, 0.2f, 0.2f, 1.0f);
material_specular = CL_Vec4f(0.0f, 0.0f, 0.0f, 1.0f);
}
void CL_RenderBatch2D::modelview_changed(const CL_Mat4f &new_modelview)
{
modelview = new_modelview;
x_dir = CL_Vec2f(modelview * CL_Vec4f(1.0f, 0.0f, 1.0f, 1.0f));
y_dir = CL_Vec2f(modelview * CL_Vec4f(0.0f, 1.0f, 1.0f, 1.0f));
origin = CL_Vec2f(modelview * CL_Vec4f(0.0f, 0.0f, 1.0f, 1.0f));
x_dir -= origin;
y_dir -= origin;
}
Model_Impl::Model_Impl()
{
vbo_size = 0;
material_shininess = 64.0f;
material_emission = CL_Vec4f(0.0f, 0.0f, 0.0f, 1.0f);
material_ambient = CL_Vec4f(0.9f, 0.2f, 0.2f, 1.0f);
material_specular = CL_Vec4f(0.0f, 0.0f, 0.0f, 1.0f);
}
Model_Impl::Model_Impl()
{
vbo_size = 0;
generate_texture_coords = true;
material_shininess = 64.0f;
material_emission = CL_Vec4f(0.0f, 0.0f, 0.0f, 1.0f);
material_ambient = CL_Vec4f(0.9f, 0.2f, 0.2f, 1.0f);
material_specular = CL_Vec4f(0.0f, 0.0f, 0.0f, 1.0f);
}
CL_Vec4f CL_SoftwareProgram_Standard::get_attribute_default(int index)
{
switch (index)
{
case 0:
return CL_Vec4f(0.0f, 0.0f, 1.0f, 1.0f);
case 1:
return CL_Vec4f(1.0f, 1.0f, 1.0f, 1.0f);
case 2:
return CL_Vec4f(0.0f, 0.0f, 0.0f, 0.0f);
case 3:
default:
return CL_Vec4f(0.0f, 0.0f, 0.0f, 0.0f);
}
}
void CL_RenderBatch3D::draw_image(CL_GraphicContext &gc, const CL_Rectf &src, const CL_Rectf &dest, const CL_Colorf &color, const CL_Texture &texture)
{
int texindex = set_batcher_active(gc, texture);
vertices[position+0].position = to_position(dest.left, dest.top);
vertices[position+1].position = to_position(dest.right, dest.top);
vertices[position+2].position = to_position(dest.left, dest.bottom);
vertices[position+3].position = to_position(dest.right, dest.top);
vertices[position+4].position = to_position(dest.right, dest.bottom);
vertices[position+5].position = to_position(dest.left, dest.bottom);
float src_left = (src.left)/tex_sizes[texindex].width;
float src_top = (src.top) / tex_sizes[texindex].height;
float src_right = (src.right)/tex_sizes[texindex].width;
float src_bottom = (src.bottom) / tex_sizes[texindex].height;
vertices[position+0].texcoord = CL_Vec2f(src_left, src_top);
vertices[position+1].texcoord = CL_Vec2f(src_right, src_top);
vertices[position+2].texcoord = CL_Vec2f(src_left, src_bottom);
vertices[position+3].texcoord = CL_Vec2f(src_right, src_top);
vertices[position+4].texcoord = CL_Vec2f(src_right, src_bottom);
vertices[position+5].texcoord = CL_Vec2f(src_left, src_bottom);
for (int i=0; i<6; i++)
{
vertices[position+i].color = CL_Vec4f(color.r, color.g, color.b, color.a);
vertices[position+i].texindex.x = (float)texindex;
}
position += 6;
}
ShaderDepth::ShaderDepth(CL_GraphicContext &gc)
{
CL_ShaderObject vertex_shader(gc, cl_shadertype_vertex, vertex);
if(!vertex_shader.compile())
{
throw CL_Exception(cl_format("Unable to compile vertex shader object: %1", vertex_shader.get_info_log()));
}
CL_ShaderObject fragment_shader(gc, cl_shadertype_fragment, fragment);
if(!fragment_shader.compile())
{
throw CL_Exception(cl_format("Unable to compile fragment shader object: %1", fragment_shader.get_info_log()));
}
program_object = CL_ProgramObject(gc);
program_object.attach(vertex_shader);
program_object.attach(fragment_shader);
program_object.bind_attribute_location(0, "InPosition");
if (!program_object.link())
{
throw CL_Exception(cl_format("Unable to link program object: %1", program_object.get_info_log()));
}
material_updated = false;
material_ambient = CL_Vec4f(0.9f, 0.2f, 0.2f, 1.0f);
}
void CL_Draw::gradient_fill(CL_GraphicContext &gc, float x1, float y1, float x2, float y2, const CL_Gradient &gradient)
{
CL_Vec2f positions[6] =
{
CL_Vec2f(x1, y1),
CL_Vec2f(x2, y1),
CL_Vec2f(x1, y2),
CL_Vec2f(x2, y1),
CL_Vec2f(x1, y2),
CL_Vec2f(x2, y2)
};
#define cl_color_to_color4d(c) c.get_red(), c.get_green(), c.get_blue(), c.get_alpha()
CL_Vec4f colors[6] =
{
CL_Vec4f(cl_color_to_color4d(gradient.top_left)),
CL_Vec4f(cl_color_to_color4d(gradient.top_right)),
CL_Vec4f(cl_color_to_color4d(gradient.bottom_left)),
CL_Vec4f(cl_color_to_color4d(gradient.top_right)),
CL_Vec4f(cl_color_to_color4d(gradient.bottom_left)),
CL_Vec4f(cl_color_to_color4d(gradient.bottom_right))
};
CL_PrimitivesArray prim_array(gc);
prim_array.set_attributes(0, positions);
prim_array.set_attributes(1, colors);
gc.set_program_object(cl_program_color_only);
gc.draw_primitives(cl_triangles, 6, prim_array);
gc.reset_program_object();
}
ShaderColor::ShaderColor(CL_GraphicContext &gc)
{
CL_ShaderObject vertex_shader(gc, cl_shadertype_vertex, vertex);
if(!vertex_shader.compile())
{
throw CL_Exception(cl_format("Unable to compile vertex shader object: %1", vertex_shader.get_info_log()));
}
CL_ShaderObject fragment_shader(gc, cl_shadertype_fragment, fragment);
if(!fragment_shader.compile())
{
throw CL_Exception(cl_format("Unable to compile fragment shader object: %1", fragment_shader.get_info_log()));
}
program_object = CL_ProgramObject(gc);
program_object.attach(vertex_shader);
program_object.attach(fragment_shader);
program_object.bind_attribute_location(0, "InPosition");
program_object.bind_attribute_location(1, "InNormal");
if (!program_object.link())
{
throw CL_Exception(cl_format("Unable to link program object: %1", program_object.get_info_log()));
}
material_updated = false;
light_updated = false;
material_shininess = 64.0f;
material_emission = CL_Vec4f(0.0f, 0.0f, 0.0f, 1.0f);
material_ambient = CL_Vec4f(1.0f, 0.0f, 0.0f, 1.0f);
material_specular = CL_Vec4f(0.0f, 0.0f, 0.0f, 1.0f);
light_vector = CL_Vec3f(0.0f, 0.0f, 1.0f);
light_specular = CL_Vec4f(0.7f, 0.7f, 0.7f, 1.0f);
light_diffuse = CL_Vec4f(0.7f, 0.7f, 0.7f, 1.0f);
spot_light_updated = false;
}
Shader::Shader(CL_GraphicContext &gc)
{
CL_ShaderObject vertex_shader(gc, cl_shadertype_vertex, vertex);
if(!vertex_shader.compile())
{
throw CL_Exception(cl_format("Unable to compile vertex shader object: %1", vertex_shader.get_info_log()));
}
CL_ShaderObject fragment_shader(gc, cl_shadertype_fragment, fragment);
if(!fragment_shader.compile())
{
throw CL_Exception(cl_format("Unable to compile fragment shader object: %1", fragment_shader.get_info_log()));
}
program_object = CL_ProgramObject(gc);
program_object.attach(vertex_shader);
program_object.attach(fragment_shader);
program_object.bind_attribute_location(cl_attrib_position, "InPosition");
program_object.bind_attribute_location(cl_attrib_normal, "InNormal");
program_object.bind_attribute_location(cl_attrib_color, "InMaterialAmbient");
program_object.bind_attribute_location(cl_attrib_texture_position, "InTextureCoords");
if (!program_object.link())
{
throw CL_Exception(cl_format("Unable to link program object: %1", program_object.get_info_log()));
}
material_shininess = 64.0f;
material_emission = CL_Vec4f(0.0f, 0.0f, 0.0f, 1.0f);
material_specular = CL_Vec4f(0.0f, 0.0f, 0.0f, 1.0f);
light_position = CL_Vec3f(0.0f, 0.0f, 1.0f);
light_specular = CL_Vec4f(0.7f, 0.7f, 0.7f, 1.0f);
light_diffuse = CL_Vec4f(0.7f, 0.7f, 0.7f, 1.0f);
}
void CL_RenderBatch3D::fill(CL_GraphicContext &gc, float x1, float y1, float x2, float y2, const CL_Colorf &color)
{
int texindex = set_batcher_active(gc);
vertices[position+0].position = to_position(x1, y1);
vertices[position+1].position = to_position(x2, y1);
vertices[position+2].position = to_position(x1, y2);
vertices[position+3].position = to_position(x2, y1);
vertices[position+4].position = to_position(x2, y2);
vertices[position+5].position = to_position(x1, y2);
for (int i=0; i<6; i++)
{
vertices[position+i].color = CL_Vec4f(color.r, color.g, color.b, color.a);
vertices[position+i].texcoord = CL_Vec2f(0.0f, 0.0f);
vertices[position+i].texindex.x = (float)texindex;
}
position += 6;
}
// 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)
{
CL_OpenGLWindowDescription win_desc;
//win_desc.set_version(3, 2, false);
win_desc.set_allow_resize(true);
win_desc.set_title("Point Sprite Example");
win_desc.set_size(CL_Size( 800, 480 ), false);
CL_DisplayWindow window(win_desc);
CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close);
CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up);
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);
CL_GraphicContext gc = window.get_gc();
// Deleted automatically by the GUI
Options *options = new Options(gui, CL_Rect(0, 0, gc.get_size()));
CL_Image image_grid(gc, "../Blend/Resources/grid.png");
CL_Texture texture_particle(gc, "Resources/particle.png");
float grid_width = (float) image_grid.get_width();
float grid_height = (float) image_grid.get_height();
grid_space = (float) (image_grid.get_width());
setup_particles();
CL_ShaderObject vertex_shader(gc, cl_shadertype_vertex, text_shader_vertex);
if(!vertex_shader.compile())
{
throw CL_Exception(cl_format("Unable to compile vertex shader object: %1", vertex_shader.get_info_log()));
}
CL_ShaderObject fragment_shader(gc, cl_shadertype_fragment, text_shader_fragment);
if(!fragment_shader.compile())
{
throw CL_Exception(cl_format("Unable to compile fragment shader object: %1", fragment_shader.get_info_log()));
}
CL_ProgramObject program_object(gc);
program_object.attach(vertex_shader);
program_object.attach(fragment_shader);
program_object.bind_attribute_location(0, "InPosition");
program_object.bind_attribute_location(1, "InColor");
if (!program_object.link())
{
throw CL_Exception(cl_format("Unable to link program object: %1", program_object.get_info_log()));
}
options->request_repaint();
unsigned int time_last = CL_System::get_time();
while (!quit)
{
unsigned int time_now = CL_System::get_time();
float time_diff = (float) (time_now - time_last);
time_last = time_now;
wm.process();
wm.draw_windows(gc);
int num_particles = options->num_particles;
if (num_particles > max_particles)
num_particles = max_particles;
move_particles(time_diff, num_particles);
const float grid_xpos = 10.0f;
const float grid_ypos = 10.0f;
// Draw the grid
image_grid.draw(gc, grid_xpos, grid_ypos);
if (num_particles > 0)
{
std::vector<CL_Vec2f> positions;
std::vector<CL_Vec4f> colors;
positions.resize(num_particles);
colors.resize(num_particles);
for (int cnt=0; cnt<num_particles; cnt++)
{
positions[cnt] = CL_Vec2f(grid_xpos + particles[cnt].xpos, grid_ypos + particles[cnt].ypos);
switch (cnt % 3)
{
case 0:
colors[cnt] = CL_Vec4f(1.0f, 0.0f, 0.0f, 1.0f);
break;
case 1:
colors[cnt] = CL_Vec4f(0.0f, 1.0f, 0.0f, 1.0f);
break;
case 2:
colors[cnt] = CL_Vec4f(0.0f, 0.0f, 1.0f, 1.0f);
break;
}
};
CL_BlendMode blend;
blend.enable_blending(true);
blend.set_blend_function(cl_blend_src_alpha, cl_blend_one, cl_blend_src_alpha, cl_blend_one);
gc.set_blend_mode(blend);
CL_Pen pen;
pen.enable_point_sprite(true);
pen.set_point_size(options->point_size);
pen.set_point_sprite_origin(cl_point_sprite_origin_upper_left);
gc.set_pen(pen);
program_object.set_uniform1i("Texture0", 0);
gc.set_texture(0, texture_particle);
CL_PrimitivesArray prim_array(gc);
prim_array.set_attributes(0, &positions[0]);
prim_array.set_attributes(1, &colors[0]);
gc.set_program_object(program_object);
gc.draw_primitives(cl_points, num_particles, prim_array);
gc.reset_program_object();
gc.reset_texture(0);
gc.reset_blend_mode();
gc.reset_pen();
}
window.flip(1);
CL_KeepAlive::process();
}
return 0;
}
void CL_Draw::gradient_circle(CL_GraphicContext &gc, const CL_Pointf ¢er, const CL_Pointf ¢ergradient, float radius, const CL_Gradient &gradient)
{
float offset_x = 0;
float offset_y = 0;
if(radius < 4)
radius = 4;
float rotationcount = (radius - 3);
float halfpi = 1.5707963267948966192313216916398f;
float turn = halfpi / rotationcount;
if(center.distance(center + centergradient) < radius)
{
offset_x = centergradient.x;
offset_y = -centergradient.y;
}
CL_Vec4f colors[3] =
{
CL_Vec4f(gradient.top_left.get_red(), gradient.top_left.get_green(), gradient.top_left.get_blue(), gradient.top_left.get_alpha()),
CL_Vec4f(gradient.bottom_right.get_red(), gradient.bottom_right.get_green(), gradient.bottom_right.get_blue(), gradient.bottom_right.get_alpha()),
CL_Vec4f(gradient.bottom_right.get_red(), gradient.bottom_right.get_green(), gradient.bottom_right.get_blue(), gradient.bottom_right.get_alpha())
};
CL_Vec4f triangle_colors[4*3];
for (int i=0; i<3; i++)
{
triangle_colors[0*3+i] = colors[i];
triangle_colors[1*3+i] = colors[i];
triangle_colors[2*3+i] = colors[i];
triangle_colors[3*3+i] = colors[i];
}
for(float i = 0; i < rotationcount ; i++)
{
float pos1 = cos(i * turn);
float pos2 = sin(i * turn);
float pos3 = cos((i+1) * turn);
float pos4 = sin((i+1) * turn);
CL_Vec2f positions[4*3] =
{
// 90 triangle:
CL_Vec2f(center.x + offset_x , center.y + offset_y),
CL_Vec2f(center.x + ((float)radius * pos1), center.y + ((float)radius * pos2)),
CL_Vec2f(center.x + ((float)radius * pos3), center.y + ((float)radius * pos4)),
// 0 triangle:
CL_Vec2f(center.x + offset_x , center.y + offset_y),
CL_Vec2f(center.x + ((float)radius * pos2), center.y - ((float)radius * pos1)),
CL_Vec2f(center.x + ((float)radius * pos4), center.y - ((float)radius * pos3)),
// 270 triangle:
CL_Vec2f(center.x + offset_x , center.y + offset_y),
CL_Vec2f(center.x - ((float)radius * pos1), center.y - ((float)radius * pos2)),
CL_Vec2f(center.x - ((float)radius * pos3), center.y - ((float)radius * pos4)),
// 180 triangle:
CL_Vec2f(center.x + offset_x , center.y + offset_y),
CL_Vec2f(center.x - ((float)radius * pos2), center.y + ((float)radius * pos1)),
CL_Vec2f(center.x - ((float)radius * pos4), center.y + ((float)radius * pos3))
};
CL_PrimitivesArray prim_array(gc);
prim_array.set_attributes(0, positions);
prim_array.set_attributes(1, triangle_colors);
gc.set_program_object(cl_program_color_only);
gc.draw_primitives(cl_triangles, 4*3, prim_array);
gc.reset_program_object();
}
}
// The start of the Application
int App::start(const std::vector<CL_String> &args)
{
quit = false;
CL_GL1WindowDescription desc;
desc.set_title("ClanLib Object 3D Example");
desc.set_size(CL_Size(640, 480), 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
// 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();
#ifdef USE_OPENGL_1
CL_GraphicContext_GL1 gc_gl1 = gc;
#endif
// 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);
CL_BufferControl buffer_control;
buffer_control.enable_depth_test(true);
buffer_control.set_depth_compare_function(cl_comparefunc_lequal);
buffer_control.enable_depth_write(true);
gc.set_buffer_control(buffer_control);
#ifdef USE_OPENGL_1
// Set the lights
CL_LightModel_GL1 light_model;
light_model.enable_lighting(true);
light_model.set_flat_shading(false);
light_model.set_scene_ambient_light(CL_Colorf(0.2f, 0.2f, 0.2f, 1.0f));
gc_gl1.set_light_model(light_model);
CL_LightSource_GL1 light_distant;
light_distant.set_spot_cutoff(180.0f);
light_distant.set_diffuse_intensity(CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f));
light_distant.set_position(CL_Vec4f(0.0f, -2.0f, 30.0f, 0.0f).normalize3());
gc_gl1.set_light(0, light_distant);
cl1Enable(GL_NORMALIZE);
#endif
#ifdef USE_OPENGL_2
Shader shader(gc);
#endif
// Create the objects
aiSetImportPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE,89.53f);
const struct aiScene* scene_teapot = aiImportFile("../Clan3D/Resources/teapot.dae",aiProcessPreset_TargetRealtime_MaxQuality);
if (!scene_teapot)
throw CL_Exception("Cannot load the teapot model");
const struct aiScene* scene_clanlib = aiImportFile("../Clan3D/Resources/clanlib.dae",aiProcessPreset_TargetRealtime_MaxQuality);
if (!scene_clanlib)
throw CL_Exception("Cannot load the clanlib model");
const struct aiScene* scene_tuxball = aiImportFile("../Clan3D/Resources/tux_ball.dae",aiProcessPreset_TargetRealtime_MaxQuality | aiProcess_FlipUVs);
if (!scene_tuxball)
throw CL_Exception("Cannot load the tux ball model");
// Load the texture
CL_Texture tux(gc, "../Clan3D/Resources/tux.png");
float angle = 0.0f;
// Run until someone presses escape
while (!quit)
{
CL_Mat4f perp = CL_Mat4f::perspective(45.0f, ((float) gc.get_width()) / ((float) gc.get_height()), 0.1f, 1000.0f);
gc.set_projection(perp);
gc.clear(CL_Colorf::black);
gc.clear_depth(1.0f);
angle += 1.0f;
if (angle >= 360.0f)
angle -= 360.0f;
#ifdef USE_OPENGL_2
shader.Set(gc);
shader.Use(gc);
#else
gc.set_program_object(cl_program_color_only);
#endif
CL_PrimitivesArray prim_array(gc);
gc.set_modelview(CL_Mat4f::identity());
gc.mult_scale(1.0f,1.0f, -1.0f); // So +'ve Z goes into the screen
gc.mult_translate(0.0f, 0.0f, 2.0f);
gc.mult_rotate(CL_Angle(angle, cl_degrees), 0.0f, 1.0f, 0.0f, false);
gc.push_modelview();
recursive_render(gc, scene_teapot, scene_teapot->mRootNode, false);
gc.pop_modelview();
gc.push_modelview();
gc.mult_scale(0.5f, 0.5f, 0.5f);
gc.mult_translate(0.0f, -0.5f, 0.0f);
recursive_render(gc, scene_clanlib, scene_clanlib->mRootNode, false);
gc.pop_modelview();
#ifdef USE_OPENGL_2
shader.Set(gc, 0);
shader.Use(gc);
#else
gc.set_program_object(cl_program_single_texture);
#endif
gc.set_texture(0, tux);
gc.set_modelview(CL_Mat4f::identity());
gc.mult_scale(1.0f,1.0f, -1.0f); // So +'ve Z goes into the screen
gc.mult_translate(0.7f, 0.5f, 2.0f);
gc.mult_scale(0.05f, 0.05f, 0.05f);
gc.mult_rotate(CL_Angle(angle * 4.0f, cl_degrees), 0.0f, 1.0f, 0.0f, false);
recursive_render(gc, scene_tuxball, scene_tuxball->mRootNode, true);
gc.reset_texture(0);
gc.reset_program_object();
// 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();
}
aiReleaseImport(scene_tuxball);
aiReleaseImport(scene_clanlib);
aiReleaseImport(scene_teapot);
aiDetachAllLogStreams();
return 0;
}
void App::create_scene(CL_GraphicContext &gc)
{
Model model_teapot(gc, "../Clan3D/Resources/teapot.dae", true);
Model model_landscape(gc, "Resources/land.dae", false);
Model model_tree(gc, "Resources/tree.dae", false);
Model model_gear(gc, "../Clan3D/Resources/gear.dae", false);
model_teapot.SetMaterial(
32.0f, // shininess
CL_Vec4f(0.0f, 0.0f, 0.0f, 1.0f), // emission
CL_Vec4f(1.5f, 1.5f, 0.5f, 1.0f), // ambient
CL_Vec4f(0.5f, 0.5f, 0.5f, 1.0f) ); // specular
camera = new SceneObject(scene, scene.base);
camera->position = CL_Vec3f(0.0f, 50.0f, -20.0f);
camera->rotation_y = CL_Angle(0.0f, cl_degrees);
camera->scale = CL_Vec3f(1.0f, 1.0f, 1.0f);
light = new SceneObject(scene, scene.base);
light->position = CL_Vec3f(-20.4732f, 48.7872f, -20.5439f);
light->rotation_y = CL_Angle(45.0f, cl_degrees);
light->rotation_x = CL_Angle(35.0f, cl_degrees);
light->scale = CL_Vec3f(1.0f, 1.0f, 1.0f);
SceneObject *object_landscape = new SceneObject(scene, scene.base);
object_landscape->model = model_landscape;
object_landscape->position = CL_Vec3f(0.0f, 0.0f, 0.0f);
object_teapot1 = new SceneObject(scene, object_landscape);
object_teapot1->model = model_teapot;
object_teapot1->position = CL_Vec3f(-8.2f, 37.3f, 8.0f);
object_teapot1->scale = CL_Vec3f(8.0f, 8.0f, 8.0f);
object_teapot2 = new SceneObject(scene, object_landscape);
object_teapot2->model = model_teapot;
object_teapot2->position = CL_Vec3f(2.0f, 40.0f, 1.0f);
object_teapot2->scale = CL_Vec3f(8.0f, 8.0f, 8.0f);
SceneObject *object_tree = new SceneObject(scene, object_landscape);
object_tree->model = model_tree;
object_tree->position = CL_Vec3f(-7.2701f, 25.58f, -9.0932f);
object_tree = new SceneObject(scene, object_landscape);
object_tree->model = model_tree;
object_tree->position = CL_Vec3f(-11.829f, 25.8125f, 0.0f);
object_tree = new SceneObject(scene, object_landscape);
object_tree->model = model_tree;
object_tree->position = CL_Vec3f(-5.0f, 27.6963f, 0.0f);
object_tree = new SceneObject(scene, object_landscape);
object_tree->model = model_tree;
object_tree->position = CL_Vec3f(0.0f, 29.4237f, 0.0f);
object_gear = new SceneObject(scene, object_landscape);
object_gear->model = model_gear;
object_gear->position = CL_Vec3f(10.0f, 40.58f, 10.0);
object_gear->scale = CL_Vec3f(3.0f, 3.0f, 3.0f);
scene.gs->LoadImages(gc);
}
