//----------------------------------------------------------------//
USRect MOAIDeck::GetBounds ( u32 idx, MOAIDeckRemapper* remapper ) {
UNUSED ( idx );
UNUSED ( remapper );
USRect rect;
rect.Init ( 0.0f, 0.0f, 0.0f, 0.0f );
return rect;
}
//----------------------------------------------------------------//
USRect MOAIQuadBrush::GetVtxBounds () {
USRect rect;
rect.Init ( this->mVtx [ 0 ]);
rect.Grow ( this->mVtx [ 1 ]);
rect.Grow ( this->mVtx [ 2 ]);
rect.Grow ( this->mVtx [ 3 ]);
return rect;
}
//----------------------------------------------------------------//
USRect USGLQuad::GetVtxBounds () {
USRect rect;
rect.Init ( this->mVtx [ 0 ]);
rect.Grow ( this->mVtx [ 1 ]);
rect.Grow ( this->mVtx [ 2 ]);
rect.Grow ( this->mVtx [ 3 ]);
return rect;
}
//----------------------------------------------------------------//
USRect USGLQuad::GetUVBounds () {
USRect rect;
rect.Init ( this->mUV [ 0 ]);
rect.Grow ( this->mUV [ 1 ]);
rect.Grow ( this->mUV [ 2 ]);
rect.Grow ( this->mUV [ 3 ]);
return rect;
}
//----------------------------------------------------------------//
USRect MOAIMesh::GetBounds ( u32 idx, MOAIDeckRemapper* remapper ) {
UNUSED ( idx );
UNUSED ( remapper );
if ( this->mVertexBuffer ) {
return this->mVertexBuffer->GetBounds ();
}
USRect bounds;
bounds.Init ( 0.0f, 0.0f, 0.0f, 0.0f );
return bounds;
}
//----------------------------------------------------------------//
USRect MOAIQuadBrush::GetUVBounds () {
USRect rect;
rect.Init ( this->mUV [ 0 ]);
rect.Grow ( this->mUV [ 1 ]);
rect.Grow ( this->mUV [ 2 ]);
rect.Grow ( this->mUV [ 3 ]);
return rect;
}
//----------------------------------------------------------------//
void MOAITileDeck2D::DrawPatch ( u32 idx, float xOff, float yOff, float xScale, float yScale ) {
idx = idx - 1;
USCellCoord coord = this->GetCellCoord ( idx );
USRect uvRect = this->GetTileRect ( coord );
uvRect.FlipY ();
USGLQuad quad;
quad.SetVerts ( this->mRect );
quad.SetUVs ( uvRect );
quad.Draw ( xOff, yOff, xScale, yScale );
}
//----------------------------------------------------------------//
USRect MOAISurfaceDeck2D::GetRect ( u32 idx, MOAIDeckRemapper* remapper ) {
idx = remapper ? remapper->Remap ( idx ) : idx;
idx = idx - 1;
if ( idx < this->mBrushes.Size ()) {
return this->mBrushes [ idx ].mBounds;
}
USRect rect;
rect.Init ( 0.0f, 0.0f, 0.0f, 0.0f );
return rect;
}
USRect MOAISurfaceDeck2D::GetRect () {
u32 size = this->mBrushes.Size ();
USRect totalRect;
totalRect.Init ( 0.0f, 0.0f, 0.0f, 0.0f );
for ( int i = 0; i < size; ++i ) {
totalRect.Grow ( this->mBrushes [ i ].mBounds );
}
return totalRect;
}
//----------------------------------------------------------------//
void MOAIGfxDevice::SetScissorRect ( const USRect& rect ) {
USRect& current = this->mScissorRect;
if ( ( current.mXMin != rect.mXMin ) ||
( current.mYMin != rect.mYMin ) ||
( current.mXMax != rect.mXMax ) ||
( current.mYMax != rect.mYMax )) {
this->Flush ();
glScissor (( int )rect.mXMin, ( int )rect.mYMin, ( int )rect.Width (), ( int )rect.Height ());
this->mScissorRect = rect;
}
}
//----------------------------------------------------------------//
USBox MOAIGfxQuadDeck2D::ComputeMaxBounds () {
USRect rect;
rect.Init ( 0.0f, 0.0f, 0.0f, 0.0f );
u32 size = this->mQuads.Size ();
for ( u32 i = 0; i < size; ++i ) {
rect.Grow ( this->mQuads [ i ].GetVtxBounds ());
}
USBox bounds;
bounds.Init ( rect.mXMin, rect.mYMax, rect.mXMax, rect.mYMin, 0.0f, 0.0f );
return bounds;
}
USRect MOAIGfxQuadDeck2D::GetRect ( ) {
u32 size = this->mQuads.Size ();
USRect totalRect;
totalRect.Init ( 0.0f, 0.0f, 0.0f, 0.0f );
for ( u32 i = 0; i < size; ++i ) {
MOAIQuadBrush& quad = this->mQuads [ i ];
USRect rect = quad.GetVtxBounds ();
totalRect.Grow ( rect );
}
return totalRect;
}
//----------------------------------------------------------------//
void MOAIGfxDevice::SetViewport ( const USRect& viewport ) {
// set us up the viewport
GLint x = ( GLint )viewport.mXMin;
GLint y = ( GLint )viewport.mYMin;
GLsizei w = ( GLsizei )( viewport.Width () + 0.5f );
GLsizei h = ( GLsizei )( viewport.Height () + 0.5f );
glViewport ( x, y, w, h );
this->mViewRect = viewport;
}
//----------------------------------------------------------------//
bool USFrustum::GetXYSectRect ( const USAffine3D& mtx, USRect& rect ) const {
u32 nHits = 0;
USVec2D hits [ 12 ];
USVec3D nlt = this->mPoints [ NEAR_LT_POINT ];
USVec3D nrt = this->mPoints [ NEAR_RT_POINT ];
USVec3D nrb = this->mPoints [ NEAR_RB_POINT ];
USVec3D nlb = this->mPoints [ NEAR_LB_POINT ];
USVec3D flt = this->mPoints [ FAR_LT_POINT ];
USVec3D frt = this->mPoints [ FAR_RT_POINT ];
USVec3D frb = this->mPoints [ FAR_RB_POINT ];
USVec3D flb = this->mPoints [ FAR_LB_POINT ];
mtx.Transform ( nlt );
mtx.Transform ( nrt );
mtx.Transform ( nrb );
mtx.Transform ( nlb );
mtx.Transform ( flt );
mtx.Transform ( frt );
mtx.Transform ( frb );
mtx.Transform ( flb );
if ( _vecToXYPlane ( nlt, flt, hits [ nHits ])) ++nHits;
if ( _vecToXYPlane ( nrt, frt, hits [ nHits ])) ++nHits;
if ( _vecToXYPlane ( nrb, frb, hits [ nHits ])) ++nHits;
if ( _vecToXYPlane ( nlb, flb, hits [ nHits ])) ++nHits;
if ( _vecToXYPlane ( nlt, nrt, hits [ nHits ])) ++nHits;
if ( _vecToXYPlane ( nrt, nrb, hits [ nHits ])) ++nHits;
if ( _vecToXYPlane ( nrb, nlb, hits [ nHits ])) ++nHits;
if ( _vecToXYPlane ( nlb, nlt, hits [ nHits ])) ++nHits;
if ( _vecToXYPlane ( flt, frt, hits [ nHits ])) ++nHits;
if ( _vecToXYPlane ( frt, frb, hits [ nHits ])) ++nHits;
if ( _vecToXYPlane ( frb, flb, hits [ nHits ])) ++nHits;
if ( _vecToXYPlane ( flb, flt, hits [ nHits ])) ++nHits;
if ( nHits ) {
rect.Init ( hits [ 0 ]);
for ( u32 i = 1; i < nHits; ++i ) {
rect.Grow ( hits [ i ]);
}
return true;
}
return false;
}
//----------------------------------------------------------------//
void MOAIGfxDevice::SetViewRect ( USRect rect ) {
USRect deviceRect = rect;
deviceRect = this->mFrameBuffer->WndRectToDevice ( rect );
GLint x = ( GLint )deviceRect.mXMin;
GLint y = ( GLint )deviceRect.mYMin;
GLsizei w = ( GLsizei )( deviceRect.Width () + 0.5f );
GLsizei h = ( GLsizei )( deviceRect.Height () + 0.5f );
glViewport ( x, y, w, h );
this->mViewRect = rect;
}
//----------------------------------------------------------------//
USRect MOAIGfxQuadDeck2D::GetBounds ( u32 idx, MOAIDeckRemapper* remapper ) {
u32 size = this->mQuads.Size ();
if ( size ) {
idx = remapper ? remapper->Remap ( idx ) : idx;
idx = ( idx - 1 ) % size;
MOAIQuadBrush& quad = this->mQuads [ idx ];
return quad.GetVtxBounds ();
}
USRect rect;
rect.Init ( 0.0f, 0.0f, 0.0f, 0.0f );
return rect;
}
//----------------------------------------------------------------//
USBox MOAISurfaceDeck2D::ComputeMaxBounds () {
u32 size = this->mBrushes.Size ();
USRect rect;
rect.Init ( 0.0f, 0.0f, 0.0f, 0.0f );
for ( u32 i = 0; i < size; ++i ) {
rect.Grow ( this->mBrushes [ i ].mBounds );
}
USBox bounds;
bounds.Init ( rect.mXMin, rect.mYMax, rect.mXMax, rect.mYMin, 0.0f, 0.0f );
return bounds;
}
//----------------------------------------------------------------//
USRect MOAIGlyph::GetRect ( float x, float y ) const {
USRect rect;
x += ( this->mBearingX );
y -= ( this->mBearingY );
rect.Init (
x,
y,
x + this->mWidth,
y + this->mHeight
);
return rect;
}
//----------------------------------------------------------------//
void MOAIDraw::DrawRectEdges ( USRect rect, u32 edges ) {
rect.Bless ();
MOAILineBrush glLine;
// right
if ( edges & USRect::kRight ) {
glLine.SetVerts ( rect.mXMax, rect.mYMin, rect.mXMax, rect.mYMax );
glLine.Draw ();
}
// top
if ( edges & USRect::kTop ) {
glLine.SetVerts ( rect.mXMin, rect.mYMin, rect.mXMax, rect.mYMin );
glLine.Draw ();
}
// left
if ( edges & USRect::kLeft ) {
glLine.SetVerts ( rect.mXMin, rect.mYMin, rect.mXMin, rect.mYMax );
glLine.Draw ();
}
// bottom
if ( edges & USRect::kBottom ) {
glLine.SetVerts ( rect.mXMin, rect.mYMax, rect.mXMax, rect.mYMax );
glLine.Draw ();
}
}
//----------------------------------------------------------------//
USMatrix4x4 MOAIGfxDevice::GetWndToNormMtx () const {
USRect rect = this->mViewRect;
float hWidth = rect.Width () * 0.5f;
float hHeight = rect.Height () * 0.5f;
// Inv Wnd
USMatrix4x4 wndToNorm;
wndToNorm.Translate ( -hWidth - rect.mXMin, -hHeight - rect.mYMin, 0.0f );
USMatrix4x4 mtx;
mtx.Scale (( 1.0f / hWidth ), -( 1.0f / hHeight ), 1.0f );
wndToNorm.Append ( mtx );
return wndToNorm;
}
//----------------------------------------------------------------//
USMatrix4x4 MOAIGfxDevice::GetNormToWndMtx () const {
USRect rect = this->mViewRect;
float hWidth = rect.Width () * 0.5f;
float hHeight = rect.Height () * 0.5f;
// Wnd
USMatrix4x4 normToWnd;
normToWnd.Scale ( hWidth, -hHeight, 1.0f );
USMatrix4x4 mtx;
mtx.Translate ( hWidth + rect.mXMin, hHeight + rect.mYMin, 0.0f );
normToWnd.Append ( mtx );
return normToWnd;
}
//----------------------------------------------------------------//
void MOAIGfxDevice::ResetState () {
this->mTop = 0;
this->mPrimCount = 0;
// turn off texture
glDisable ( GL_TEXTURE_2D );
this->mTexture = 0;
// turn off blending
glDisable ( GL_BLEND );
this->mBlendEnabled = false;
// clear the vertex format
this->SetVertexFormat ();
// clear the shader
this->mShader = 0;
// disable backface culling
glDisable ( GL_CULL_FACE );
// reset the pen width
this->mPenWidth = 1.0f;
glLineWidth (( GLfloat )this->mPenWidth );
// reset the point size
this->mPointSize = 1.0f;
// reset the scissor rect
MOAIGfxDevice& device = MOAIGfxDevice::Get ();
USRect scissorRect = device.GetRect ();
glScissor (( int )scissorRect.mXMin, ( int )scissorRect.mYMin, ( int )scissorRect.Width (), ( int )scissorRect.Height ());
this->mScissorRect = scissorRect;
// fixed function reset
if ( !this->IsProgrammable ()) {
// reset the current vertex color
glColor4f ( 1.0f, 1.0f, 1.0f, 1.0f );
// reset the point size
glPointSize (( GLfloat )this->mPointSize );
}
}
//----------------------------------------------------------------//
void MOAIGfxDevice::SetViewport ( const USRect& viewport ) {
// set us up the viewport
GLint x = ( GLint )viewport.mXMin;
GLint y = ( GLint )viewport.mYMin;
GLsizei w = ( GLsizei )( viewport.Width () + 0.5f );
GLsizei h = ( GLsizei )( viewport.Height () + 0.5f );
glViewport (
( GLint )( x * this->mDeviceScale ),
( GLint )( y * this->mDeviceScale ),
( GLsizei )( w * this->mDeviceScale ),
( GLsizei )( h * this->mDeviceScale )
);
this->mViewRect = viewport;
}
//----------------------------------------------------------------//
USMatrix4x4 MOAIGfxDevice::GetWorldToWndMtx ( float xScale, float yScale ) const {
USMatrix4x4 worldToWnd;
USMatrix4x4 mtx;
USRect rect = this->GetViewRect ();
float hWidth = rect.Width () * 0.5f;
float hHeight = rect.Height () * 0.5f;
// viewproj
worldToWnd = this->GetViewProjMtx ();
// wnd
mtx.Scale ( hWidth * xScale, hHeight * yScale, 1.0f );
worldToWnd.Append ( mtx );
mtx.Translate ( hWidth + rect.mXMin, hHeight + rect.mYMin, 0.0f );
worldToWnd.Append ( mtx );
return worldToWnd;
}
//----------------------------------------------------------------//
USMatrix4x4 MOAIGfxDevice::GetWndToWorldMtx () const {
USMatrix4x4 wndToWorld;
USMatrix4x4 mtx;
USRect rect = this->GetViewRect ();
float hWidth = rect.Width () * 0.5f;
float hHeight = rect.Height () * 0.5f;
// Inv Wnd
wndToWorld.Translate ( -hWidth - rect.mXMin, -hHeight - rect.mYMin, 0.0f );
mtx.Scale (( 1.0f / hWidth ), -( 1.0f / hHeight ), 1.0f );
wndToWorld.Append ( mtx );
// inv viewproj
mtx = this->GetViewProjMtx ();
mtx.Inverse ();
wndToWorld.Append ( mtx );
return wndToWorld;
}
//----------------------------------------------------------------//
void MOAIDraw::DrawRay ( float x, float y, float dx, float dy ) {
USVec2D loc ( x, y );
USVec2D vec ( dx, dy );
USMatrix4x4 mtx = MOAIGfxDevice::Get ().GetViewProjMtx ();
USMatrix4x4 invMtx;
invMtx.Inverse ( mtx );
mtx.Transform ( loc );
mtx.TransformVec ( vec );
USRect viewRect;
viewRect.Init ( -1.0f, -1.0f, 1.0f, 1.0f );
USVec2D p0;
USVec2D p1;
if ( viewRect.GetIntersection ( loc, vec, p0, p1 )) {
invMtx.Transform ( p0 );
invMtx.Transform ( p1 );
MOAIGfxDevice& gfxDevice = MOAIGfxDevice::Get ();
gfxDevice.BeginPrim ( GL_LINES );
gfxDevice.WriteVtx ( p0.mX, p0.mY, 0.0f );
gfxDevice.WriteFinalColor4b ();
gfxDevice.WriteVtx ( p1.mX, p1.mY, 0.0f );
gfxDevice.WriteFinalColor4b ();
gfxDevice.EndPrim ();
}
}
//----------------------------------------------------------------//
USRect MOAIScissorRect::GetScissorRect ( const USMatrix4x4& worldToWndMtx ) const {
USVec3D vtx3D [ 4 ];
vtx3D [ 0 ].mX = this->mRect.mXMin;
vtx3D [ 0 ].mY = this->mRect.mYMin;
vtx3D [ 0 ].mZ = 0.0f;
vtx3D [ 1 ].mX = this->mRect.mXMin;
vtx3D [ 1 ].mY = this->mRect.mYMax;
vtx3D [ 1 ].mZ = 0.0f;
vtx3D [ 2 ].mX = this->mRect.mXMax;
vtx3D [ 2 ].mY = this->mRect.mYMax;
vtx3D [ 2 ].mZ = 0.0f;
vtx3D [ 3 ].mX = this->mRect.mXMax;
vtx3D [ 3 ].mY = this->mRect.mYMin;
vtx3D [ 3 ].mZ = 0.0f;
USMatrix4x4 mtx;
mtx.Init ( this->GetLocalToWorldMtx ());
mtx.Append ( worldToWndMtx );
mtx.Project ( vtx3D [ 0 ]);
mtx.Project ( vtx3D [ 1 ]);
mtx.Project ( vtx3D [ 2 ]);
mtx.Project ( vtx3D [ 3 ]);
USRect scissorRect;
scissorRect.Init ( vtx3D [ 0 ]);
scissorRect.Grow ( vtx3D [ 1 ]);
scissorRect.Grow ( vtx3D [ 2 ]);
scissorRect.Grow ( vtx3D [ 3 ]);
if ( this->mScissorRect ) {
USRect parentRect = this->mScissorRect->GetScissorRect ( worldToWndMtx );
parentRect.Clip ( scissorRect );
}
return scissorRect;
}
//----------------------------------------------------------------//
void MOAIDraw::DrawRectEdges ( USRect rect, u32 edges ) {
rect.Bless ();
// right
if ( edges & USRect::kRight ) {
MOAIDraw::DrawLine ( rect.mXMax, rect.mYMin, rect.mXMax, rect.mYMax );
}
// top
if ( edges & USRect::kTop ) {
MOAIDraw::DrawLine ( rect.mXMin, rect.mYMin, rect.mXMax, rect.mYMin );
}
// left
if ( edges & USRect::kLeft ) {
MOAIDraw::DrawLine ( rect.mXMin, rect.mYMin, rect.mXMin, rect.mYMax );
}
// bottom
if ( edges & USRect::kBottom ) {
MOAIDraw::DrawLine ( rect.mXMin, rect.mYMax, rect.mXMax, rect.mYMax );
}
}
//----------------------------------------------------------------//
void MOAIDraw::DrawRectFill ( USRect rect ) {
rect.Bless ();
MOAIDraw::DrawRectFill ( rect.mXMin, rect.mYMin, rect.mXMax, rect.mYMax );
}
//----------------------------------------------------------------//
void MOAIDraw::DrawAxisGrid ( USVec2D loc, USVec2D vec, float size ) {
USMatrix4x4 mtx = MOAIGfxDevice::Get ().GetViewProjMtx ();
USMatrix4x4 invMtx;
invMtx.Inverse ( mtx );
// Set the axis to the grid length so we can get the length back post-transform
vec.SetLength ( size );
mtx.Transform ( loc );
mtx.TransformVec ( vec );
// Get the axis unit vector
USVec2D norm = vec;
size = norm.NormSafe ();
// Get the axis normal
USVec2D perpNorm ( norm.mY, -norm.mX );
// Project the corners of the viewport onto the axis to get the mix/max bounds
float dot;
float min;
float max;
USVec2D corner;
// left, top
corner.Init ( -1.0f, 1.0f );
corner.Sub ( loc );
dot = norm.Dot ( corner );
min = dot;
max = dot;
// right, top
corner.Init ( 1.0f, 1.0f );
corner.Sub ( loc );
dot = norm.Dot ( corner );
min = ( dot < min ) ? dot : min;
max = ( dot > max ) ? dot : max;
// right, bottom
corner.Init ( 1.0f, -1.0f );
corner.Sub ( loc );
dot = norm.Dot ( corner );
min = ( dot < min ) ? dot : min;
max = ( dot > max ) ? dot : max;
// left, bottom
corner.Init ( -1.0f, -1.0f );
corner.Sub ( loc );
dot = norm.Dot ( corner );
min = ( dot < min ) ? dot : min;
max = ( dot > max ) ? dot : max;
// Get the start andstop grids
s32 start = ( s32 )( min / size ) - 1;
s32 stop = ( s32 )( max / size ) + 1;
// Set the pen to the first...
USVec2D pen = norm;
pen.Scale (( float )start * size );
pen.Add ( loc );
// Step along the axis to draw perpendicular grid lines
USRect viewRect;
viewRect.Init ( -1.0f, -1.0f, 1.0f, 1.0f );
for ( ; start < stop; ++start ) {
USVec2D p0;
USVec2D p1;
if ( viewRect.GetIntersection ( pen, perpNorm, p0, p1 )) {
invMtx.Transform ( p0 );
invMtx.Transform ( p1 );
MOAIDraw::DrawLine ( p0, p1 );
}
pen.Add ( vec );
}
}