void ClipRectManager::clamp(const CL_Vec2f& topleftBase, const CL_Size& sizeBase) {
if (forceRepaint_) {
CL_Rectf rect(topleftBase.x, topleftBase.y, CL_Sizef(sizeBase.width, sizeBase.height));
rectangles_.clear();
rectangles_.push_back(rect);
} else if (rectangles_.empty()) {
return;
}
std::vector<CL_Rectf> clamped;
CL_Rectf clampRect(topleftBase.x, topleftBase.y, CL_Sizef(sizeBase.width, sizeBase.height));
std::vector<CL_Rectf>::iterator iter = rectangles_.begin();
std::vector<CL_Rectf>::iterator end = rectangles_.end();
for (; iter != end; ++iter) {
if (clampRect.is_overlapped(*iter)) {
bool addedWithExpand = false;
CL_Rectf curClamped = iter->clip(clampRect);
float curClampedArea = curClamped.get_width() * curClamped.get_height();
// check for overlaps to keep number of rectangles as small as possible
std::vector<CL_Rectf>::iterator mergeIter = clamped.begin();
std::vector<CL_Rectf>::iterator mergeEnd = clamped.end();
for (; mergeIter != mergeEnd; ++mergeIter) {
if (mergeIter->is_overlapped(curClamped)) {
CL_Rectf bounding = CL_Rectf(*mergeIter).bounding_rect(curClamped);
CL_Rectf overlap = CL_Rectf(*mergeIter).overlap(curClamped);
// area of the bounding rectangle should not be too big. keep the rects seperate if joining them does not give a significant advantage
float unnecessaryIncluded =
(bounding.get_width() * bounding.get_height())
- (mergeIter->get_width() * mergeIter->get_height() + curClampedArea)
+ (overlap.get_width() * overlap.get_height());
if (unnecessaryIncluded <= curClampedArea * 3) {
mergeIter->bounding_rect(curClamped);
addedWithExpand = true;
break;
}
}
}
if (!addedWithExpand) {
clamped.push_back(curClamped);
}
}
}
rectangles_ = clamped;
}
CL_Rectf
ObjMapSpriteObjectImpl::get_bound_rect() const
{
CL_Point align = CL_Point(0, 0);
CL_Origin origin_e;
sprite.get_alignment(origin_e, align.x, align.y);
CL_Point origin = calc_origin(origin_e, CL_Size(sprite.get_width(),
sprite.get_height()));
align.x = -align.x;
// FIXME: This looks a bit hacky
float scale_x, scale_y;
sprite.get_scale(scale_x, scale_y);
if (scale_x < 0)
align.x += sprite.get_width();
if (scale_y < 0)
align.y += sprite.get_height();
// if (scale_x > 1.0f && scale_y > 1.0f)
// return CL_Rectf(pos - origin - align,
// CL_Sizef(sprite.get_width() * scale_x, sprite.get_height() * scale_y));
// else
return CL_Rectf(pos - origin - align,
CL_Sizef(sprite.get_width(), sprite.get_height()));
}
int CL_RenderBatch3D::set_batcher_active(CL_GraphicContext &gc, const CL_Texture &texture, bool glyph_program, const CL_Colorf &new_constant_color)
{
if (use_glyph_program != glyph_program || constant_color != new_constant_color)
{
gc.flush_batcher();
use_glyph_program = glyph_program;
constant_color = new_constant_color;
}
int texindex = -1;
for (int i = 0; i < num_current_textures; i++)
{
if (current_textures[i] == texture)
{
texindex = i;
break;
}
}
if (texindex == -1 && num_current_textures < max_textures)
{
texindex = num_current_textures;
current_textures[num_current_textures++] = texture;
tex_sizes[texindex] = CL_Sizef((float)current_textures[texindex].get_width(), (float)current_textures[texindex].get_height());
}
if (position == 0 || position+6 > max_vertices || texindex == -1)
{
gc.flush_batcher();
texindex = 0;
current_textures[texindex] = texture;
num_current_textures = 1;
tex_sizes[texindex] = CL_Sizef((float)current_textures[texindex].get_width(), (float)current_textures[texindex].get_height());
}
gc.set_batcher(this);
return texindex;
}
void CL_GlyphCache::draw_text(CL_FontEngine *font_engine, CL_GraphicContext &gc, float xpos, float ypos, const CL_StringRef &text, const CL_Colorf &color)
{
CL_String::size_type string_length = text.length();
if (string_length==0)
{
return;
}
CL_RenderBatcherSprite *batcher = gc.impl->current_internal_batcher;
// Scan the string
CL_UTF8_Reader reader(text);
while(!reader.is_end())
{
unsigned int glyph = reader.get_char();
reader.next();
CL_Font_TextureGlyph *gptr = get_glyph(font_engine, gc, glyph);
if (gptr == NULL) continue;
if (!gptr->empty_buffer)
{
float xp = xpos + gptr->offset.x;
float yp = ypos + gptr->offset.y;
CL_Rectf dest_size(xp, yp, CL_Sizef(gptr->geometry.get_size()));
if (enable_subpixel)
{
batcher->draw_glyph_subpixel(gc, gptr->geometry, dest_size, color, gptr->subtexture.get_texture());
}else
{
batcher->draw_image(gc, gptr->geometry, dest_size, color, gptr->subtexture.get_texture());
}
}
xpos += gptr->increment.x;
ypos += gptr->increment.y;
}
}
// 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_stencil_size(8);
// For simplicity this example does not use the depth components
//win_desc.set_depth_size(16);
win_desc.set_title("Stencil Example");
win_desc.set_size(CL_Size( 900, 570 ), 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_Image image_ball(gc, "../Blend/Resources/ball.png");
grid_space = (float) (image_grid.get_width() - image_ball.get_width());
setup_balls();
CL_BufferControl buffer_control;
CL_BufferControl default_buffer_control;
options->request_repaint();
CL_Font font(gc, "Tahoma", 24);
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_balls = options->num_balls;
if (num_balls > max_balls)
num_balls = max_balls;
if (options->is_moveballs_set)
move_balls(time_diff, num_balls);
gc.clear_stencil(0);
// Draw the grid
const float grid_xpos = 10.0f;
const float grid_ypos = 10.0f;
image_grid.draw(gc, grid_xpos, grid_ypos);
// Draw the circle onto the stencil
if (options->is_circle_set)
{
buffer_control.enable_logic_op(false);
buffer_control.enable_stencil_test(true);
buffer_control.set_stencil_compare_func(cl_comparefunc_always, cl_comparefunc_always);
buffer_control.set_stencil_fail(cl_stencil_incr_wrap, cl_stencil_incr_wrap);
buffer_control.set_stencil_pass_depth_fail(cl_stencil_incr_wrap, cl_stencil_incr_wrap);
buffer_control.set_stencil_pass_depth_pass(cl_stencil_incr_wrap, cl_stencil_incr_wrap);
buffer_control.enable_color_write(false);
buffer_control.enable_depth_write(false);
buffer_control.enable_depth_test(false);
gc.set_buffer_control(buffer_control);
CL_Draw::circle(gc, grid_xpos + image_grid.get_width()/2, grid_ypos + image_grid.get_height()/2, 100, CL_Colorf::white);
}
buffer_control.enable_color_write(true);
buffer_control.enable_logic_op(false);
buffer_control.enable_stencil_test(true);
buffer_control.set_stencil_compare_func(options->compare_function, options->compare_function);
buffer_control.set_stencil_compare_reference(options->compare_reference, options->compare_reference);
buffer_control.set_stencil_write_mask(255, 255);
buffer_control.set_stencil_compare_mask(255, 255);
buffer_control.set_stencil_fail(options->stencil_fail, options->stencil_fail);;
// Note, depth testing disabled for this example
buffer_control.set_stencil_pass_depth_fail(options->stencil_pass, options->stencil_pass);
buffer_control.set_stencil_pass_depth_pass(options->stencil_pass, options->stencil_pass);
buffer_control.enable_depth_write(false);
buffer_control.enable_depth_test(false);
gc.set_buffer_control(buffer_control);
for (int cnt=0; cnt<num_balls; cnt++)
{
image_ball.draw(gc, grid_xpos + balls[cnt].xpos, grid_ypos + balls[cnt].ypos);
}
gc.set_buffer_control(default_buffer_control);
CL_Image stencil_image = get_stencil(gc,
CL_Rect(grid_xpos, grid_ypos, image_grid.get_width(), image_grid.get_height()));
const float stencil_image_xpos = 400.0f;
const float stencil_image_ypos = 30.0f;
const float stencil_image_scale = 0.5f;
stencil_image.set_scale(stencil_image_scale, stencil_image_scale);
stencil_image.draw(gc, stencil_image_xpos, stencil_image_ypos);
CL_Draw::box(gc, CL_Rectf(stencil_image_xpos, stencil_image_ypos, CL_Sizef(stencil_image.get_width() * stencil_image_scale, stencil_image.get_height() * stencil_image_scale)), CL_Colorf::white);
font.draw_text(gc, stencil_image_xpos, stencil_image_ypos - 4.0f, "Stencil", CL_Colorf::black);
// Add a note to avoid confusion
font.draw_text(gc, 10.0f, 500.0, "(This example does not use the stencil depth buffer comparison or the stencil bitmask)", CL_Colorf::black);
window.flip(1);
CL_KeepAlive::process();
}
return 0;
}
void ContainerRenderer::render(CL_GraphicContext& gc) {
renderQueue_->preRender();
gc.clear(CL_Colorf(0.f, 0.f, 0.f, 0.f));
boost::shared_ptr<CL_ProgramObject> shader = ui::Manager::getShaderManager()->getGumpShader();
gc.set_program_object(*shader, cl_program_matrix_modelview_projection);
CL_Texture huesTexture = data::Manager::getHuesLoader()->getHuesTexture();
gc.set_texture(0, huesTexture);
// set texture unit 1 active to avoid overriding the hue texture with newly loaded object textures
gc.set_texture(1, huesTexture);
shader->set_uniform1i("HueTexture", 0);
shader->set_uniform1i("ObjectTexture", 1);
RenderQueue::const_iterator igIter = renderQueue_->begin();
RenderQueue::const_iterator igEnd = renderQueue_->end();
CL_Vec2f vertexCoords[6];
bool renderingComplete = true;
// draw background container texture
boost::shared_ptr<ui::Texture> bgTex = containerView_->getBackgroundTexture();
if (bgTex && bgTex->isReadComplete()) {
CL_Vec3f hueInfo(0, 0, 1);
CL_Rectf rect(0, 0, CL_Sizef(bgTex->getWidth(), bgTex->getHeight()));
vertexCoords[0] = CL_Vec2f(rect.left, rect.top);
vertexCoords[1] = CL_Vec2f(rect.right, rect.top);
vertexCoords[2] = CL_Vec2f(rect.left, rect.bottom);
vertexCoords[3] = CL_Vec2f(rect.right, rect.top);
vertexCoords[4] = CL_Vec2f(rect.left, rect.bottom);
vertexCoords[5] = CL_Vec2f(rect.right, rect.bottom);
CL_Rectf texCoordHelper = bgTex->getNormalizedTextureCoords();
CL_Vec2f texCoords[6] = {
CL_Vec2f(texCoordHelper.left, texCoordHelper.top),
CL_Vec2f(texCoordHelper.right, texCoordHelper.top),
CL_Vec2f(texCoordHelper.left, texCoordHelper.bottom),
CL_Vec2f(texCoordHelper.right, texCoordHelper.top),
CL_Vec2f(texCoordHelper.left, texCoordHelper.bottom),
CL_Vec2f(texCoordHelper.right, texCoordHelper.bottom)
};
CL_PrimitivesArray primarray(gc);
primarray.set_attributes(0, vertexCoords);
primarray.set_attributes(1, texCoords);
primarray.set_attribute(2, hueInfo);
gc.set_texture(1, bgTex->getTexture());
gc.draw_primitives(cl_triangles, 6, primarray);
} else {
renderingComplete = false;
}
for (; igIter != igEnd; ++igIter) {
boost::shared_ptr<world::IngameObject> curObj = *igIter;
// just items in a container
if (!curObj->isDynamicItem()) {
continue;
}
// check if texture is ready to be drawn
boost::shared_ptr<ui::Texture> tex = curObj->getIngameTexture();
if (!tex) {
continue;
}
if (!tex->isReadComplete()) {
renderingComplete = false;
continue;
}
CL_Rectf rect(curObj->getLocXDraw(), curObj->getLocYDraw(), CL_Sizef(tex->getWidth(), tex->getHeight()));
vertexCoords[0] = CL_Vec2f(rect.left, rect.top);
vertexCoords[1] = CL_Vec2f(rect.right, rect.top);
vertexCoords[2] = CL_Vec2f(rect.left, rect.bottom);
vertexCoords[3] = CL_Vec2f(rect.right, rect.top);
vertexCoords[4] = CL_Vec2f(rect.left, rect.bottom);
vertexCoords[5] = CL_Vec2f(rect.right, rect.bottom);
CL_Rectf texCoordHelper = tex->getNormalizedTextureCoords();
CL_Vec2f texCoords[6] = {
CL_Vec2f(texCoordHelper.left, texCoordHelper.top),
CL_Vec2f(texCoordHelper.right, texCoordHelper.top),
CL_Vec2f(texCoordHelper.left, texCoordHelper.bottom),
CL_Vec2f(texCoordHelper.right, texCoordHelper.top),
CL_Vec2f(texCoordHelper.left, texCoordHelper.bottom),
CL_Vec2f(texCoordHelper.right, texCoordHelper.bottom)
};
CL_PrimitivesArray primarray(gc);
primarray.set_attributes(0, vertexCoords);
primarray.set_attributes(1, texCoords);
primarray.set_attribute(2, curObj->getHueInfo(false));
gc.set_texture(1, tex->getTexture());
gc.draw_primitives(cl_triangles, 6, primarray);
}
gc.reset_textures();
gc.reset_program_object();
renderQueue_->postRender(renderingComplete);
if (!renderingComplete) {
ui::Manager::getSingleton()->queueComponentRepaint(containerView_);
}
}
void TouchDragComponent::OnInput( VariantList *pVList )
{
//0 = message type, 1 = parent coordinate offset
CL_Vec2f pt = pVList->Get(1).GetVector2();
uint32 fingerID = 0;
if (pVList->Get(2).GetType() == Variant::TYPE_UINT32)
{
fingerID = pVList->Get(2).GetUINT32();
}
//LogMsg("Detected finger %d at %s", fingerID, PrintVector2(pt).c_str());
switch (eMessageType( int(pVList->Get(0).GetFloat())))
{
case MESSAGE_TYPE_GUI_CLICK_START:
//first, determine if the click is on our area
{
if (*m_pDisabled != 0) return;
CL_Rectf r(*m_pPos2d, CL_Sizef(m_pSize2d->x, m_pSize2d->y));
ApplyPadding(&r, *m_pTouchPadding);
if (r.contains(pt))
{
if (m_activeFingerID != -1)
{
//LogMsg("Ignoring new finger..");
return;
}
TouchTrackInfo *pTouch = BaseApp::GetBaseApp()->GetTouch(pVList->Get(2).GetUINT32());
if (pTouch->WasHandled()) return;
pTouch->SetWasHandled(true);
VariantList vList(pt, GetParent(), uint32(fingerID));
GetParent()->GetFunction("OnOverStart")->m_sig_function(&vList);
m_lastPos = pt;
m_activeFingerID = fingerID;
}
}
break;
case MESSAGE_TYPE_GUI_CLICK_END:
EndDrag(fingerID, pt);
break;
case MESSAGE_TYPE_GUI_CLICK_MOVE:
if (*m_pDisabled != 0)
{
EndDrag(fingerID, pt);
return;
}
if (m_activeFingerID == fingerID)
{
SetPosition(pt);
}
break;
default: ;
}
}
// The start of the Application
int App::start(const std::vector<CL_String> &args)
{
quit = false;
// Create a console window for text-output if not available
CL_ConsoleWindow console("Console", 80, 200);
try
{
// Set the window
// This opens a 640 x 480 window, including the frame size
// If you want more control over the window, pass CL_DisplayWindowDescription to CL_DisplayWindow
// (This is useful to create a borderless window of a specific size)
// If you require target specific control over the window, use the derived CL_OpenGLWindowDescription
// (This contains the multisampling options)
#ifdef USE_SWRENDER
CL_DisplayWindowDescription desc;
#else
CL_OpenGLWindowDescription desc;
// desc.set_multisampling(4);
#endif
desc.set_title("ClanLib 2D 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_Texture texture_image(gc, "tux.png");
texture_image.set_wrap_mode(cl_wrap_repeat, cl_wrap_repeat, cl_wrap_repeat);
texture_image.set_min_filter(cl_filter_linear);
texture_image.set_mag_filter(cl_filter_linear);
CL_ResourceManager resources("resources.xml");
CL_Sprite sprite(gc, "test", &resources);
//sprite.set_linear_filter(true);
CL_Font small_font = CL_Font(gc, "Tahoma", 12);
float test_base_angle = 0.0f;
float test_angle = 0.0f;
float test_angle_pitch = 0.0f;
float test_angle_yaw = 0.0f;
float test_scale = 1.0f;
bool test_scale_dir = false;
// Run until someone presses escape
while (!quit)
{
gc.clear(CL_Colorf(0.0f,0.0f,0.2f));
gc.set_map_mode(CL_MapMode(cl_map_2d_upper_left));
// CL_Draw::point()
for (int xcnt=0; xcnt<8; xcnt++)
{
for (int ycnt=0; ycnt<6; ycnt++)
{
CL_Draw::point(gc, xcnt*2, ycnt*2, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f));
}
}
small_font.draw_text(gc, 32, 10, "8*6 Points (0 + 2x), (0 + 2y)");
// CL_Draw::line()
for (int xcnt=0; xcnt<4; xcnt++)
{
for (int ycnt=0; ycnt<3; ycnt++)
{
const int offset_y = 16;
const int line_length = 6;
const int spacing = 8;
CL_Draw::line(gc, xcnt*spacing, (ycnt*spacing) + offset_y, line_length + (xcnt*spacing), (line_length + (ycnt*spacing)) + offset_y, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f));
}
}
small_font.draw_text(gc, 48, 30, "4*3 Lines (0 + 8x), (32 + 8y), (6 + 8x), (38 + 8y)");
// CL_Draw::box()
for (int xcnt=0; xcnt<4; xcnt++)
{
for (int ycnt=0; ycnt<3; ycnt++)
{
const int offset_y = 48;
const int line_length = 6;
const int spacing = 8;
CL_Draw::box(gc, xcnt*spacing, (ycnt*spacing) + offset_y, line_length + (xcnt*spacing), (line_length + (ycnt*spacing)) + offset_y, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f));
}
}
small_font.draw_text(gc, 48, 66, "4*3 Box (0 + 8x), (32 + 8y), (6 + 8x), (38 + 8y)");
// CL_Draw::fill()
for (int xcnt=0; xcnt<4; xcnt++)
{
for (int ycnt=0; ycnt<3; ycnt++)
{
const int offset_y = 80;
const int line_length = 6;
const int spacing = 8;
CL_Draw::fill(gc, xcnt*spacing, (ycnt*spacing) + offset_y, line_length + (xcnt*spacing), (line_length + (ycnt*spacing)) + offset_y, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f));
}
}
small_font.draw_text(gc, 48, 90, "4*3 Fill (0 + 8x), (32 + 8y), (6 + 8x), (38 + 8y)");
// CL_Draw::gradient_fill()
CL_Gradient gradient;
gradient.top_left = CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f);
gradient.top_right = CL_Colorf(1.0f, 0.0f, 0.0f, 1.0f);
gradient.bottom_left = CL_Colorf(0.0f, 0.0f, 1.0f, 1.0f);
gradient.bottom_right = CL_Colorf(0.0f, 1.0f, 0.0f, 1.0f);
for (int xcnt=0; xcnt<4; xcnt++)
{
for (int ycnt=0; ycnt<3; ycnt++)
{
const int offset_y = 110;
const int line_length = 6;
const int spacing = 8;
CL_Draw::gradient_fill(gc, xcnt*spacing, (ycnt*spacing) + offset_y, line_length + (xcnt*spacing), (line_length + (ycnt*spacing)) + offset_y, gradient);
}
}
small_font.draw_text(gc, 48, 115, "4*3 GradientFill (0 + 8x), (32 + 8y), (6 + 8x), (38 + 8y)");
small_font.draw_text(gc, 48, 125, "top left = white. top right = red");
small_font.draw_text(gc, 48, 135, "bottom left = blue. bottom right = green");
// CL_Draw::circle()
{
const int offset_y = 140;
int radius = 5;
CL_Draw::circle(gc, radius, offset_y + radius, radius, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f));
const int offset_x = 16;
radius = 16;
CL_Draw::circle(gc, offset_x + radius, offset_y + radius, radius, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f));
}
small_font.draw_text(gc, 54, 149, "Circle (5, 145) Radius = 5");
small_font.draw_text(gc, 54, 159, "Circle (32, 156) Radius = 16");
// CL_Draw::gradient_circle()
{
CL_Gradient gradient;
gradient.top_left = CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f);
gradient.top_right = CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f);
gradient.bottom_left = CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f);
gradient.bottom_right = CL_Colorf(1.0f, 0.0f, 0.0f, 1.0f);
const int offset_y = 180;
float radius = 17.0;
float xpos = radius;
float ypos = offset_y + radius;
CL_Draw::gradient_circle(gc, CL_Pointf( xpos, ypos ), CL_Pointf(radius/2.0, 0.0f), radius, gradient);
const int offset_x = 40;
radius = 17.0;
xpos = offset_x + radius;
ypos = offset_y + radius;
CL_Draw::gradient_circle(gc, CL_Pointf( xpos, ypos), CL_Pointf(0.0f, radius/2.0), radius, gradient);
}
small_font.draw_text(gc, 80, 189, "Gradient Circle (16, 196) Radius = 17. Gradient right");
small_font.draw_text(gc, 80, 199, "Gradient Circle (56, 196) Radius = 17. Gradient up");
small_font.draw_text(gc, 80, 209, "centre = white, outer = red");
// CL_Draw::triangle()
{
const float offset_y = 220.0f;
const float size = 12.0f;
CL_Draw::triangle(gc, CL_Pointf(0.0f, offset_y), CL_Pointf(0.0f, offset_y + size), CL_Pointf(size, offset_y + size), CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f));
float offset_x = 16.0f;
CL_Draw::triangle(gc, CL_Pointf(offset_x + 0.0f, offset_y + size), CL_Pointf(offset_x + size, offset_y + size), CL_Pointf(offset_x + 0.0f, offset_y), CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f));
offset_x = 32.0f;
CL_Draw::triangle(gc, CL_Pointf(offset_x + size, offset_y + size), CL_Pointf(offset_x + 0.0f, offset_y), CL_Pointf(offset_x + 0.0f, offset_y + size), CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f));
}
small_font.draw_text(gc, 48, 229, "3 Triangles (12 pixel size) (Left vertical edge).");
small_font.draw_text(gc, 48, 239, "Top Left: (0,220) (16,220) (32,220)");
// CL_Draw::texture()
gc.set_texture(0, texture_image);
{
float offset_x = 0.0f;
float offset_y = 250.0f;
CL_Rectf src_rect(offset_x, offset_y, CL_Sizef(31, 47));
CL_Rectf texture_coords(0.0, 0.0, 1.0f, 1.0f);
CL_Colorf color(1.0f, 1.0f, 1.0f, 1.0f);
CL_Draw::texture(gc, src_rect, color, texture_coords);
offset_x = 33.0f;
src_rect = CL_Rectf(offset_x, offset_y, CL_Sizef(31, 47));
texture_coords = CL_Rectf(0.25f, 0.25f, 0.75f, 0.75f);
color = CL_Colorf(1.0f, 0.0f, 0.0f, 1.0f);
CL_Draw::texture(gc, src_rect, color, texture_coords);
}
gc.reset_texture(0);
small_font.draw_text(gc, 76, 260, "Texture (0, 250) size=(31,47)");
small_font.draw_text(gc, 76, 275, "Texture (33, 250) size=(31,47) (red, magnify*2)");
// CL_RoundedRect
{
CL_RoundedRect roundedrect(CL_Sizef(64.0f, 32.0f), 15.0f);
float offset_x = 0.0f;
float offset_y = 300.0f;
CL_Origin origin = origin_top_left;
roundedrect.draw(gc, CL_Pointf(offset_x, offset_y), CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f), origin);
offset_y = 340.0f;
roundedrect.fill(gc, CL_Pointf(offset_x, offset_y), CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f), origin);
offset_y = 380.0f;
CL_Gradient gradient;
gradient.top_left = CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f);
gradient.top_right = CL_Colorf(1.0f, 0.0f, 0.0f, 1.0f);
gradient.bottom_left = CL_Colorf(0.0f, 0.0f, 1.0f, 1.0f);
gradient.bottom_right = CL_Colorf(0.0f, 1.0f, 0.0f, 1.0f);
roundedrect.fill(gc, CL_Pointf(offset_x, offset_y), gradient, origin);
offset_y = 420.0f;
roundedrect.set_control_point_bl(CL_Pointf(0.4f, 0.8f));
roundedrect.set_rounding_bottom_left(CL_Sizef(0.2f, 0.6f));
roundedrect.set_control_point_tl(CL_Pointf(0.2f, 0.4f));
roundedrect.set_rounding_top_left(CL_Sizef(0.4f, 0.2f));
roundedrect.set_control_point_tr(CL_Pointf(0.6f, 0.2f));
roundedrect.set_rounding_top_right(CL_Sizef(0.8f, 0.4f));
roundedrect.set_control_point_br(CL_Pointf(0.6f, 0.8f));
roundedrect.set_rounding_bottom_right(CL_Sizef(0.8f, 0.6f));
roundedrect.fill(gc, CL_Pointf(offset_x, offset_y), gradient, origin);
}
small_font.draw_text(gc, 76, 310, "RoundedRect - draw (0, 300) size=(64,32)");
small_font.draw_text(gc, 76, 325, "(RoundedRect - draw gradient - is not implemented)");
small_font.draw_text(gc, 76, 350, "RoundedRect - fill (0, 340) size=(64,32)");
small_font.draw_text(gc, 76, 390, "RoundedRect - fill gradient (0, 380) size=(64,32)");
small_font.draw_text(gc, 76, 400, "top left = white. top right = red");
small_font.draw_text(gc, 76, 410, "bottom left = blue. bottom right = green");
small_font.draw_text(gc, 76, 430, "RoundedRect - fill gradient (0, 420) size=(64,32)");
small_font.draw_text(gc, 76, 440, "Controling control / rounding points");
// CL_Sprite
{
test_base_angle+=5.0f;
if (test_base_angle >= 360.0f)
{
test_base_angle = 0.0f;
}
#ifndef USE_SWRENDER
clEnable(GL_MULTISAMPLE);
#endif
sprite.set_base_angle(CL_Angle(test_base_angle, cl_degrees));
sprite.draw(gc, 350, 20);
sprite.set_base_angle(CL_Angle(0, cl_degrees));
#ifndef USE_SWRENDER
clDisable(GL_MULTISAMPLE);
#endif
}
small_font.draw_text(gc, 370, 20, "Sprite - Base angle");
small_font.draw_text(gc, 370, 35, "Multisampling enabled");
{
test_angle+=5.0f;
if (test_angle >= 360.0f)
{
test_angle = 0.0f;
}
sprite.set_angle(CL_Angle(test_angle, cl_degrees));
sprite.draw(gc, 350, 60);
sprite.set_angle(CL_Angle(0, cl_degrees));
}
small_font.draw_text(gc, 370, 60, "Sprite - Angle");
{
test_angle_pitch+=5.0f;
if (test_angle_pitch >= 360.0f)
{
test_angle_pitch = 0.0f;
}
sprite.set_angle_pitch(CL_Angle(test_angle_pitch, cl_degrees));
sprite.draw(gc, 350, 100);
sprite.set_angle_pitch(CL_Angle(0, cl_degrees));
}
small_font.draw_text(gc, 370, 100, "Sprite - Angle Pitch");
{
test_angle_yaw+=5.0f;
if (test_angle_yaw >= 360.0f)
{
test_angle_yaw = 0.0f;
}
sprite.set_angle_yaw(CL_Angle(test_angle_yaw, cl_degrees));
sprite.draw(gc, 350, 140);
sprite.set_angle_yaw(CL_Angle(0, cl_degrees));
}
small_font.draw_text(gc, 370, 140, "Sprite - Angle Yaw");
{
if (test_scale_dir)
{
test_scale += 0.1f;
if (test_scale >= 2.0f)
{
test_scale = 2.0f;
test_scale_dir = false;
}
}else
{
test_scale -= 0.1f;
if (test_scale <= -2.0f)
{
test_scale = -2.0f;
test_scale_dir = true;
}
}
sprite.set_scale(test_scale, 1.0f);
sprite.draw(gc, 350, 180);
sprite.set_scale(1.0f, test_scale);
sprite.draw(gc, 390, 180);
sprite.set_scale(1.0f, 1.0f);
}
small_font.draw_text(gc, 420, 180, "Sprite - Set Scale (x), (y)");
// 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();
}
small_font = CL_Font();
}
catch(CL_Exception& exception)
{
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;
}
void FilterInputComponent::FilterOnInput(VariantList *pVList)
{
if (pVList->m_variant[Entity::FILTER_INDEX].GetUINT32() == Entity::FILTER_REFUSE_ALL) return;
switch (*m_pMode)
{
case MODE_CLIP_INPUT_TO_SIZE:
//let's only apply this to some messages
switch (eMessageType( int(pVList->Get(0).GetFloat())))
{
case MESSAGE_TYPE_GUI_CLICK_START:
case MESSAGE_TYPE_GUI_CLICK_MOVE:
CL_Vec2f pt = pVList->Get(1).GetVector2();
pt += GetAlignmentOffset(*m_pSize2d, eAlignment(*m_pAlignment));
CL_Rectf r(*m_pPos2d, CL_Sizef(m_pSize2d->x, m_pSize2d->y));
if (!r.contains(pt))
{
pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL));
return;
} else
{
//fine, you may pass
}
break;
}
break;
case MODE_CLIP_INPUT_TO_SIZE_STRICT:
//let's only apply this to some messages
switch (eMessageType( int(pVList->Get(0).GetFloat())))
{
case MESSAGE_TYPE_GUI_CLICK_START:
case MESSAGE_TYPE_GUI_CLICK_MOVE:
case MESSAGE_TYPE_GUI_CLICK_END:
CL_Vec2f pt = pVList->Get(1).GetVector2();
pt += GetAlignmentOffset(*m_pSize2d, eAlignment(*m_pAlignment));
CL_Rectf r(*m_pPos2d, CL_Sizef(m_pSize2d->x, m_pSize2d->y));
if (!r.contains(pt))
{
pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL));
return;
} else
{
//fine, you may pass
}
}
break;
case MODE_DISABLE_INPUT_ALL:
pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL));
break;
case MODE_DISABLE_INPUT_CHILDREN:
pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_CHILDREN));
break;
case MODE_IDLE:
//let it know it can process this message like normal
//pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_ALLOW));
break;
case MODE_CLIP_INPUT_TO_ABSOLUTE_CLIP_RECT_AND_DISABLE_INPUT_CHILDREN:
//let's only apply this to some messages
switch (eMessageType( int(pVList->Get(0).GetFloat())))
{
case MESSAGE_TYPE_GUI_CLICK_START:
case MESSAGE_TYPE_GUI_CLICK_MOVE:
case MESSAGE_TYPE_GUI_CLICK_END:
CL_Vec2f pt = pVList->Get(1).GetVector2();
//pt -= GetAlignmentOffset(*m_pSize2d, eAlignment(*m_pAlignment));
if (!m_pClipRect->contains(pt))
{
pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL));
return;
} else
{
//fine, you may pass
}
}
//let it know it can process this message like normal
pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_CHILDREN));
break;
case MODE_CLIP_INPUT_TO_ABSOLUTE_CLIP_RECT:
//let's only apply this to some messages
switch (eMessageType( int(pVList->Get(0).GetFloat())))
{
case MESSAGE_TYPE_GUI_CLICK_START:
case MESSAGE_TYPE_GUI_CLICK_MOVE:
case MESSAGE_TYPE_GUI_CLICK_END:
CL_Vec2f pt = pVList->Get(1).GetVector2();
if (!m_pClipRect->contains(pt))
{
pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL));
return;
} else
{
//fine, you may pass
}
}
break;
case MODE_IGNORE_ABSOLUTE_CLIP_RECT:
//let's only apply this to some messages
switch (eMessageType( int(pVList->Get(0).GetFloat())))
{
case MESSAGE_TYPE_GUI_CLICK_START:
case MESSAGE_TYPE_GUI_CLICK_MOVE:
case MESSAGE_TYPE_GUI_CLICK_END:
CL_Vec2f pt = pVList->Get(1).GetVector2();
if (m_pClipRect->contains(pt))
{
pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL));
return;
} else
{
//fine, you may pass
}
}
break;
case MODE_CLIP_INPUT_TO_CLIP_RECT:
//let's only apply this to some messages
switch (eMessageType( int(pVList->Get(0).GetFloat())))
{
case MESSAGE_TYPE_GUI_CLICK_START:
case MESSAGE_TYPE_GUI_CLICK_MOVE:
case MESSAGE_TYPE_GUI_CLICK_END:
CL_Vec2f pt = pVList->Get(1).GetVector2();
pt += GetAlignmentOffset(CL_Vec2f(m_pClipRect->get_width(), m_pClipRect->get_height()), eAlignment(*m_pAlignment));
CL_Rectf r(*m_pPos2d, m_pClipRect->get_size());
if (!r.contains(pt))
{
pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL));
return;
} else
{
//fine, you may pass
}
}
break;
default:
LogError("FilterInputComponent: Unknown mode %d", *m_pMode);
}
}
void CursorManager::drawDragObject(CL_GraphicContext& gc, const CL_Point& mousePos) const {
if (isDragging_ && dragCandidate_) {
boost::shared_ptr<ui::Texture> dragTex = dragCandidate_->getIngameTexture();
if (dragTex && dragTex->isReadComplete()) {
// TODO: load shader here for correct hueing
CL_Draw::texture(gc, dragTex->getTexture(),
CL_Quadf(CL_Rectf(mousePos.x - dragTex->getWidth() / 2, mousePos.y - dragTex->getHeight() / 2, CL_Sizef(dragTex->getWidth(), dragTex->getHeight()))),
CL_Colorf::white, dragTex->getNormalizedTextureCoords()
);
} else {
dragCandidate_->updateRenderData(0);
}
}
}
