/************************************************************************* Move the window by the pixel offsets specified in 'offset'. *************************************************************************/ void FrameWindow::offsetPixelPosition(const Vector2& offset) { UVector2 uOffset(cegui_absdim(PixelAligned(offset.d_x)), cegui_absdim(PixelAligned(offset.d_y))); setPosition(d_area.getPosition() + uOffset); }
//----------------------------------------------------------------------------// void OpenGLGeometryBuffer::setClippingRegion(const Rect& region) { d_clipRect.d_top = ceguimax(0.0f, PixelAligned(region.d_top)); d_clipRect.d_bottom = ceguimax(0.0f, PixelAligned(region.d_bottom)); d_clipRect.d_left = ceguimax(0.0f, PixelAligned(region.d_left)); d_clipRect.d_right = ceguimax(0.0f, PixelAligned(region.d_right)); }
//----------------------------------------------------------------------------// void Direct3D8GeometryBuffer::setClippingRegion(const Rect& region) { d_clipRect.d_top = PixelAligned(region.d_top); d_clipRect.d_bottom = PixelAligned(region.d_bottom); d_clipRect.d_left = PixelAligned(region.d_left); d_clipRect.d_right = PixelAligned(region.d_right); }
/************************************************************************* Sets up sizes and positions for attached ItemEntry children. *************************************************************************/ void Menubar::layoutItemWidgets() { Rect render_rect = getItemRenderArea(); float x0 = PixelAligned(render_rect.d_left+d_borderWidth); Rect rect; ItemEntryList::iterator item = d_listItems.begin(); while ( item != d_listItems.end() ) { Size optimal = (*item)->getItemPixelSize(); optimal.d_width += 2*d_horzPadding; optimal.d_height += 2*d_vertPadding; (*item)->setVerticalAlignment(VA_CENTRE); rect.setPosition( Point(x0,0) ); rect.setSize( Size( PixelAligned(optimal.d_width), PixelAligned(optimal.d_height) ) ); (*item)->setRect(Absolute,rect); x0 += optimal.d_width + d_itemSpacing; item++; } }
/************************************************************************* Queues an area of the associated Texture the be drawn on the screen. Low-level routine not normally used! *************************************************************************/ void Imageset::draw(const Rect& source_rect, const Rect& dest_rect, float z, const Rect& clip_rect,const ColourRect& colours, QuadSplitMode quad_split_mode, const Image* image ) const { // get the rect area that we will actually draw to (i.e. perform clipping) Rect final_rect(dest_rect.getIntersection(clip_rect)); // check if rect was totally clipped if (final_rect.getWidth() != 0) { float x_scale = 1.0f / (float)d_texture->getWidth(); float y_scale = 1.0f / (float)d_texture->getHeight(); float tex_per_pix_x = source_rect.getWidth() / dest_rect.getWidth(); float tex_per_pix_y = source_rect.getHeight() / dest_rect.getHeight(); // calculate final, clipped, texture co-ordinates Rect tex_rect((source_rect.d_left + ((final_rect.d_left - dest_rect.d_left) * tex_per_pix_x)) * x_scale, (source_rect.d_top + ((final_rect.d_top - dest_rect.d_top) * tex_per_pix_y)) * y_scale, (source_rect.d_right + ((final_rect.d_right - dest_rect.d_right) * tex_per_pix_x)) * x_scale, (source_rect.d_bottom + ((final_rect.d_bottom - dest_rect.d_bottom) * tex_per_pix_y)) * y_scale); final_rect.d_left = PixelAligned(final_rect.d_left); final_rect.d_right = PixelAligned(final_rect.d_right); final_rect.d_top = PixelAligned(final_rect.d_top); final_rect.d_bottom = PixelAligned(final_rect.d_bottom); // queue a quad to be rendered d_texture->getRenderer()->addQuad(final_rect, z, d_texture, tex_rect, colours, quad_split_mode,image); } }
/************************************************************************* Sets up sizes and positions for attached ItemEntry children. *************************************************************************/ void PopupMenu::layoutItemWidgets() { // get render area Rect render_rect = getItemRenderArea(); // get starting position const float x0 = PixelAligned(render_rect.d_left); float y0 = PixelAligned(render_rect.d_top); URect rect; UVector2 sz(cegui_absdim(PixelAligned(render_rect.getWidth())), cegui_absdim(0)); // set item width // iterate through all items attached to this window ItemEntryList::iterator item = d_listItems.begin(); while ( item != d_listItems.end() ) { // get the "optimal" height of the item and use that! sz.d_y.d_offset = PixelAligned((*item)->getItemPixelSize().d_height); // rounding errors ? // set destination rect rect.setPosition(UVector2(cegui_absdim(x0), cegui_absdim(y0)) ); rect.setSize( sz ); (*item)->setArea(rect); // next position y0 += PixelAligned(sz.d_y.d_offset + d_itemSpacing); item++; // next item } }
/************************************************************************* Return the rendered pixel size of this list box item. *************************************************************************/ Size ListboxWrappedTextItem::getPixelSize(void) const { Size size(0,0); if (d_owner != NULL) { size.d_width = d_owner->getPixelSize().d_width - 25.0f; } Font* font = const_cast<Font*>(getFont()); if (font != NULL) { size.d_height = PixelAligned(font->getLineSpacing()); if(size.d_width == 0) { size.d_width = PixelAligned(font->getTextExtent(d_itemText)); } Rect formatRect; formatRect.setPosition(CEGUI::Point(0,0)); if (d_draw_bullet) { formatRect.d_left = font->getTextExtent(ds_bullet); } formatRect.setSize(size); uint lines = font->getFormattedLineCount(d_itemText, formatRect, d_textFormatting); size.d_height *= lines; size.d_height += d_padding; } return size; }
//----------------------------------------------------------------------------// void RenderingWindow::setSize(const Size& size) { d_size.d_width = PixelAligned(size.d_width); d_size.d_height = PixelAligned(size.d_height); d_geometryValid = false; d_textarget.declareRenderSize(d_size); }
void FalagardProgressBarEx::render() { const StateImagery* imagery; // get WidgetLookFeel for the assigned look. const WidgetLookFeel& wlf = getLookNFeel(); // try and get imagery for our current state imagery = &wlf.getStateImagery(d_window->isDisabled() ? "Disabled" : "Enabled"); // peform the rendering operation. imagery->render(*d_window); // get imagery for actual progress rendering imagery = &wlf.getStateImagery(d_window->isDisabled() ? "DisabledProgress" : "EnabledProgress"); // get target rect for this imagery Rect progressRect(wlf.getNamedArea("ProgressArea").getArea().getPixelRect(*d_window)); // calculate a clipper according to the current progress. Rect progressClipper(progressRect); ProgressBar* w = (ProgressBar*)d_window; if (d_vertical) { float height = PixelAligned(progressClipper.getHeight() * w->getProgress()); if (d_reversed) { progressClipper.setHeight(height); } else { progressClipper.d_top = progressClipper.d_bottom - height; } } else { float width = PixelAligned(progressClipper.getWidth() * w->getProgress()); if (d_reversed) { progressClipper.d_left = progressClipper.d_right - width; } else { progressClipper.setWidth(width); } } // peform the rendering operation. imagery->render(*d_window, progressRect, 0, &progressClipper); // perform the text rendering operation imagery = &wlf.getStateImagery("Label"); imagery->render(*d_window); }
/************************************************************************* Return the rendered pixel size of this list box item. *************************************************************************/ Size ListboxNumberItem::getPixelSize(void) const { Size tmp(0,0); const Font* fnt = getFont(); if (fnt != NULL) { tmp.d_height = PixelAligned(fnt->getLineSpacing()); tmp.d_width = PixelAligned(fnt->getTextExtent(d_itemText)); } return tmp; }
/************************************************************************* Processing for drag-sizing the segment *************************************************************************/ void ListHeaderSegment::doDragSizing(const Point& local_mouse) { float delta = local_mouse.d_x - d_dragPoint.d_x; // store this so we can work out how much size actually changed float orgWidth = d_pixelSize.d_width; // ensure that we only size to the set constraints. // // NB: We are required to do this here due to our virtually unique sizing nature; the // normal system for limiting the window size is unable to supply the information we // require for updating our internal state used to manage the dragging, etc. float maxWidth(d_maxSize.d_x.asAbsolute(System::getSingleton().getRenderer()->getDisplaySize().d_width)); float minWidth(d_minSize.d_x.asAbsolute(System::getSingleton().getRenderer()->getDisplaySize().d_width)); float newWidth = orgWidth + delta; if (newWidth > maxWidth) delta = maxWidth - orgWidth; else if (newWidth < minWidth) delta = minWidth - orgWidth; // update segment area rect URect area(d_area.d_min.d_x, d_area.d_min.d_y, d_area.d_max.d_x + UDim(0,PixelAligned(delta)), d_area.d_max.d_y); setArea_impl(area.d_min, area.getSize()); // move the dragging point so mouse remains 'attached' to edge of segment d_dragPoint.d_x += d_pixelSize.d_width - orgWidth; WindowEventArgs args(this); onSegmentSized(args); }
/************************************************************************* Draw the list box item in its current state. *************************************************************************/ void ListboxTextItem::draw(GeometryBuffer& buffer, const Rect& targetRect, float alpha, const Rect* clipper) const { if (d_selected && d_selectBrush != 0) d_selectBrush->draw(buffer, targetRect, clipper, getModulateAlphaColourRect(d_selectCols, alpha)); Font* font = getFont(); if (!font) return; Vector2 draw_pos(targetRect.getPosition()); draw_pos.d_y += PixelAligned( (font->getLineSpacing() - font->getFontHeight()) * 0.5f); if (!d_renderedStringValid) parseTextString(); const ColourRect final_colours( getModulateAlphaColourRect(ColourRect(0xFFFFFFFF), alpha)); for (size_t i = 0; i < d_renderedString.getLineCount(); ++i) { d_renderedString.draw(i, buffer, draw_pos, &final_colours, clipper, 0.0f); draw_pos.d_y += d_renderedString.getPixelSize(i).d_height; } }
/************************************************************************* Draw the list box item in its current state. *************************************************************************/ void ListboxWrappedTextItem::draw(const Vector3& position, float alpha, const Rect& clipper) const { if (d_selected && (d_selectBrush != 0)) { d_selectBrush->draw(clipper, position.d_z, clipper, getModulateAlphaColourRect(d_selectCols, alpha)); } Font* font = const_cast<Font*>(getFont()); if (font) { float left_offset = 0; if (d_draw_bullet) { left_offset = font->getTextExtent(ds_bullet); } Vector3 finalPos = position; finalPos.d_y -= PixelAligned((font->getLineSpacing() - font->getBaseline()) * 0.5f); Rect draw_area = Rect(finalPos.d_x, finalPos.d_y, clipper.d_right, finalPos.d_y); font->drawText(ds_bullet, draw_area, finalPos.d_z, clipper, d_textFormatting, getModulateAlphaColourRect(d_textCols, alpha)); draw_area.d_left += left_offset; font->drawText(d_itemText, draw_area, finalPos.d_z, clipper, d_textFormatting, getModulateAlphaColourRect(d_textCols, alpha)); } }
void PushButton::resizeWithText() { Size size = getRenderSize(); setSize( Absolute, size ); Point newPos; newPos.d_x = m_ptHookPosition.d_x; newPos.d_y = m_ptHookPosition.d_y; switch( m_HookMode ) { case Hook_Left: newPos.d_y -= d_pixelSize.d_height / 2; break; case Hook_Right: newPos.d_x -= d_pixelSize.d_width; newPos.d_y -= d_pixelSize.d_height / 2; break; case Hook_Top: newPos.d_x -= d_pixelSize.d_width / 2; break; case Hook_Bottom: newPos.d_x -= d_pixelSize.d_width / 2; newPos.d_y -= d_pixelSize.d_height; break; case Hook_LeftTop: break; case Hook_LeftBottom: newPos.d_y -= d_pixelSize.d_height; break; case Hook_RightTop: newPos.d_x -= d_pixelSize.d_width; break; case Hook_RightBottom: newPos.d_x -= d_pixelSize.d_width; newPos.d_y -= d_pixelSize.d_height; break; case Hook_Center: newPos.d_x -= d_pixelSize.d_width / 2; newPos.d_y -= d_pixelSize.d_height / 2; break; default: break; } UVector2 relativePos; d_area.setPosition( UVector2(cegui_absdim(PixelAligned(newPos.d_x)), cegui_absdim(PixelAligned( newPos.d_y) ) ) ); }
/************************************************************************* Return the rendered pixel size of this list box item. *************************************************************************/ Size ListboxImageItem::getPixelSize(void) { if ( !d_bSizeChanged ) return d_savedPixelSize; Size tmp(0,0); if (d_image != NULL) { tmp.d_height = PixelAligned(d_image->getHeight()); tmp.d_width = PixelAligned(d_image->getWidth()); } d_bSizeChanged = false; d_savedPixelSize = tmp; return tmp; }
/************************************************************************* Return the rendered pixel size of this list box item. *************************************************************************/ Size ListboxTextItem::getPixelSize(void) { if ( !d_bSizeChanged ) return d_savedPixelSize; Size tmp(0,0); const Font* fnt = getFont(); if (fnt != NULL) { tmp.d_height = PixelAligned(fnt->getLineSpacing()); tmp.d_width = PixelAligned(fnt->getTextExtent(d_itemText)); } d_bSizeChanged = false; d_savedPixelSize = tmp; return tmp; }
/************************************************************************* Sets up sizes and positions for attached ItemEntry children. *************************************************************************/ void Menubar::layoutItemWidgets() { Rect render_rect = getItemRenderArea(); float x0 = PixelAligned(render_rect.d_left); URect rect; ItemEntryList::iterator item = d_listItems.begin(); while ( item != d_listItems.end() ) { const Size optimal = (*item)->getItemPixelSize(); (*item)->setVerticalAlignment(VA_CENTRE); rect.setPosition(UVector2(cegui_absdim(x0), cegui_absdim(0)) ); rect.setSize( UVector2( cegui_absdim(PixelAligned(optimal.d_width)), cegui_absdim(PixelAligned(optimal.d_height)))); (*item)->setArea(rect); x0 += optimal.d_width + d_itemSpacing; ++item; } }
void ListboxTextItem::draw(RenderCache& cache,const Rect& targetRect, float zBase, float alpha, const Rect* clipper) const { if (d_selected && d_selectBrush != 0) { cache.cacheImage(*d_selectBrush, targetRect, zBase, getModulateAlphaColourRect(d_selectCols, alpha), clipper); } Font* font = getFont(); if (font) { Rect finalPos(targetRect); finalPos.d_top += PixelAligned((font->getLineSpacing() - font->getFontHeight()) * 0.5f); cache.cacheText(d_itemText, font, LeftAligned, finalPos, zBase, getModulateAlphaColourRect(d_textCols, alpha), clipper); } }
void ListboxTextItem::draw(RenderCache& cache,const Rect& targetRect, float zBase, float alpha, const Rect* clipper) const { if (d_selected && d_selectBrush != 0) { cache.cacheImage(*d_selectBrush, targetRect, zBase, getModulateAlphaColourRect(d_selectCols, alpha), clipper); } const FontBase* font = getFont(); if (font) { Rect finalPos(targetRect); finalPos.d_top += PixelAligned( FontBase::LineSpace * 0.5f); cache.cacheText( getOwnerWindow(), d_itemText, font, d_horzFormateing, finalPos, zBase, getModulateAlphaColourRect(d_textCols, alpha), clipper); } }
/************************************************************************* Draw the list box item in its current state. *************************************************************************/ void ListboxNumberItem::draw(const Vector3& position, float alpha, const Rect& clipper) const { if (d_selected && (d_selectBrush != NULL)) { d_selectBrush->draw(clipper, position.d_z, clipper, getModulateAlphaColourRect(d_selectCols, alpha)); } const Font* fnt = getFont(); if (fnt != NULL) { Vector3 finalPos(position); finalPos.d_y -= PixelAligned((fnt->getLineSpacing() - fnt->getBaseline()) * 0.5f); fnt->drawText(d_itemText, finalPos, clipper, getModulateAlphaColourRect(d_textCols, alpha)); } }
/************************************************************************* move the window's bottom edge by 'delta'. The rest of the window does not move, thus this changes the size of the Window. *************************************************************************/ void FrameWindow::moveBottomEdge(float delta) { // store this so we can work out how much size actually changed float orgHeight = d_pixelSize.d_height; URect area(d_area); // ensure that we only size to the set constraints. // // NB: We are required to do this here due to our virtually unique sizing nature; the // normal system for limiting the window size is unable to supply the information we // require for updating our internal state used to manage the dragging, etc. float maxHeight(d_maxSize.d_y.asAbsolute(System::getSingleton().getRenderer()->getHeight())); float minHeight(d_minSize.d_y.asAbsolute(System::getSingleton().getRenderer()->getHeight())); float newHeight = orgHeight + delta; if (newHeight > maxHeight) delta = maxHeight - orgHeight; else if (newHeight < minHeight) delta = minHeight - orgHeight; // ensure adjustment will be whole pixel float adjustment = PixelAligned(delta); area.d_max.d_y.d_offset += adjustment; if (d_vertAlign == VA_BOTTOM) { area.d_max.d_y.d_offset += adjustment; area.d_min.d_y.d_offset += adjustment; } else if (d_vertAlign == VA_CENTRE) { area.d_max.d_y.d_offset += adjustment * 0.5f; area.d_min.d_y.d_offset += adjustment * 0.5f; } setArea_impl(area.d_min, area.getSize(), d_vertAlign == VA_BOTTOM); // move the dragging point so mouse remains 'attached' to edge of window d_dragPoint.d_y += d_pixelSize.d_height - orgHeight; }
/************************************************************************* move the window's top edge by 'delta'. The rest of the window does not move, thus this changes the size of the Window. *************************************************************************/ void FrameWindow::moveTopEdge(float delta) { float orgHeight = d_pixelSize.d_height; URect area(d_area); // ensure that we only size to the set constraints. // // NB: We are required to do this here due to our virtually unique sizing nature; the // normal system for limiting the window size is unable to supply the information we // require for updating our internal state used to manage the dragging, etc. float maxHeight(d_maxSize.d_y.asAbsolute(System::getSingleton().getRenderer()->getHeight())); float minHeight(d_minSize.d_y.asAbsolute(System::getSingleton().getRenderer()->getHeight())); float newHeight = orgHeight - delta; if (newHeight > maxHeight) delta = orgHeight - maxHeight; else if (newHeight < minHeight) delta = orgHeight - minHeight; // ensure adjustment will be whole pixel float adjustment = PixelAligned(delta); if (d_vertAlign == VA_BOTTOM) { area.d_max.d_y.d_offset -= adjustment; } else if (d_vertAlign == VA_CENTRE) { area.d_max.d_y.d_offset -= adjustment * 0.5f; area.d_min.d_y.d_offset += adjustment * 0.5f; } else { area.d_min.d_y.d_offset += adjustment; } setArea_impl(area.d_min, area.getSize(), d_vertAlign == VA_TOP); }
/************************************************************************* move the window's left edge by 'delta'. The rest of the window does not move, thus this changes the size of the Window. *************************************************************************/ void FrameWindow::moveLeftEdge(float delta) { float orgWidth = d_pixelSize.d_width; URect area(d_area); // ensure that we only size to the set constraints. // // NB: We are required to do this here due to our virtually unique sizing nature; the // normal system for limiting the window size is unable to supply the information we // require for updating our internal state used to manage the dragging, etc. float maxWidth(d_maxSize.d_x.asAbsolute(System::getSingleton().getRenderer()->getWidth())); float minWidth(d_minSize.d_x.asAbsolute(System::getSingleton().getRenderer()->getWidth())); float newWidth = orgWidth - delta; if (newWidth > maxWidth) delta = orgWidth - maxWidth; else if (newWidth < minWidth) delta = orgWidth - minWidth; // ensure adjustment will be whole pixel float adjustment = PixelAligned(delta); if (d_horzAlign == HA_RIGHT) { area.d_max.d_x.d_offset -= adjustment; } else if (d_horzAlign == HA_CENTRE) { area.d_max.d_x.d_offset -= adjustment * 0.5f; area.d_min.d_x.d_offset += adjustment * 0.5f; } else { area.d_min.d_x.d_offset += adjustment; } setArea_impl(area.d_min, area.getSize(), d_horzAlign == HA_LEFT); }
/************************************************************************* set the vertical scaling factor to be applied to this Image *************************************************************************/ void Image::setVertScaling(float factor) { d_scaledHeight = PixelAligned(d_area.getHeight() * factor); d_scaledOffset.d_y = PixelAligned(d_offset.d_y * factor); }
/************************************************************************* set the horizontal scaling factor to be applied to this Image *************************************************************************/ void Image::setHorzScaling(float factor) { d_scaledWidth = PixelAligned(d_area.getWidth() * factor); d_scaledOffset.d_x = PixelAligned(d_offset.d_x * factor); }
void CPFRotatingText::renderRotatingText() { Font* font = d_window->getFont(); // can't render text without a font :) if( font==NULL){ return; } // get destination area for the text. Rect absarea(getTextRenderArea()); Rect clipper(absarea); float textHeight = font->getFormattedLineCount(d_window->getText(), absarea, (TextFormatting)d_horzFormatting) * font->getLineSpacing(); Scrollbar* vertScrollbar = getVertScrollbar(); Scrollbar* horzScrollbar = getHorzScrollbar(); // calculate X offset static float xOffset = horzScrollbar->getPageSize(); if( xOffset<-(horzScrollbar->getDocumentSize()+horzScrollbar->getPageSize()) ){ xOffset = horzScrollbar->getPageSize(); } static boost::system_time previous_time = boost::get_system_time(); boost::system_time time = boost::get_system_time(); boost::system_time::time_duration_type time_step = (time-previous_time); xOffset -= (static_cast<float>(time_step.total_milliseconds())*d_textSpeed); previous_time = time; absarea.offset(Point(xOffset, 0)); // see if we may need to adjust horizontal position if( horzScrollbar->isVisible() ){ switch(d_horzFormatting) { case LeftAligned: case WordWrapLeftAligned: case Justified: case WordWrapJustified: absarea.offset(Point(-horzScrollbar->getScrollPosition(), 0)); break; case Centred: case WordWrapCentred: absarea.setWidth(horzScrollbar->getDocumentSize()); absarea.offset(Point(-horzScrollbar->getScrollPosition(), 0)); break; case RightAligned: case WordWrapRightAligned: absarea.offset(Point(horzScrollbar->getScrollPosition(), 0)); break; } } // adjust y positioning according to formatting option switch(d_vertFormatting) { case TopAligned: absarea.d_top -= vertScrollbar->getScrollPosition(); break; case VertCentred: // if scroll bar is in use, act like TopAligned if( vertScrollbar->isVisible() ){ absarea.d_top -= vertScrollbar->getScrollPosition(); } // no scroll bar, so centre text instead. else{ absarea.d_top += PixelAligned((absarea.getHeight() - textHeight) * 0.5f); } break; case BottomAligned: absarea.d_top = absarea.d_bottom - textHeight; absarea.d_top += vertScrollbar->getScrollPosition(); break; } // offset the font little down so that it's centered within its own spacing absarea.d_top += (font->getLineSpacing() - font->getFontHeight()) * 0.5f; // calculate final colours ColourRect final_cols(d_textCols); final_cols.modulateAlpha(d_window->getEffectiveAlpha()); // cache the text for rendering. d_window->getRenderCache().cacheText(d_window->getText(), font, (TextFormatting)d_horzFormatting, absarea, 0, final_cols, &clipper); }
/************************************************************************* Renders text on the display. Return number of lines output. *************************************************************************/ size_t Font::drawText(const String& text, const Rect& draw_area, float z, const Rect& clip_rect, TextFormatting fmt, const ColourRect& colours, float x_scale, float y_scale) { size_t thisCount; size_t lineCount = 0; float y_base = draw_area.d_top + getBaseline(y_scale); Rect tmpDrawArea( PixelAligned(draw_area.d_left), PixelAligned(draw_area.d_top), PixelAligned(draw_area.d_right), PixelAligned(draw_area.d_bottom) ); size_t lineStart = 0, lineEnd = 0; String currLine; while (lineEnd < text.length()) { if ((lineEnd = text.find_first_of('\n', lineStart)) == String::npos) lineEnd = text.length(); currLine = text.substr(lineStart, lineEnd - lineStart); lineStart = lineEnd + 1; // +1 to skip \n char switch(fmt) { case LeftAligned: drawTextLine(currLine, Vector3(tmpDrawArea.d_left, y_base, z), clip_rect, colours, x_scale, y_scale); thisCount = 1; y_base += getLineSpacing(y_scale); break; case RightAligned: drawTextLine(currLine, Vector3(tmpDrawArea.d_right - getTextExtent(currLine, x_scale), y_base, z), clip_rect, colours, x_scale, y_scale); thisCount = 1; y_base += getLineSpacing(y_scale); break; case Centred: drawTextLine(currLine, Vector3(PixelAligned(tmpDrawArea.d_left + ((tmpDrawArea.getWidth() - getTextExtent(currLine, x_scale)) / 2.0f)), y_base, z), clip_rect, colours, x_scale, y_scale); thisCount = 1; y_base += getLineSpacing(y_scale); break; case Justified: // new function in order to keep drawTextLine's signature unchanged drawTextLineJustified(currLine, draw_area, Vector3(tmpDrawArea.d_left, y_base, z), clip_rect, colours, x_scale, y_scale); thisCount = 1; y_base += getLineSpacing(y_scale); break; case WordWrapLeftAligned: thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, LeftAligned, colours, x_scale, y_scale); tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale); break; case WordWrapRightAligned: thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, RightAligned, colours, x_scale, y_scale); tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale); break; case WordWrapCentred: thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, Centred, colours, x_scale, y_scale); tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale); break; case WordWrapJustified: // no change needed thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, Justified, colours, x_scale, y_scale); tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale); break; default: throw InvalidRequestException("Font::drawText - Unknown or unsupported TextFormatting value specified."); } lineCount += thisCount; } // should not return 0 return ceguimax(lineCount, (size_t)1); }
void ImageryComponent::render_impl(Window& srcWindow, Rect& destRect, float base_z, const CEGUI::ColourRect* modColours, const Rect* clipper, bool clipToDisplay) const { // get final image to use. const Image* img = isImageFetchedFromProperty() ? PropertyHelper::stringToImage(srcWindow.getProperty(d_imagePropertyName)) : d_image; // do not draw anything if image is not set. if (!img) return; HorizontalFormatting horzFormatting = d_horzFormatPropertyName.empty() ? d_horzFormatting : FalagardXMLHelper::stringToHorzFormat(srcWindow.getProperty(d_horzFormatPropertyName)); VerticalFormatting vertFormatting = d_vertFormatPropertyName.empty() ? d_vertFormatting : FalagardXMLHelper::stringToVertFormat(srcWindow.getProperty(d_vertFormatPropertyName)); uint horzTiles, vertTiles; float xpos, ypos; Size imgSz(img->getSize()); // calculate final colours to be used ColourRect finalColours; initColoursRect(srcWindow, modColours, finalColours); // calculate initial x co-ordinate and horizontal tile count according to formatting options switch (horzFormatting) { case HF_STRETCHED: imgSz.d_width = destRect.getWidth(); xpos = destRect.d_left; horzTiles = 1; break; case HF_TILED: xpos = destRect.d_left; horzTiles = (uint)((destRect.getWidth() + (imgSz.d_width - 1)) / imgSz.d_width); break; case HF_LEFT_ALIGNED: xpos = destRect.d_left; horzTiles = 1; break; case HF_CENTRE_ALIGNED: xpos = destRect.d_left + PixelAligned((destRect.getWidth() - imgSz.d_width) * 0.5f); horzTiles = 1; break; case HF_RIGHT_ALIGNED: xpos = destRect.d_right - imgSz.d_width; horzTiles = 1; break; default: throw InvalidRequestException("ImageryComponent::render - An unknown HorizontalFormatting value was specified."); } // calculate initial y co-ordinate and vertical tile count according to formatting options switch (vertFormatting) { case VF_STRETCHED: imgSz.d_height = destRect.getHeight(); ypos = destRect.d_top; vertTiles = 1; break; case VF_TILED: ypos = destRect.d_top; vertTiles = (uint)((destRect.getHeight() + (imgSz.d_height - 1)) / imgSz.d_height); break; case VF_TOP_ALIGNED: ypos = destRect.d_top; vertTiles = 1; break; case VF_CENTRE_ALIGNED: ypos = destRect.d_top + PixelAligned((destRect.getHeight() - imgSz.d_height) * 0.5f); vertTiles = 1; break; case VF_BOTTOM_ALIGNED: ypos = destRect.d_bottom - imgSz.d_height; vertTiles = 1; break; default: throw InvalidRequestException("ImageryComponent::render - An unknown VerticalFormatting value was specified."); } // perform final rendering (actually is now a caching of the images which will be drawn) Rect finalRect; Rect finalClipper; const Rect* clippingRect; finalRect.d_top = ypos; finalRect.d_bottom = ypos + imgSz.d_height; for (uint row = 0; row < vertTiles; ++row) { finalRect.d_left = xpos; finalRect.d_right = xpos + imgSz.d_width; for (uint col = 0; col < horzTiles; ++col) { // use custom clipping for right and bottom edges when tiling the imagery if (((vertFormatting == VF_TILED) && row == vertTiles - 1) || ((horzFormatting == HF_TILED) && col == horzTiles - 1)) { finalClipper = clipper ? clipper->getIntersection(destRect) : destRect; clippingRect = &finalClipper; } // not tiliing, or not on far edges, just used passed in clipper (if any). else { clippingRect = clipper; } // add image to the rendering cache for the target window. srcWindow.getRenderCache().cacheImage(*img, finalRect, base_z, finalColours, clippingRect, clipToDisplay); finalRect.d_left += imgSz.d_width; finalRect.d_right += imgSz.d_width; } finalRect.d_top += imgSz.d_height; finalRect.d_bottom += imgSz.d_height; } }
/************************************************************************* Queues an area of the associated Texture the be drawn on the screen. Low-level routine not normally used! *************************************************************************/ void Imageset::draw(GeometryBuffer& buffer, const Rect& source_rect, const Rect& dest_rect, const Rect* clip_rect,const ColourRect& colours, QuadSplitMode quad_split_mode) const { // get the rect area that we will actually draw to (i.e. perform clipping) Rect final_rect(clip_rect ? dest_rect.getIntersection(*clip_rect) : dest_rect ); // check if rect was totally clipped if ((final_rect.getWidth() == 0) || (final_rect.getHeight() == 0)) return; // Fix bug #45 // Obtain correct scale values from the texture const float x_scale = d_texture->getTexelScaling().d_x; const float y_scale = d_texture->getTexelScaling().d_y; float tex_per_pix_x = source_rect.getWidth() / dest_rect.getWidth(); float tex_per_pix_y = source_rect.getHeight() / dest_rect.getHeight(); // calculate final, clipped, texture co-ordinates Rect tex_rect((source_rect.d_left + ((final_rect.d_left - dest_rect.d_left) * tex_per_pix_x)) * x_scale, (source_rect.d_top + ((final_rect.d_top - dest_rect.d_top) * tex_per_pix_y)) * y_scale, (source_rect.d_right + ((final_rect.d_right - dest_rect.d_right) * tex_per_pix_x)) * x_scale, (source_rect.d_bottom + ((final_rect.d_bottom - dest_rect.d_bottom) * tex_per_pix_y)) * y_scale); final_rect.d_left = PixelAligned(final_rect.d_left); final_rect.d_right = PixelAligned(final_rect.d_right); final_rect.d_top = PixelAligned(final_rect.d_top); final_rect.d_bottom = PixelAligned(final_rect.d_bottom); Vertex vbuffer[6]; // vertex 0 vbuffer[0].position = Vector3(final_rect.d_left, final_rect.d_top, 0.0f); vbuffer[0].colour_val = colours.d_top_left; vbuffer[0].tex_coords = Vector2(tex_rect.d_left, tex_rect.d_top); // vertex 1 vbuffer[1].position = Vector3(final_rect.d_left, final_rect.d_bottom, 0.0f); vbuffer[1].colour_val = colours.d_bottom_left; vbuffer[1].tex_coords = Vector2(tex_rect.d_left, tex_rect.d_bottom); // vertex 2 vbuffer[2].position.d_x = final_rect.d_right; vbuffer[2].position.d_z = 0.0f; vbuffer[2].colour_val = colours.d_bottom_right; vbuffer[2].tex_coords.d_x = tex_rect.d_right; // top-left to bottom-right diagonal if (quad_split_mode == TopLeftToBottomRight) { vbuffer[2].position.d_y = final_rect.d_bottom; vbuffer[2].tex_coords.d_y = tex_rect.d_bottom; } // bottom-left to top-right diagonal else { vbuffer[2].position.d_y = final_rect.d_top; vbuffer[2].tex_coords.d_y = tex_rect.d_top; } // vertex 3 vbuffer[3].position = Vector3(final_rect.d_right, final_rect.d_top, 0.0f); vbuffer[3].colour_val = colours.d_top_right; vbuffer[3].tex_coords = Vector2(tex_rect.d_right, tex_rect.d_top); // vertex 4 vbuffer[4].position.d_x = final_rect.d_left; vbuffer[4].position.d_z = 0.0f; vbuffer[4].colour_val = colours.d_top_left; vbuffer[4].tex_coords.d_x = tex_rect.d_left; // top-left to bottom-right diagonal if (quad_split_mode == TopLeftToBottomRight) { vbuffer[4].position.d_y = final_rect.d_top; vbuffer[4].tex_coords.d_y = tex_rect.d_top; } // bottom-left to top-right diagonal else { vbuffer[4].position.d_y = final_rect.d_bottom; vbuffer[4].tex_coords.d_y = tex_rect.d_bottom; } // vertex 5 vbuffer[5].position = Vector3(final_rect.d_right, final_rect.d_bottom, 0.0f); vbuffer[5].colour_val= colours.d_bottom_right; vbuffer[5].tex_coords = Vector2(tex_rect.d_right, tex_rect.d_bottom); // TODO: Remove cast when GeometryBuffer gets it's APIs fixed! buffer.setActiveTexture((Texture*)d_texture); buffer.appendGeometry(vbuffer, 6); }
void FrameComponent::doBackgroundRender(Window& srcWindow, Rect& destRect, const ColourRect& colours, const Rect* clipper, bool /*clipToDisplay*/) const { HorizontalFormatting horzFormatting = d_horzFormatPropertyName.empty() ? d_horzFormatting : FalagardXMLHelper::stringToHorzFormat(srcWindow.getProperty(d_horzFormatPropertyName)); VerticalFormatting vertFormatting = d_vertFormatPropertyName.empty() ? d_vertFormatting : FalagardXMLHelper::stringToVertFormat(srcWindow.getProperty(d_vertFormatPropertyName)); uint horzTiles, vertTiles; float xpos, ypos; Size imgSz(d_frameImages[FIC_BACKGROUND]->getSize()); // calculate initial x co-ordinate and horizontal tile count according to formatting options switch (horzFormatting) { case HF_STRETCHED: imgSz.d_width = destRect.getWidth(); xpos = destRect.d_left; horzTiles = 1; break; case HF_TILED: xpos = destRect.d_left; horzTiles = std::abs(static_cast<int>( (destRect.getWidth() + (imgSz.d_width - 1)) / imgSz.d_width)); break; case HF_LEFT_ALIGNED: xpos = destRect.d_left; horzTiles = 1; break; case HF_CENTRE_ALIGNED: xpos = destRect.d_left + PixelAligned((destRect.getWidth() - imgSz.d_width) * 0.5f); horzTiles = 1; break; case HF_RIGHT_ALIGNED: xpos = destRect.d_right - imgSz.d_width; horzTiles = 1; break; default: CEGUI_THROW(InvalidRequestException("FrameComponent::doBackgroundRender - An unknown HorizontalFormatting value was specified.")); } // calculate initial y co-ordinate and vertical tile count according to formatting options switch (vertFormatting) { case VF_STRETCHED: imgSz.d_height = destRect.getHeight(); ypos = destRect.d_top; vertTiles = 1; break; case VF_TILED: ypos = destRect.d_top; vertTiles = std::abs(static_cast<int>( (destRect.getHeight() + (imgSz.d_height - 1)) / imgSz.d_height)); break; case VF_TOP_ALIGNED: ypos = destRect.d_top; vertTiles = 1; break; case VF_CENTRE_ALIGNED: ypos = destRect.d_top + PixelAligned((destRect.getHeight() - imgSz.d_height) * 0.5f); vertTiles = 1; break; case VF_BOTTOM_ALIGNED: ypos = destRect.d_bottom - imgSz.d_height; vertTiles = 1; break; default: CEGUI_THROW(InvalidRequestException("FrameComponent::doBackgroundRender - An unknown VerticalFormatting value was specified.")); } // perform final rendering (actually is now a caching of the images which will be drawn) Rect finalRect; Rect finalClipper; const Rect* clippingRect; finalRect.d_top = ypos; finalRect.d_bottom = ypos + imgSz.d_height; for (uint row = 0; row < vertTiles; ++row) { finalRect.d_left = xpos; finalRect.d_right = xpos + imgSz.d_width; for (uint col = 0; col < horzTiles; ++col) { // use custom clipping for right and bottom edges when tiling the imagery if (((vertFormatting == VF_TILED) && row == vertTiles - 1) || ((horzFormatting == HF_TILED) && col == horzTiles - 1)) { finalClipper = clipper ? clipper->getIntersection(destRect) : destRect; clippingRect = &finalClipper; } // not tiliing, or not on far edges, just used passed in clipper (if any). else { clippingRect = clipper; } // add image to the rendering cache for the target window. d_frameImages[FIC_BACKGROUND]->draw(srcWindow.getGeometryBuffer(), finalRect, clippingRect, colours); finalRect.d_left += imgSz.d_width; finalRect.d_right += imgSz.d_width; } finalRect.d_top += imgSz.d_height; finalRect.d_bottom += imgSz.d_height; } }