void CL_GUIComponent::render(CL_GraphicContext &gc, const CL_Rect &clip_rect, bool include_children)
{
if (!impl->visible)
return;
if (!impl->css_layout.is_null())
{
impl->css_layout.layout(gc, get_size());
impl->css_layout.render(gc, this);
}
if (impl->func_render.is_null() == false)
{
impl->func_render.invoke(gc, clip_rect);
}
else
{
CL_GUIThemePart part(this);
CL_Rect geometry = get_size();
part.render_box(gc, CL_RectPS(0, 0, geometry.get_width(), geometry.get_height()), clip_rect);
}
if (include_children)
{
if (impl->clip_children)
{
push_cliprect(gc, impl->clip_children_rect);
}
CL_GUIComponent *cur = impl->first_child;
while (cur)
{
CL_Rect cur_geometry = cur->get_geometry();
CL_Rect update_rect = component_to_window_coords(clip_rect);
update_rect.overlap(component_to_window_coords(cur_geometry));
if (update_rect.get_width() > 0 && update_rect.get_height() > 0)
{
CL_Rect child_dirty_rect = cur->window_to_component_coords(update_rect);
gc.push_translate((float)cur_geometry.left, (float)cur_geometry.top);
cur->render(gc, child_dirty_rect, true);
gc.pop_modelview();
}
cur = cur->impl->next_sibling;
}
if (impl->clip_children)
{
pop_cliprect(gc);
}
}
}
void ExampleText::draw_text(CL_GraphicContext &gc, CL_Texture &texture, CL_Angle angle)
{
gc.set_texture(0, texture);
gc.push_modelview();
gc.mult_translate(gc.get_width()/2.0f, gc.get_height()/2.0f);
gc.mult_rotate(angle, 0.0f, 0.0f, 1.0f);
CL_Draw::texture(gc, CL_Rectf(-300.0f, -300.0f, 300.0f, 300.0f), CL_Colorf(1.0f, 1.0f, 1.0f, 0.7f));
gc.pop_modelview();
gc.reset_texture(0);
}
void ShaderImpl::end(CL_GraphicContext &p_gc)
{
G_ASSERT(m_initialized);
G_ASSERT(m_began);
// detach frame buffer
p_gc.reset_frame_buffer();
m_frameBuffer.detach_color_buffer(0, m_texture);
// prepare shader
m_program.set_uniform1i("tex", 0);
m_program.set_uniform1i("textureWidth", m_drawRect.get_width());
m_program.set_uniform1i("textureHeight", m_drawRect.get_height());
m_parent->setUniforms(m_program);
// draw texture using shader
p_gc.set_modelview(CL_Mat4f::identity());
p_gc.mult_translate(m_drawRect.left, m_drawRect.top);
p_gc.mult_scale(m_drawRect.get_width(), m_drawRect.get_height());
p_gc.set_texture(0, m_texture);
p_gc.set_program_object(m_program);
p_gc.draw_primitives(cl_quads, 4, m_quad);
p_gc.reset_program_object();
p_gc.reset_texture(0);
#if defined(DRAW_WIREFRAME)
CL_Draw::line(p_gc, 0, 0, 1, 0, CL_Colorf::red);
CL_Draw::line(p_gc, 1, 0, 1, 1, CL_Colorf::red);
CL_Draw::line(p_gc, 1, 1, 0, 1, CL_Colorf::red);
CL_Draw::line(p_gc, 0, 1, 0, 0, CL_Colorf::red);
#endif // DRAW_WIREFRAME
// reset modelview matrix
p_gc.pop_modelview();
m_began = false;
}
void PlayerList::draw(CL_GraphicContext &p_gc)
{
const Race::Level &level = m_impl->m_logic->getLevel();
const int carCount = level.getCarCount();
float h = 0.0f;
p_gc.mult_translate(m_impl->m_position.x, m_impl->m_position.y);
for (int i = 0; i < carCount; ++i) {
const Race::Car &car = level.getCar(i);
m_impl->m_label.setPosition(CL_Pointf(0, h));
m_impl->m_label.setText(cl_format("%1. %2", i + 1, m_impl->m_logic->getPlayer(car).getName())); // FIXME: not optimal
m_impl->m_label.draw(p_gc);
h += m_impl->m_labelHeight;
}
p_gc.pop_modelview();
}
void Sandpit::draw(CL_GraphicContext &p_gc)
{
assert(m_built);
if (m_texture.is_null()) {
// create texture
m_texture = CL_SharedPtr<CL_Texture>(
new CL_Texture(
p_gc,
m_pixelData->get_width(), m_pixelData->get_height()
)
);
m_texture->set_image(*m_pixelData);
}
p_gc.set_texture(0, *m_texture);
CL_Rectf drawRect(0, 0, m_pixelData->get_width(), m_pixelData->get_height());
p_gc.push_translate(m_position.x, m_position.y);
CL_Draw::texture(p_gc, drawRect, CL_Colorf::white);
p_gc.pop_modelview();
}
bool TextShooter::draw(CL_GraphicContext &gc, unsigned int current_time)
{
int time_delta = current_time - start_time;
if (time_delta < 0) // Not on screen
return true;
if (time_delta >= duration) // Reached destination
return false;
CL_Vec3f current_position;
// Get position
current_position.x = start_position.x + (((end_position.x - start_position.x) * time_delta) / duration);
current_position.y = start_position.y + (((end_position.y - start_position.y) * time_delta) / duration);
current_position.z = start_position.z + (((end_position.z - start_position.z) * time_delta) / duration);
// Get fade towards end
float font_alpha = (float) (duration - time_delta);
font_alpha /= end_fade_time;
if (font_alpha > 1.0f) font_alpha = 1.0f;
// Get initial white colour setting
float font_white = (float) time_delta;
font_white /= initial_white_time;
if (font_white > 1.0f) font_white = 1.0f;
font_white = 1.0f - font_white;
// Calculate color
CL_Colorf font_color;
if (use_red_component)
{
font_color.r = 1.0f;
}
else
{
font_color.r = font_white;
}
if (use_green_component)
{
font_color.g = 1.0f;
}
else
{
font_color.g = font_white;
}
if (use_blue_component)
{
font_color.b = 1.0f;
}
else
{
font_color.b = font_white;
}
font_color.a = font_alpha;
// Draw the text
gc.push_translate(current_position.x, current_position.y, current_position.z);
gc.push_scale( 2.0f / gc.get_width(), -2.0f / gc.get_height());
CL_Size text_size = vector_font.get_text_size(gc, text);
vector_font.draw_text(gc, -text_size.width/2, text_size.height/4, text, font_color);
gc.pop_modelview();
gc.pop_modelview();
return true;
}
void Viewport::finalizeGC(CL_GraphicContext &p_gc) {
p_gc.pop_modelview();
}
// 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::recursive_render(CL_GraphicContext &gc, const struct aiScene *sc, const struct aiNode* nd, bool use_texture_coords)
{
int i;
unsigned int n = 0, t;
struct aiMatrix4x4 m = nd->mTransformation;
// update transform
aiTransposeMatrix4(&m);
gc.push_modelview();
gc.mult_modelview((float*)&m);
// draw all meshes assigned to this node
for (; n < nd->mNumMeshes; ++n)
{
const struct aiMesh* mesh = sc->mMeshes[nd->mMeshes[n]];
if (mesh->mNormals == NULL)
throw CL_Exception("This example expects normals to be set");
std::vector<CL_Vec3f> normals;
std::vector<CL_Vec3f> vertices;
std::vector<CL_Vec3f> tex_coords;
normals.reserve(mesh->mNumFaces * 3);
vertices.reserve(mesh->mNumFaces * 3);
if (use_texture_coords)
{
if (mesh->mTextureCoords == NULL || mesh->mTextureCoords[0] == NULL)
throw CL_Exception("This example expects texcoords to be set for this object");
tex_coords.reserve(mesh->mNumFaces * 3);
}
for (t = 0; t < mesh->mNumFaces; ++t)
{
const struct aiFace* face = &mesh->mFaces[t];
if (face->mNumIndices != 3)
throw CL_Exception("This example only supports triangles");
for(i = 0; i < face->mNumIndices; i++)
{
int index = face->mIndices[i];
normals.push_back(&mesh->mNormals[index].x);
vertices.push_back( &mesh->mVertices[index].x);
if (use_texture_coords)
tex_coords.push_back( &mesh->mTextureCoords[0][index].x);
}
}
if (!vertices.empty())
{
CL_PrimitivesArray prim_array(gc);
prim_array.set_attributes(cl_attrib_position, &vertices[0]);
prim_array.set_attribute(cl_attrib_color, CL_Colorf::white);
prim_array.set_attributes(cl_attrib_normal, &normals[0]);
if (use_texture_coords)
prim_array.set_attributes(cl_attrib_texture_position, &tex_coords[0]);
gc.draw_primitives(cl_triangles, vertices.size(), prim_array);
}
}
// draw all children
for (n = 0; n < nd->mNumChildren; ++n)
{
recursive_render(gc, sc, nd->mChildren[n], use_texture_coords);
}
gc.pop_modelview();
}
// The start of the Application
int App::start(const std::vector<CL_String> &args)
{
CL_DisplayWindowDescription win_desc;
win_desc.set_allow_resize(true);
win_desc.set_title("Vertex Buffer Object Example");
win_desc.set_depth_size(16);
win_desc.set_size(CL_Size( 800, 600 ), 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_GraphicContext gc = window.get_gc();
Shader shader(gc);
// 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);
std::vector<CL_Vec3f> object_positions;
std::vector<CL_Vec3f> object_normals;
std::vector<CL_Vec4f> object_material_ambient;
const int num_cubes = 20000;
object_positions.reserve(num_cubes * 6 * 6); // 6 faces, and 6 vertices per face
object_normals.reserve(num_cubes * 6 * 6);
object_material_ambient.reserve(num_cubes * 6 * 6);
for (int cnt=0; cnt < num_cubes; cnt++)
{
create_cube(object_positions, object_normals, object_material_ambient);
}
CL_VertexArrayBuffer vb_positions(gc, &object_positions[0], sizeof(CL_Vec3f) * object_positions.size());
CL_VertexArrayBuffer vb_normals(gc, &object_normals[0], sizeof(CL_Vec3f) * object_normals.size());
CL_VertexArrayBuffer vb_material_ambient(gc, &object_material_ambient[0], sizeof(CL_Vec4f) * object_material_ambient.size());
// ** Note, at this point "object_positions, object_normals and object_material_ambient"
// ** can be destroyed. But for the purpose of this example, is it kept
CL_Font fps_font(gc, "tahoma", 20);
FramerateCounter frameratecounter;
unsigned int time_last = CL_System::get_time();
float angle = 0.0f;
is_vertex_buffer_on = true;
while (!quit)
{
unsigned int time_now = CL_System::get_time();
float time_diff = (float) (time_now - time_last);
time_last = time_now;
gc.clear(CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f));
gc.clear_depth(1.0f);
gc.set_map_mode(cl_map_2d_upper_left);
CL_String fps = cl_format("%1 fps", frameratecounter.get_framerate());
fps_font.draw_text(gc, gc.get_width() - 100, 30, fps);
CL_String info = cl_format("%1 vertices", (int) object_positions.size());
fps_font.draw_text(gc, 30, 30, info);
fps_font.draw_text(gc, 30, gc.get_height() - 8, "Press any key to toggle the Vertex Buffer option");
if (is_vertex_buffer_on)
{
fps_font.draw_text(gc, 200, 30, "Vertex Buffer = ON");
}
else
{
fps_font.draw_text(gc, 200, 30, "Vertex Buffer = OFF");
}
gc.set_map_mode(cl_user_projection);
CL_Mat4f perp = CL_Mat4f::perspective(45.0f, ((float) gc.get_width()) / ((float) gc.get_height()), 0.1f, 100000.0f);
gc.set_projection(perp);
angle += time_diff / 20.0f;
if (angle >= 360.0f)
angle -= 360.0f;
gc.push_modelview();
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, 800.0f);
gc.mult_rotate(CL_Angle(angle*2.0f, cl_degrees), 0.0f, 1.0f, 0.0f, false);
gc.mult_rotate(CL_Angle(angle, cl_degrees), 1.0f, 0.0f, 0.0f, false);
shader.Set(gc);
shader.Use(gc);
CL_PrimitivesArray prim_array(gc);
if (is_vertex_buffer_on)
{
prim_array.set_attributes(0, vb_positions, 3, cl_type_float, (void *) 0);
prim_array.set_attributes(1, vb_normals, 3, cl_type_float, (void *) 0);
prim_array.set_attributes(2, vb_material_ambient, 4, cl_type_float, (void *) 0);
}
else
{
prim_array.set_attributes(0, &object_positions[0]);
prim_array.set_attributes(1, &object_normals[0]);
prim_array.set_attributes(2, &object_material_ambient[0]);
}
gc.draw_primitives(cl_triangles, object_positions.size(), prim_array);
gc.pop_modelview();
gc.reset_program_object();
window.flip(0);
frameratecounter.frame_shown();
CL_KeepAlive::process();
}
return 0;
}
