void
stage_manager::
reset() {
if (_is_first_pos_set) {
if (_report_range.is_end_pos) {
pos_t final_pos(_report_range.end_pos);
for (pos_t i(_max_pos+1); i<final_pos; ++i) {
process_pos(i);
}
}
} else if (_report_range.is_begin_pos && _report_range.is_end_pos) {
// never read any data in this case, so we just write out
// the approriate range of zeros for consistency:
//
_min_pos=_report_range.begin_pos;
const pos_t end(_report_range.end_pos);
for (pos_t i(_report_range.begin_pos); i<end; ++i) {
process_pos(i);
}
}
finish_process_pos();
// reset to ground state:
_is_first_pos_set=false;
_is_head_pos=false;
}
void playFinalMatch(int numGames, int gameNo,
team_t* team1, team_t* team2, int* goals1, int* goals2) {
playMatchGen(team1, team2, goals1, goals2);
// handle visualization
handleGame(36 + final_pos(numGames) + gameNo,
team1->name, team2->name, *goals1, *goals2);
}
//----------------------------------------------------------------------------//
void RenderedStringWidgetComponent::draw(GeometryBuffer& /*buffer*/,
const Vector2& position,
const CEGUI::ColourRect* /*mod_colours*/,
const Rect* /*clip_rect*/,
const float vertical_space,
const float /*space_extra*/) const
{
if (!d_window)
return;
// HACK: re-adjust for inner-rect of parent
float x_adj = 0, y_adj = 0;
Window* parent = d_window->getParent();
if (parent)
{
const CEGUI::Rect outer(parent->getUnclippedOuterRect());
const CEGUI::Rect inner(parent->getUnclippedInnerRect());
x_adj = inner.d_left - outer.d_left;
y_adj = inner.d_top - outer.d_top;
}
// HACK: re-adjust for inner-rect of parent (Ends)
Vector2 final_pos(position);
// handle formatting options
switch (d_verticalFormatting)
{
case VF_BOTTOM_ALIGNED:
final_pos.d_y += vertical_space - getPixelSize().d_height;
break;
case VF_STRETCHED:
Logger::getSingleton().logEvent("RenderedStringWidgetComponent::draw: "
"VF_STRETCHED specified but is unsupported for Widget types; "
"defaulting to VF_CENTRE_ALIGNED instead.");
// intentional fall-through.
case VF_CENTRE_ALIGNED:
final_pos.d_y += (vertical_space - getPixelSize().d_height) / 2 ;
break;
case VF_TOP_ALIGNED:
// nothing additional to do for this formatting option.
break;
default:
CEGUI_THROW(InvalidRequestException("RenderedStringTextComponent::draw: "
"unknown VerticalFormatting option specified."));
}
// we do not actually draw the widget, we just move it into position.
const UVector2 wpos(UDim(0, final_pos.d_x + d_padding.d_left - x_adj),
UDim(0, final_pos.d_y + d_padding.d_top - y_adj));
d_window->setPosition(wpos);
}
//----------------------------------------------------------------------------//
void RenderedStringTextComponent::draw(GeometryBuffer& buffer,
const Vector2& position,
const ColourRect* mod_colours,
const Rect* clip_rect,
const float vertical_space,
const float space_extra) const
{
Font* fnt = d_font ? d_font : System::getSingleton().getDefaultFont();
if (!fnt)
return;
Vector2 final_pos(position);
float y_scale = 1.0f;
// handle formatting options
switch (d_verticalFormatting)
{
case VF_BOTTOM_ALIGNED:
final_pos.d_y += vertical_space - getPixelSize().d_height;
break;
case VF_CENTRE_ALIGNED:
final_pos.d_y += (vertical_space - getPixelSize().d_height) / 2 ;
break;
case VF_STRETCHED:
y_scale = vertical_space / getPixelSize().d_height;
break;
case VF_TOP_ALIGNED:
// nothing additional to do for this formatting option.
break;
default:
throw InvalidRequestException("RenderedStringTextComponent::draw: "
"unknown VerticalFormatting option specified.");
}
// apply padding to position:
final_pos += d_padding.getPosition();
// apply modulative colours if needed.
ColourRect final_cols(d_colours);
if (mod_colours)
final_cols *= *mod_colours;
// draw the text string.
fnt->drawText(buffer, d_text, final_pos, clip_rect, final_cols,
space_extra, 1.0f, y_scale);
}
/*************************************************************************
Draw the element chain starting with this element.
*************************************************************************/
void RenderableElement::draw(const Vector3& position, const Rect& clip_rect)
{
Vector3 final_pos(position);
final_pos.d_x += d_area.d_left;
final_pos.d_y += d_area.d_top;
// call implementation function to perform actual rendering
draw_impl(final_pos, clip_rect);
// render next element in the chain if any.
if (d_next != NULL)
{
d_next->draw(position, clip_rect);
}
}
std::list<MovePathNode> Fleet::MovePath(const std::list<int>& route) const {
std::list<MovePathNode> retval;
if (route.empty())
return retval; // nowhere to go => empty path
// if (route.size() == 1) do nothing special. this fleet is probably on the starlane leading to
// its final destination. normal looping to read destination should work fine
if (route.size() == 2 && route.front() == route.back())
return retval; // nowhere to go => empty path
if (this->Speed() < FLEET_MOVEMENT_EPSILON) {
retval.push_back(MovePathNode(this->X(), this->Y(), true, ETA_NEVER, this->SystemID(), INVALID_OBJECT_ID, INVALID_OBJECT_ID));
return retval; // can't move => path is just this system with explanatory ETA
}
double fuel = Fuel();
double max_fuel = MaxFuel();
//Logger().debugStream() << "Fleet " << this->Name() << " movePath fuel: " << fuel << " sys id: " << this->SystemID();
// determine all systems where fleet(s) can be resupplied if fuel runs out
int owner = this->Owner();
const Empire* empire = Empires().Lookup(owner);
std::set<int> fleet_supplied_systems;
std::set<int> unobstructed_systems;
if (empire) {
fleet_supplied_systems = empire->FleetSupplyableSystemIDs();
unobstructed_systems = empire->SupplyUnobstructedSystems();
}
// determine if, given fuel available and supplyable systems, fleet will ever be able to move
if (fuel < 1.0 &&
this->SystemID() != INVALID_OBJECT_ID &&
fleet_supplied_systems.find(this->SystemID()) == fleet_supplied_systems.end())
{
MovePathNode node(this->X(), this->Y(), true, ETA_OUT_OF_RANGE,
this->SystemID(),
INVALID_OBJECT_ID,
INVALID_OBJECT_ID);
retval.push_back(node);
return retval; // can't move => path is just this system with explanatory ETA
}
// get iterator pointing to System* on route that is the first after where this fleet is currently.
// if this fleet is in a system, the iterator will point to the system after the current in the route
// if this fleet is not in a system, the iterator will point to the first system in the route
std::list<int>::const_iterator route_it = route.begin();
if (*route_it == SystemID())
++route_it; // first system in route is current system of this fleet. skip to the next system
if (route_it == route.end())
return retval; // current system of this fleet is the *only* system in the route. path is empty.
// get current, previous and next systems of fleet
const System* cur_system = GetSystem(this->SystemID()); // may be 0
const System* prev_system = GetSystem(this->PreviousSystemID());// may be 0 if this fleet is not moving or ordered to move
const System* next_system = GetSystem(*route_it); // can't use this->NextSystemID() because this fleet may not be moving and may not have a next system. this might occur when a fleet is in a system, not ordered to move or ordered to move to a system, but a projected fleet move line is being calculated to a different system
if (!next_system) {
Logger().errorStream() << "Fleet::MovePath couldn't get next system with id " << *route_it << " for this fleet " << this->Name();
return retval;
}
//Logger().debugStream() << "initial cur system: " << (cur_system ? cur_system->Name() : "(none)") <<
// " prev system: " << (prev_system ? prev_system->Name() : "(none)") <<
// " next system: " << (next_system ? next_system->Name() : "(none)");
// place initial position MovePathNode
MovePathNode initial_pos(this->X(), this->Y(), false /* not an end of turn node */, 0 /* turns taken to reach position of node */,
(cur_system ? cur_system->ID() : INVALID_OBJECT_ID),
(prev_system ? prev_system->ID() : INVALID_OBJECT_ID),
(next_system ? next_system->ID() : INVALID_OBJECT_ID));
retval.push_back(initial_pos);
const int TOO_LONG = 100; // limit on turns to simulate. 99 turns max keeps ETA to two digits, making UI work better
int turns_taken = 1;
double turn_dist_remaining = m_speed; // additional distance that can be travelled in current turn of fleet movement being simulated
double cur_x = this->X();
double cur_y = this->Y();
double next_x = next_system->X();
double next_y = next_system->Y();
// simulate fleet movement given known speed, starting position, fuel limit and systems on route
// need to populate retval with MovePathNodes that indicate the correct position, whether this
// fleet will end a turn at the node, the turns it will take to reach the node, and (when applicable)
// the current (if at a system), previous and next system IDs at which the fleet will be. the
// previous and next system ids are needed to know what starlane a given node is located on, if any.
// nodes at systems don't need previous system ids to be valid, but should have next system ids
// valid so that when rendering starlanes using the returned move path, lines departing a system
// can be drawn on the correct side of the system icon
while (turns_taken < TOO_LONG) {
// each loop iteration moves the current position to the next location of interest along the move
// path, and then adds a node at that position.
//Logger().debugStream() << " starting iteration";
//if (cur_system)
// Logger().debugStream() << " at system " << cur_system->Name() << " with id " << cur_system->ID();
//else
// Logger().debugStream() << " at (" << cur_x << ", " << cur_y << ")";
// check if fuel limits movement or current system refuels passing fleet
if (cur_system) {
// check if current system has fuel supply available
if (fleet_supplied_systems.find(cur_system->ID()) != fleet_supplied_systems.end()) {
// current system has fuel supply. replenish fleet's supply and don't restrict movement
fuel = max_fuel;
//Logger().debugStream() << " ... at system with fuel supply. replenishing and continuing movement";
} else {
// current system has no fuel supply. require fuel to proceed
if (fuel >= 1.0) {
//Logger().debugStream() << " ... at system without fuel supply. consuming unit of fuel to proceed";
fuel -= 1.0;
} else {
//Logger().debugStream() << " ... at system without fuel supply. have insufficient fuel to continue moving";
turns_taken = ETA_OUT_OF_RANGE;
break;
}
}
}
// find distance to next system along path from current position
double dist_to_next_system = std::sqrt((next_x - cur_x)*(next_x - cur_x) + (next_y - cur_y)*(next_y - cur_y));
//Logger().debugStream() << " ... dist to next system: " << dist_to_next_system;
// move ship as far as it can go this turn, or to next system, whichever is closer, and deduct
// distance travelled from distance travellable this turn
if (turn_dist_remaining >= FLEET_MOVEMENT_EPSILON) {
double dist_travelled_this_step = std::min(turn_dist_remaining, dist_to_next_system);
//Logger().debugStream() << " ... fleet moving " << dist_travelled_this_step << " this iteration. dist to next system: " << dist_to_next_system << " and turn_dist_remaining: " << turn_dist_remaining;
double x_dist = next_x - cur_x;
double y_dist = next_y - cur_y;
// dist_to_next_system = std::sqrt(x_dist * x_dist + y_dist * y_dist); // should already equal this distance, so don't need to recalculate
double unit_vec_x = x_dist / dist_to_next_system;
double unit_vec_y = y_dist / dist_to_next_system;
cur_x += unit_vec_x*dist_travelled_this_step;
cur_y += unit_vec_y*dist_travelled_this_step;
turn_dist_remaining -= dist_travelled_this_step;
dist_to_next_system -= dist_travelled_this_step;
// if moved away any distance from a system, are no longer in that system
if (cur_system && dist_travelled_this_step >= FLEET_MOVEMENT_EPSILON) {
prev_system = cur_system;
cur_system = 0;
}
}
bool end_turn_at_cur_position = false;
// check if fleet can move any further this turn
if (turn_dist_remaining < FLEET_MOVEMENT_EPSILON) {
//Logger().debugStream() << " ... fleet can't move further this turn.";
turn_dist_remaining = 0.0; // to prevent any possible precision-related errors
end_turn_at_cur_position = true;
}
// check if current position is close enough to next system on route to qualify as at that system.
if (dist_to_next_system < FLEET_MOVEMENT_EPSILON) {
// close enough to be consider to be at next system.
// set current position to be exactly at next system to avoid rounding issues
cur_system = next_system;
cur_x = cur_system->X(); // update positions to ensure no round-off-errors
cur_y = cur_system->Y();
//Logger().debugStream() << " ... arrived at system: " << cur_system->Name();
// attempt to get next system on route, to update next system. if new current
// system is the end of the route, abort.
++route_it;
if (route_it == route.end())
break;
// update next system on route and distance to it from current position
next_system = GetEmpireKnownSystem(*route_it, owner);
if (!next_system) {
Logger().errorStream() << "Fleet::MovePath couldn't get system with id " << *route_it;
break;
}
next_x = next_system->X();
next_y = next_system->Y();
}
// if new position is an obstructed system, must end turn here
if (cur_system && unobstructed_systems.find(cur_system->ID()) == unobstructed_systems.end()) {
turn_dist_remaining = 0.0;
end_turn_at_cur_position = true;
}
// if turn done and turns taken is enough, abort simulation
if (end_turn_at_cur_position && (turns_taken + 1 >= TOO_LONG)) {
// exit loop before placing current node to simplify post-loop processing: now all cases require a post-loop node to be added
++turns_taken;
break;
}
// add MovePathNode for current position (end of turn position and/or system location)
MovePathNode cur_pos(cur_x, cur_y, end_turn_at_cur_position, turns_taken,
(cur_system ? cur_system->ID() : INVALID_OBJECT_ID),
(prev_system ? prev_system->ID() : INVALID_OBJECT_ID),
(next_system ? next_system->ID() : INVALID_OBJECT_ID));
retval.push_back(cur_pos);
// if the turn ended at this position, increment the turns taken and
// reset the distance remaining to be travelled during the current (now
// next) turn for the next loop iteration
if (end_turn_at_cur_position) {
//Logger().debugStream() << " ... end of simulated turn " << turns_taken;
++turns_taken;
turn_dist_remaining = m_speed;
}
}
// done looping. may have exited due to reaching end of path, lack of fuel, or turns taken getting too big
if (turns_taken == TOO_LONG)
turns_taken = ETA_NEVER;
MovePathNode final_pos(cur_x, cur_y, true, turns_taken,
(cur_system ? cur_system->ID() : INVALID_OBJECT_ID),
(prev_system ? prev_system->ID() : INVALID_OBJECT_ID),
(next_system ? next_system->ID() : INVALID_OBJECT_ID));
retval.push_back(final_pos);
return retval;
}
/*************************************************************************
Drawing method for the frame
*************************************************************************/
void RenderableFrame::draw_impl(const Vector3& position, const Rect& clip_rect) const
{
Vector3 final_pos(position);
float org_width = d_area.getWidth(), org_height = d_area.getHeight();
Size final_size;
ColourRect final_colours(d_colours);
bool calcColoursPerImage = !(d_useColoursPerImage || d_colours.isMonochromatic());
float leftfactor, rightfactor, topfactor, bottomfactor;
// calculate 'adjustments' required to accommodate corner pieces.
float coord_adj, size_adj;
// draw top-edge, if required
if (d_top != NULL) {
// calculate adjustments required if top-left corner will be rendered.
if (d_topleft != NULL) {
size_adj = (d_topleft->getWidth() - d_topleft->getOffsetX());
coord_adj = d_topleft->getWidth();
}
else {
coord_adj = 0;
size_adj = 0;
}
// calculate adjustments required if top-right corner will be rendered.
if (d_topright != NULL) {
size_adj += (d_topright->getWidth() + d_topright->getOffsetX());
}
final_size.d_width = org_width - size_adj;
final_size.d_height = d_top->getHeight();
final_pos.d_x = position.d_x + coord_adj;
final_pos.d_y = position.d_y;
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x - position.d_x + d_top->getOffsetX()) / org_width;
rightfactor = leftfactor + final_size.d_width / org_width;
topfactor = (final_pos.d_y - position.d_y + d_top->getOffsetY()) / org_height;
bottomfactor = topfactor + final_size.d_height / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
d_top->draw(final_pos, final_size, clip_rect, final_colours);
}
// draw bottom-edge, if required
if (d_bottom != NULL) {
// calculate adjustments required if bottom-left corner will be rendered.
if (d_bottomleft != NULL) {
size_adj = (d_bottomleft->getWidth() - d_bottomleft->getOffsetX());
coord_adj = d_bottomleft->getWidth();
}
else {
coord_adj = 0;
size_adj = 0;
}
// calculate adjustments required if bottom-right corner will be rendered.
if (d_bottomright != NULL) {
size_adj += (d_bottomright->getWidth() + d_bottomright->getOffsetX());
}
final_size.d_width = org_width - size_adj;
final_size.d_height = d_bottom->getHeight();
final_pos.d_x = position.d_x + coord_adj;
final_pos.d_y = position.d_y + org_height - final_size.d_height;
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x - position.d_x + d_bottom->getOffsetX()) / org_width;
rightfactor = leftfactor + final_size.d_width / org_width;
topfactor = (final_pos.d_y - position.d_y + d_bottom->getOffsetY()) / org_height;
bottomfactor = topfactor + final_size.d_height / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
d_bottom->draw(final_pos, final_size, clip_rect, final_colours);
}
// draw left-edge, if required
if (d_left != NULL) {
// calculate adjustments required if top-left corner will be rendered.
if (d_topleft != NULL) {
size_adj = (d_topleft->getHeight() - d_topleft->getOffsetY());
coord_adj = d_topleft->getHeight();
}
else {
coord_adj = 0;
size_adj = 0;
}
// calculate adjustments required if bottom-left corner will be rendered.
if (d_bottomleft != NULL) {
size_adj += (d_bottomleft->getHeight() + d_bottomleft->getOffsetY());
}
final_size.d_height = org_height - size_adj;
final_size.d_width = d_left->getWidth();
final_pos.d_y = position.d_y + coord_adj;
final_pos.d_x = position.d_x;
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x - position.d_x + d_left->getOffsetX()) / org_width;
rightfactor = leftfactor + final_size.d_width / org_width;
topfactor = (final_pos.d_y - position.d_y + d_left->getOffsetY()) / org_height;
bottomfactor = topfactor + final_size.d_height / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
d_left->draw(final_pos, final_size, clip_rect, final_colours);
}
// draw right-edge, if required
if (d_right != NULL) {
// calculate adjustments required if top-left corner will be rendered.
if (d_topright != NULL) {
size_adj = (d_topright->getHeight() - d_topright->getOffsetY());
coord_adj = d_topright->getHeight();
}
else {
coord_adj = 0;
size_adj = 0;
}
// calculate adjustments required if bottom-left corner will be rendered.
if (d_bottomright != NULL) {
size_adj += (d_bottomright->getHeight() + d_bottomright->getOffsetY());
}
final_size.d_height = org_height - size_adj;
final_size.d_width = d_right->getWidth();
final_pos.d_y = position.d_y + coord_adj;
final_pos.d_x = position.d_x + org_width - final_size.d_width;
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x - position.d_x + d_right->getOffsetX()) / org_width;
rightfactor = leftfactor + final_size.d_width / org_width;
topfactor = (final_pos.d_y - position.d_y + d_right->getOffsetY()) / org_height;
bottomfactor = topfactor + final_size.d_height / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
d_right->draw(final_pos, final_size, clip_rect, final_colours);
}
// draw required corner pieces...
if (d_topleft != NULL) {
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = d_topleft->getOffsetX() / org_width;
rightfactor = leftfactor + d_topleft->getWidth() / org_width;
topfactor = d_topleft->getOffsetY() / org_height;
bottomfactor = topfactor + d_topleft->getHeight() / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
d_topleft->draw(position, clip_rect, final_colours);
}
if (d_topright != NULL) {
final_pos.d_x = position.d_x + org_width - d_topright->getWidth();
final_pos.d_y = position.d_y;
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x - position.d_x + d_topright->getOffsetX()) / org_width;
rightfactor = leftfactor + d_topright->getWidth() / org_width;
topfactor = (final_pos.d_y - position.d_y + d_topright->getOffsetY()) / org_height;
bottomfactor = topfactor + d_topright->getHeight() / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
d_topright->draw(final_pos, clip_rect, final_colours);
}
if (d_bottomleft != NULL) {
final_pos.d_x = position.d_x;
final_pos.d_y = position.d_y + org_height - d_bottomleft->getHeight();
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x - position.d_x + d_bottomleft->getOffsetX()) / org_width;
rightfactor = leftfactor + d_bottomleft->getWidth() / org_width;
topfactor = (final_pos.d_y - position.d_y + d_bottomleft->getOffsetY()) / org_height;
bottomfactor = topfactor + d_bottomleft->getHeight() / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
d_bottomleft->draw(final_pos, clip_rect, final_colours);
}
if (d_bottomright != NULL) {
final_pos.d_x = position.d_x + org_width - d_bottomright->getWidth();
final_pos.d_y = position.d_y + org_height - d_bottomright->getHeight();
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x - position.d_x + d_bottomright->getOffsetX()) / org_width;
rightfactor = leftfactor + d_bottomright->getWidth() / org_width;
topfactor = (final_pos.d_y - position.d_y + d_bottomright->getOffsetY()) / org_height;
bottomfactor = topfactor + d_bottomright->getHeight() / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
d_bottomright->draw(final_pos, clip_rect, final_colours);
}
}
void RenderableFrame::draw_impl(RenderCache& renderCache) const
{
// TODO: This is a fairly substantial Cut, paste, and hack job.
// TODO: There are probably a thousand ways that this should be improved!
Rect destArea;
Vector3 final_pos(0,0,0);
float org_width = d_area.getWidth(), org_height = d_area.getHeight();
Size final_size;
ColourRect final_colours(d_colours);
bool calcColoursPerImage = !(d_useColoursPerImage || d_colours.isMonochromatic());
float leftfactor, rightfactor, topfactor, bottomfactor;
// calculate 'adjustments' required to accommodate corner pieces.
float coord_adj, size_adj;
// draw top-edge, if required
if (d_top != NULL) {
// calculate adjustments required if top-left corner will be rendered.
if (d_topleft != NULL) {
size_adj = (d_topleft->getWidth() - d_topleft->getOffsetX());
coord_adj = d_topleft->getWidth();
}
else {
coord_adj = 0;
size_adj = 0;
}
// calculate adjustments required if top-right corner will be rendered.
if (d_topright != NULL) {
size_adj += (d_topright->getWidth() + d_topright->getOffsetX());
}
final_size.d_width = org_width - size_adj;
final_size.d_height = d_top->getHeight();
final_pos.d_x = coord_adj;
final_pos.d_y = 0;
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x + d_top->getOffsetX()) / org_width;
rightfactor = leftfactor + final_size.d_width / org_width;
topfactor = (final_pos.d_y + d_top->getOffsetY()) / org_height;
bottomfactor = topfactor + final_size.d_height / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
destArea.d_left = final_pos.d_x;
destArea.d_top = final_pos.d_y;
destArea.d_right = final_pos.d_x + final_size.d_width;
destArea.d_bottom = final_pos.d_y + final_size.d_height;
renderCache.cacheImage(*d_top, destArea, 0, final_colours);
}
// draw bottom-edge, if required
if (d_bottom != NULL) {
// calculate adjustments required if bottom-left corner will be rendered.
if (d_bottomleft != NULL) {
size_adj = (d_bottomleft->getWidth() - d_bottomleft->getOffsetX());
coord_adj = d_bottomleft->getWidth();
}
else {
coord_adj = 0;
size_adj = 0;
}
// calculate adjustments required if bottom-right corner will be rendered.
if (d_bottomright != NULL) {
size_adj += (d_bottomright->getWidth() + d_bottomright->getOffsetX());
}
final_size.d_width = org_width - size_adj;
final_size.d_height = d_bottom->getHeight();
final_pos.d_x = coord_adj;
final_pos.d_y = org_height - final_size.d_height;
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x + d_bottom->getOffsetX()) / org_width;
rightfactor = leftfactor + final_size.d_width / org_width;
topfactor = (final_pos.d_y + d_bottom->getOffsetY()) / org_height;
bottomfactor = topfactor + final_size.d_height / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
destArea.d_left = final_pos.d_x;
destArea.d_top = final_pos.d_y;
destArea.d_right = final_pos.d_x + final_size.d_width;
destArea.d_bottom = final_pos.d_y + final_size.d_height;
renderCache.cacheImage(*d_bottom, destArea, 0, final_colours);
}
// draw left-edge, if required
if (d_left != NULL) {
// calculate adjustments required if top-left corner will be rendered.
if (d_topleft != NULL) {
size_adj = (d_topleft->getHeight() - d_topleft->getOffsetY());
coord_adj = d_topleft->getHeight();
}
else {
coord_adj = 0;
size_adj = 0;
}
// calculate adjustments required if bottom-left corner will be rendered.
if (d_bottomleft != NULL) {
size_adj += (d_bottomleft->getHeight() + d_bottomleft->getOffsetY());
}
final_size.d_height = org_height - size_adj;
final_size.d_width = d_left->getWidth();
final_pos.d_y = coord_adj;
final_pos.d_x = 0;
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x + d_left->getOffsetX()) / org_width;
rightfactor = leftfactor + final_size.d_width / org_width;
topfactor = (final_pos.d_y + d_left->getOffsetY()) / org_height;
bottomfactor = topfactor + final_size.d_height / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
destArea.d_left = final_pos.d_x;
destArea.d_top = final_pos.d_y;
destArea.d_right = final_pos.d_x + final_size.d_width;
destArea.d_bottom = final_pos.d_y + final_size.d_height;
renderCache.cacheImage(*d_left, destArea, 0, final_colours);
}
// draw right-edge, if required
if (d_right != NULL) {
// calculate adjustments required if top-left corner will be rendered.
if (d_topright != NULL) {
size_adj = (d_topright->getHeight() - d_topright->getOffsetY());
coord_adj = d_topright->getHeight();
}
else {
coord_adj = 0;
size_adj = 0;
}
// calculate adjustments required if bottom-left corner will be rendered.
if (d_bottomright != NULL) {
size_adj += (d_bottomright->getHeight() + d_bottomright->getOffsetY());
}
final_size.d_height = org_height - size_adj;
final_size.d_width = d_right->getWidth();
final_pos.d_y = coord_adj;
final_pos.d_x = org_width - final_size.d_width;
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x + d_right->getOffsetX()) / org_width;
rightfactor = leftfactor + final_size.d_width / org_width;
topfactor = (final_pos.d_y + d_right->getOffsetY()) / org_height;
bottomfactor = topfactor + final_size.d_height / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
destArea.d_left = final_pos.d_x;
destArea.d_top = final_pos.d_y;
destArea.d_right = final_pos.d_x + final_size.d_width;
destArea.d_bottom = final_pos.d_y + final_size.d_height;
renderCache.cacheImage(*d_right, destArea, 0, final_colours);
}
// draw required corner pieces...
if (d_topleft != NULL) {
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = d_topleft->getOffsetX() / org_width;
rightfactor = leftfactor + d_topleft->getWidth() / org_width;
topfactor = d_topleft->getOffsetY() / org_height;
bottomfactor = topfactor + d_topleft->getHeight() / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
destArea.d_left = 0;
destArea.d_top = 0;
destArea.d_right = d_topleft->getWidth();
destArea.d_bottom = d_topleft->getHeight();
renderCache.cacheImage(*d_topleft, destArea, 0, final_colours);
}
if (d_topright != NULL) {
final_pos.d_x = org_width - d_topright->getWidth();
final_pos.d_y = 0;
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x + d_topright->getOffsetX()) / org_width;
rightfactor = leftfactor + d_topright->getWidth() / org_width;
topfactor = (final_pos.d_y + d_topright->getOffsetY()) / org_height;
bottomfactor = topfactor + d_topright->getHeight() / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
destArea.d_left = final_pos.d_x;
destArea.d_top = final_pos.d_y;
destArea.d_right = final_pos.d_x + d_topright->getWidth();
destArea.d_bottom = final_pos.d_y + d_topright->getHeight();
renderCache.cacheImage(*d_topright, destArea, 0, final_colours);
}
if (d_bottomleft != NULL) {
final_pos.d_x = 0;
final_pos.d_y = org_height - d_bottomleft->getHeight();
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x + d_bottomleft->getOffsetX()) / org_width;
rightfactor = leftfactor + d_bottomleft->getWidth() / org_width;
topfactor = (final_pos.d_y + d_bottomleft->getOffsetY()) / org_height;
bottomfactor = topfactor + d_bottomleft->getHeight() / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
destArea.d_left = final_pos.d_x;
destArea.d_top = final_pos.d_y;
destArea.d_right = final_pos.d_x + d_bottomleft->getWidth();
destArea.d_bottom = final_pos.d_y + d_bottomleft->getHeight();
renderCache.cacheImage(*d_bottomleft, destArea, 0, final_colours);
}
if (d_bottomright != NULL) {
final_pos.d_x = org_width - d_bottomright->getWidth();
final_pos.d_y = org_height - d_bottomright->getHeight();
// calculate final colours that are to be used
if (calcColoursPerImage)
{
leftfactor = (final_pos.d_x + d_bottomright->getOffsetX()) / org_width;
rightfactor = leftfactor + d_bottomright->getWidth() / org_width;
topfactor = (final_pos.d_y + d_bottomright->getOffsetY()) / org_height;
bottomfactor = topfactor + d_bottomright->getHeight() / org_height;
final_colours = d_colours.getSubRectangle( leftfactor, rightfactor, topfactor, bottomfactor);
}
destArea.d_left = final_pos.d_x;
destArea.d_top = final_pos.d_y;
destArea.d_right = final_pos.d_x + d_bottomright->getWidth();
destArea.d_bottom = final_pos.d_y + d_bottomright->getHeight();
renderCache.cacheImage(*d_bottomright, destArea, 0, final_colours);
}
}
//----------------------------------------------------------------------------//
void RenderedStringWidgetComponent::draw(const Window* ref_wnd,
GeometryBuffer& buffer,
const Vector2f& position,
const CEGUI::ColourRect* /*mod_colours*/,
const Rectf* clip_rect,
const float vertical_space,
const float /*space_extra*/) const
{
Window* const window = getEffectiveWindow(ref_wnd);
if (!window)
return;
// HACK: re-adjust for inner-rect of parent
float x_adj = 0, y_adj = 0;
Window* parent = window->getParent();
if (parent)
{
const Rectf& outer(parent->getUnclippedOuterRect().get());
const Rectf& inner(parent->getUnclippedInnerRect().get());
x_adj = inner.d_min.d_x - outer.d_min.d_x;
y_adj = inner.d_min.d_y - outer.d_min.d_y;
}
// HACK: re-adjust for inner-rect of parent (Ends)
Vector2f final_pos(position);
// handle formatting options
switch (d_verticalFormatting)
{
case VF_BOTTOM_ALIGNED:
final_pos.d_y += vertical_space - getPixelSize(ref_wnd).d_height;
break;
case VF_STRETCHED:
Logger::getSingleton().logEvent("RenderedStringWidgetComponent::draw: "
"VF_STRETCHED specified but is unsupported for Widget types; "
"defaulting to VF_CENTRE_ALIGNED instead.");
// intentional fall-through.
case VF_CENTRE_ALIGNED:
final_pos.d_y += (vertical_space - getPixelSize(ref_wnd).d_height) / 2 ;
break;
case VF_TOP_ALIGNED:
// nothing additional to do for this formatting option.
break;
default:
CEGUI_THROW(InvalidRequestException(
"unknown VerticalFormatting option specified."));
}
// render the selection if needed
if (d_selectionImage && d_selected)
{
const Rectf select_area(position, getPixelSize(ref_wnd));
d_selectionImage->render(buffer, select_area, clip_rect, ColourRect(0xFF002FFF));
}
// we do not actually draw the widget, we just move it into position.
const UVector2 wpos(UDim(0, final_pos.d_x + d_padding.d_min.d_x - x_adj),
UDim(0, final_pos.d_y + d_padding.d_min.d_y - y_adj));
window->setPosition(wpos);
}
void Mesh::init_mesh(const aiScene* scene, const aiMesh* mesh, size_t index) {
std::cout << "Loading mesh named '" << mesh->mName.C_Str() << "'" << std::endl;
entries[index].material_index = mesh->mMaterialIndex;
if (!mesh->HasNormals()) {
std::cerr << "Mesh has no normals!" << std::endl;
} else {
if (mesh->mNumVertices > 0)
std::cerr << "First normal:" << mesh->mNormals[0].x << "," << mesh->mNormals[0].y << "," << mesh->mNormals[0].z << std::endl;
}
// Create vectors to store the transformed position and normals; initialize them to the origin.
std::vector<aiVector3D> final_pos(mesh->mNumVertices),
final_normal(mesh->mNumVertices);
for (size_t i = 0; i < mesh->mNumVertices; ++i) {
final_pos[i] = final_normal[i] = aiVector3D(0.0, 0.0, 0.0);
}
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
const aiVector3D zero_3d(0.0, 0.0, 0.0);
if (mesh->mNumBones) {
std::vector<aiMatrix4x4> bone_matrices(mesh->mNumBones);
// Calculate bone matrices.
for (size_t i = 0; i < mesh->mNumBones; ++i) {
const aiBone* bone = mesh->mBones[i];
bone_matrices[i] = bone->mOffsetMatrix;
std::cout << "Bone '" << bone->mName.C_Str() << "' includes " << bone->mNumWeights << " vertices:" << std::endl;
for (size_t j = 0; j < bone->mNumWeights; ++j) {
std::cout << ' ' << bone->mWeights[j].mVertexId;
}
std::cout << std::endl;
const aiNode* node = scene->mRootNode->FindNode(bone->mName.C_Str());
const aiNode* temp_node = node;
while (temp_node != NULL) {
bone_matrices[i] = temp_node->mTransformation * bone_matrices[i];
temp_node = temp_node->mParent;
}
}
// Update vertex positions according to calculated matrices
for (size_t i = 0; i < mesh->mNumBones; ++i) {
const aiBone* bone = mesh->mBones[i];
aiMatrix3x3 normal_matrix = aiMatrix3x3(bone_matrices[i]);
for (size_t j = 0; j < bone->mNumWeights; ++j) {
const aiVertexWeight *vertex_weight = &(bone->mWeights[j]);
size_t v = (size_t)(vertex_weight->mVertexId);
float w = vertex_weight->mWeight;
const aiVector3D *src_pos = &(mesh->mVertices[v]);
const aiVector3D *src_normal = &(mesh->mNormals[v]);
final_pos[v] += w * (bone_matrices[i] * (*src_pos));
final_normal[v] += w * (normal_matrix * (*src_normal));
}
std::cout << "bone " << i << ":" << std::endl;
std::cout << bone_matrices[i].a1 << ' ' << bone_matrices[i].a2 << ' ' << bone_matrices[i].a3 << ' ' << bone_matrices[i].a4 << std::endl;
std::cout << bone_matrices[i].b1 << ' ' << bone_matrices[i].b2 << ' ' << bone_matrices[i].b3 << ' ' << bone_matrices[i].b4 << std::endl;
std::cout << bone_matrices[i].c1 << ' ' << bone_matrices[i].c2 << ' ' << bone_matrices[i].c3 << ' ' << bone_matrices[i].c4 << std::endl;
std::cout << bone_matrices[i].d1 << ' ' << bone_matrices[i].d2 << ' ' << bone_matrices[i].d3 << ' ' << bone_matrices[i].d4 << std::endl;
}
// initialize our dimension trackers.
if (mesh->mNumVertices != 0) {
min_extremities.x = final_pos[0].x;
min_extremities.y = final_pos[0].y;
min_extremities.z = final_pos[0].z;
max_extremities = min_extremities;
}
// Add each updated vertex and calculate its extremities.
for (size_t i = 0; i < mesh->mNumVertices; ++i) {
const aiVector3D *diffuse_texture_coord = mesh->HasTextureCoords(0) ? &(mesh->mTextureCoords[0][i]) : &zero_3d;
const aiVector3D *specular_texture_coord = mesh->HasTextureCoords(1) ? &(mesh->mTextureCoords[1][i]) : &zero_3d;
// Find the extremities of this mesh so we can get a measurement for the object in object units.
if (final_pos[i].x < min_extremities.x) min_extremities.x = final_pos[i].x;
else if (final_pos[i].x > max_extremities.x) max_extremities.x = final_pos[i].x;
if (final_pos[i].y < min_extremities.y) min_extremities.y = final_pos[i].y;
else if (final_pos[i].y > max_extremities.y) max_extremities.y = final_pos[i].y;
if (final_pos[i].z < min_extremities.z) min_extremities.z = final_pos[i].z;
else if (final_pos[i].z > max_extremities.z) max_extremities.z = final_pos[i].z;
Vertex vertex(glm::vec3(final_pos[i].x, final_pos[i].y, final_pos[i].z),
glm::vec2(diffuse_texture_coord->x, diffuse_texture_coord->y),
glm::vec2(specular_texture_coord->x, specular_texture_coord->y),
glm::vec3(final_normal[i].x, final_normal[i].y, final_normal[i].z));
std::cout << "Adding vertex " << i << ": " << final_pos[i].x << "," << final_pos[i].y << "," << final_pos[i].z;
std::cout << "\t" << final_normal[i].x << "," << final_normal[i].y << "," << final_normal[i].z << std::endl;
std::cout << " was: " << mesh->mVertices[i].x << "," << mesh->mVertices[i].y << "," << mesh->mVertices[i].z << '\t';
std::cout << mesh->mNormals[i].x << "," << mesh->mNormals[i].y << "," << mesh->mNormals[i].z << std::endl;
// Accumulate the centroid_ of the object.
centroid_ += vertex.pos;
vertices.push_back(vertex);
}
} else {
for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
const aiVector3D* pos = &(mesh->mVertices[i]);
const aiVector3D* normal = &(mesh->mNormals[i]);
const aiVector3D* diffuse_texture_coord = mesh->HasTextureCoords(0) ? &(mesh->mTextureCoords[0][i]) : &zero_3d;
const aiVector3D* specular_texture_coord = mesh->HasTextureCoords(1) ? &(mesh->mTextureCoords[1][i]) : &zero_3d;
// Find the extremities of this mesh so we can get a measurement for the object in object units.
if (pos->x < min_extremities.x) min_extremities.x = pos->x;
else if (pos->x > max_extremities.x) max_extremities.x = pos->x;
if (pos->y < min_extremities.y) min_extremities.y = pos->y;
else if (pos->y > max_extremities.y) max_extremities.y = pos->y;
if (pos->z < min_extremities.z) min_extremities.z = pos->z;
else if (pos->z > max_extremities.z) max_extremities.z = pos->z;
Vertex v(glm::vec3(pos->x, pos->y, pos->z),
glm::vec2(diffuse_texture_coord->x, diffuse_texture_coord->y),
glm::vec2(specular_texture_coord->x, specular_texture_coord->y),
glm::vec3(normal->x, normal->y, normal->z));
// Accumulate the centroid_ of the object.
centroid_ += v.pos;
vertices.push_back(v);
}
}
centroid_ /= mesh->mNumVertices;
// Add vertices for each face
for (size_t i = 0; i < mesh->mNumFaces; ++i) {
const aiFace& face = mesh->mFaces[i];
if (face.mNumIndices != 3) {
std::cerr << "Face has " << face.mNumIndices << " indices; skipping" << std::endl;
continue;
}
indices.push_back(face.mIndices[0]);
indices.push_back(face.mIndices[1]);
indices.push_back(face.mIndices[2]);
}
// Create index buffer.
entries[index].init(vertices, indices);
}
int final_pos (int numGames){
if (numGames == 8)
return 0;
return final_pos (2 * numGames)+ 2*numGames;
}
//----------------------------------------------------------------------------//
void RenderedStringTextComponent::draw(const Window* ref_wnd,
GeometryBuffer& buffer,
const Vector2f& position,
const ColourRect* mod_colours,
const Rectf* clip_rect,
const float vertical_space,
const float space_extra) const
{
const Font* fnt = getEffectiveFont(ref_wnd);
if (!fnt)
return;
Vector2f final_pos(position);
float y_scale = 1.0f;
// handle formatting options
switch (d_verticalFormatting)
{
case VF_BOTTOM_ALIGNED:
final_pos.d_y += vertical_space - getPixelSize(ref_wnd).d_height;
break;
case VF_CENTRE_ALIGNED:
final_pos.d_y += (vertical_space - getPixelSize(ref_wnd).d_height) / 2 ;
break;
case VF_STRETCHED:
y_scale = vertical_space / getPixelSize(ref_wnd).d_height;
break;
case VF_TOP_ALIGNED:
// nothing additional to do for this formatting option.
break;
default:
CEGUI_THROW(InvalidRequestException(
"unknown VerticalFormatting option specified."));
}
// apply padding to position:
final_pos += d_padding.getPosition();
// apply modulative colours if needed.
ColourRect final_cols(d_colours);
if (mod_colours)
final_cols *= *mod_colours;
// render selection
if (d_selectionImage && d_selectionLength)
{
float sel_start_extent = 0, sel_end_extent = 0;
if (d_selectionStart > 0)
sel_start_extent = fnt->getTextExtent(d_text.substr(0, d_selectionStart));
sel_end_extent = fnt->getTextExtent(d_text.substr(0, d_selectionStart + d_selectionLength));
Rectf sel_rect(position.d_x + sel_start_extent,
position.d_y,
position.d_x + sel_end_extent,
position.d_y + vertical_space);
d_selectionImage->render(buffer, sel_rect, clip_rect, ColourRect(0xFF002FFF));
}
// draw the text string.
fnt->drawText(buffer, d_text, final_pos, clip_rect, final_cols,
space_extra, 1.0f, y_scale);
}
