void Container::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
QGraphicsItem::mousePressEvent(event);
if(this->isSelected())
{
QRectF r = this->rect();
QRectF corner1(r.width()/2 -8,0,16,5);
QRectF corner2(0,r.bottom()/2-8,5,16);
QRectF corner3(r.right()-5,r.bottom()/2-8,5,16);
QRectF corner4(r.width()/2 -8,r.bottom()-5,16,5);
if(corner1.contains(event->pos()))
{
_onResize = true;
_resizeType = 0;
}
else if(corner2.contains(event->pos()))
{
_onResize = true;
_resizeType = 1;
}
else if(corner3.contains(event->pos()))
{
_onResize = true;
_resizeType = 2;
}
else if(corner4.contains(event->pos()))
{
_onResize = true;
_resizeType = 3;
}
}
}
void CBoundingBoxAligned::Transform(const CMatrix3D& transform, CBoundingBoxOriented& result) const
{
// The idea is this: compute the corners of this bounding box, transform them according to the specified matrix,
// then derive the box center, orientation vectors, and half-sizes.
// TODO: this implementation can be further optimized; see Philip's comments on http://trac.wildfiregames.com/ticket/914
const CVector3D& pMin = m_Data[0];
const CVector3D& pMax = m_Data[1];
// Find the corners of these bounds. We only need some of the corners to derive the information we need, so let's
// not actually compute all of them. The corners are numbered starting from the minimum position (m_Data[0]), going
// counter-clockwise in the bottom plane, and then in the same order for the top plane (starting from the corner
// that's directly above the minimum position). Hence, corner0 is pMin and corner6 is pMax, so we don't need to
// custom-create those.
CVector3D corner0; // corner0 is pMin, no need to copy it
CVector3D corner1(pMax.X, pMin.Y, pMin.Z);
CVector3D corner3(pMin.X, pMin.Y, pMax.Z);
CVector3D corner4(pMin.X, pMax.Y, pMin.Z);
CVector3D corner6; // corner6 is pMax, no need to copy it
// transform corners to world space
corner0 = transform.Transform(pMin); // = corner0
corner1 = transform.Transform(corner1);
corner3 = transform.Transform(corner3);
corner4 = transform.Transform(corner4);
corner6 = transform.Transform(pMax); // = corner6
// Compute orientation vectors, half-size vector, and box center. We can get the orientation vectors by just taking
// the directional vectors from a specific corner point (corner0) to the other corners, once in each direction. The
// half-sizes are similarly computed by taking the distances of those sides and dividing them by 2. Finally, the
// center is simply the middle between the transformed pMin and pMax corners.
const CVector3D sideU(corner1 - corner0);
const CVector3D sideV(corner4 - corner0);
const CVector3D sideW(corner3 - corner0);
result.m_Basis[0] = sideU.Normalized();
result.m_Basis[1] = sideV.Normalized();
result.m_Basis[2] = sideW.Normalized();
result.m_HalfSizes = CVector3D(
sideU.Length()/2.f,
sideV.Length()/2.f,
sideW.Length()/2.f
);
result.m_Center = (corner0 + corner6) * 0.5f;
}
//------------------------------------------------------------------------------//
void GeoTerrainSection::_calcCurrentLod(Camera* cam)
{
Vector2 corner0(mSectionBound.getMinimum().x, mSectionBound.getMinimum().z);
Vector2 corner1(mSectionBound.getMinimum().x, mSectionBound.getMaximum().z);
Vector2 corner2(mSectionBound.getMaximum().x, mSectionBound.getMaximum().z);
Vector2 corner3(mSectionBound.getMaximum().x, mSectionBound.getMinimum().z);
Vector2 viewPoint(cam->getPosition().x, cam->getPosition().z);
// compute view distance to our 4 corners
float distance0 = viewPoint.distance(corner0);
float distance1 = viewPoint.distance(corner1);
float distance2 = viewPoint.distance(corner2);
float distance3 = viewPoint.distance(corner3);
// compute min distance as the test value
float dist = minimum(distance0, distance1);
dist = minimum(dist, distance2);
dist = minimum(dist, distance3);
// make sure the minimum distance is non-zero
dist = maximum(dist, 0.0001f);
// find the lowest lod which will suffice
mCurrentLod = 0;
bool finished = false;
float fScale = mCreator->getLodErrorScale();
float fLimit = mCreator->getRatioLimit();
while (!finished)
{
// find the ratio of variance over distance
float variance = mErrorMetrics[mCurrentLod];
float vRatio = (variance * fScale) / dist;
// if we exceed the ratio limit, move to the next lod
if (vRatio > fLimit
&& mCurrentLod + 1 < TOTAL_DETAIL_LEVELS)
{
++mCurrentLod;
}
else
{
finished=true;
}
}
}
Primitive::Ptr Renderer::CreateLine( const sf::Vector2f& begin, const sf::Vector2f& end, const sf::Color& color, float thickness ) {
// Get vector perpendicular to direction of the line vector.
// Vector is rotated CCW 90 degrees and normalized.
sf::Vector2f normal( end - begin );
std::swap( normal.x, normal.y );
float length = std::sqrt( normal.x * normal.x + normal.y * normal.y );
normal.x /= -length;
normal.y /= length;
sf::Vector2f corner0( begin + normal * ( thickness * .5f ) );
sf::Vector2f corner1( begin - normal * ( thickness * .5f ) );
sf::Vector2f corner2( end - normal * ( thickness * .5f ) );
sf::Vector2f corner3( end + normal * ( thickness * .5f ) );
return CreateQuad( corner3, corner2, corner1, corner0, color );
}
void CBC_DefaultPlacement::place() {
int32_t pos = 0;
int32_t row = 4;
int32_t col = 0;
do {
if ((row == m_numrows) && (col == 0)) {
corner1(pos++);
}
if ((row == m_numrows - 2) && (col == 0) && ((m_numcols % 4) != 0)) {
corner2(pos++);
}
if ((row == m_numrows - 2) && (col == 0) && (m_numcols % 8 == 4)) {
corner3(pos++);
}
if ((row == m_numrows + 4) && (col == 2) && ((m_numcols % 8) == 0)) {
corner4(pos++);
}
do {
if ((row < m_numrows) && (col >= 0) && !hasBit(col, row)) {
utah(row, col, pos++);
}
row -= 2;
col += 2;
} while (row >= 0 && (col < m_numcols));
row++;
col += 3;
do {
if ((row >= 0) && (col < m_numcols) && !hasBit(col, row)) {
utah(row, col, pos++);
}
row += 2;
col -= 2;
} while ((row < m_numrows) && (col >= 0));
row += 3;
col++;
} while ((row < m_numrows) || (col < m_numcols));
if (!hasBit(m_numcols - 1, m_numrows - 1)) {
setBit(m_numcols - 1, m_numrows - 1, true);
setBit(m_numcols - 2, m_numrows - 2, true);
}
}
//-------------------------------------------------------------------------------//
void ChunkTerrainSection::_calcLod(Camera* cam)
{
// compute a 2d point for each corner of the section
Vector2 corner0(mSectionBound.getMinimum().x, mSectionBound.getMinimum().z);
Vector2 corner1(mSectionBound.getMinimum().x, mSectionBound.getMaximum().z);
Vector2 corner2(mSectionBound.getMaximum().x, mSectionBound.getMaximum().z);
Vector2 corner3(mSectionBound.getMaximum().x, mSectionBound.getMinimum().z);
Vector2 viewPoint= Vector2(cam->getPosition().x, cam->getPosition().z);
// compute view distance to our 4 corners
float distance0 = viewPoint.distance(corner0);
float distance1 = viewPoint.distance(corner1);
float distance2 = viewPoint.distance(corner2);
float distance3 = viewPoint.distance(corner3);
_recursiveTessellate(distance0, distance1, distance2, distance3,
0, 0, 0,
mCreator->getLodErrorScale(), mCreator->getRatioLimit());
}
void CModelDecal::CalcVertexExtents(ssize_t& i0, ssize_t& j0, ssize_t& i1, ssize_t& j1)
{
CVector3D corner0(m_Decal.m_OffsetX + m_Decal.m_SizeX/2, 0, m_Decal.m_OffsetZ + m_Decal.m_SizeZ/2);
CVector3D corner1(m_Decal.m_OffsetX + m_Decal.m_SizeX/2, 0, m_Decal.m_OffsetZ - m_Decal.m_SizeZ/2);
CVector3D corner2(m_Decal.m_OffsetX - m_Decal.m_SizeX/2, 0, m_Decal.m_OffsetZ - m_Decal.m_SizeZ/2);
CVector3D corner3(m_Decal.m_OffsetX - m_Decal.m_SizeX/2, 0, m_Decal.m_OffsetZ + m_Decal.m_SizeZ/2);
corner0 = GetTransform().Transform(corner0);
corner1 = GetTransform().Transform(corner1);
corner2 = GetTransform().Transform(corner2);
corner3 = GetTransform().Transform(corner3);
i0 = floor(std::min(std::min(corner0.X, corner1.X), std::min(corner2.X, corner3.X)) / TERRAIN_TILE_SIZE);
j0 = floor(std::min(std::min(corner0.Z, corner1.Z), std::min(corner2.Z, corner3.Z)) / TERRAIN_TILE_SIZE);
i1 = ceil(std::max(std::max(corner0.X, corner1.X), std::max(corner2.X, corner3.X)) / TERRAIN_TILE_SIZE);
j1 = ceil(std::max(std::max(corner0.Z, corner1.Z), std::max(corner2.Z, corner3.Z)) / TERRAIN_TILE_SIZE);
i0 = clamp(i0, (ssize_t)0, m_Terrain->GetVerticesPerSide()-1);
j0 = clamp(j0, (ssize_t)0, m_Terrain->GetVerticesPerSide()-1);
i1 = clamp(i1, (ssize_t)0, m_Terrain->GetVerticesPerSide()-1);
j1 = clamp(j1, (ssize_t)0, m_Terrain->GetVerticesPerSide()-1);
}
