void ImageryComponent::writeXMLToStream(OutStream& out_stream) const
{
// opening tag
out_stream << "<ImageryComponent>" << std::endl;
// write out area
d_area.writeXMLToStream(out_stream);
// write image
if (isImageFetchedFromProperty())
out_stream << "<ImageProperty name=\"" << d_imagePropertyName << "\" />" << std::endl;
else
out_stream << "<Image imageset=\"" << d_image->getImagesetName() << "\" image=\"" << d_image->getName() << "\" />" << std::endl;
// get base class to write colours
writeColoursXML(out_stream);
// write vert format, allowing base class to do this for us if a propety is in use
if (!writeVertFormatXML(out_stream))
{
// was not a property, so write out explicit formatting in use
out_stream << "<VertFormat type=\"" << FalagardXMLHelper::vertFormatToString(d_vertFormatting) << "\" />" << std::endl;
}
// write horz format, allowing base class to do this for us if a propety is in use
if (!writeHorzFormatXML(out_stream))
{
// was not a property, so write out explicit formatting in use
out_stream << "<HorzFormat type=\"" << FalagardXMLHelper::horzFormatToString(d_horzFormatting) << "\" />" << std::endl;
}
// closing tag
out_stream << "</ImageryComponent>" << std::endl;
}
void ImageryComponent::writeXMLToStream(XMLSerializer& xml_stream) const
{
// opening tag
xml_stream.openTag("ImageryComponent");
// write out area
d_area.writeXMLToStream(xml_stream);
// write image
if (isImageFetchedFromProperty())
xml_stream.openTag("ImageProperty")
.attribute("name", d_imagePropertyName)
.closeTag();
else
xml_stream.openTag("Image")
.attribute("imageset", d_image->getImagesetName())
.attribute("image", d_image->getName())
.closeTag();
// get base class to write colours
writeColoursXML(xml_stream);
// write vert format, allowing base class to do this for us if a propety is in use
if (!writeVertFormatXML(xml_stream))
{
// was not a property, so write out explicit formatting in use
xml_stream.openTag("VertFormat")
.attribute("type", FalagardXMLHelper::vertFormatToString(d_vertFormatting))
.closeTag();
}
// write horz format, allowing base class to do this for us if a propety is in use
if (!writeHorzFormatXML(xml_stream))
{
// was not a property, so write out explicit formatting in use
xml_stream.openTag("HorzFormat")
.attribute("type", FalagardXMLHelper::horzFormatToString(d_horzFormatting))
.closeTag();
}
// closing tag
xml_stream.closeTag();
}
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;
}
}
