//----------------------------------------------------------------// void MOAIPartitionLevel::GatherProps ( MOAIPartitionResultBuffer& results, MOAIProp* ignore, const USVec3D& point, u32 planeID, u32 mask ) { USVec2D cellPoint ( 0.0f, 0.0f ); switch ( planeID ) { case USBox::PLANE_XY: cellPoint.Init ( point.mX, point.mY ); break; case USBox::PLANE_XZ: cellPoint.Init ( point.mX, point.mZ ); break; case USBox::PLANE_YZ: cellPoint.Init ( point.mY, point.mZ ); break; }; float halfSize = this->mCellSize * 0.5f; cellPoint.mX = cellPoint.mX - halfSize; cellPoint.mY = cellPoint.mY + halfSize; MOAICellCoord coord = this->mGridSpace.GetCellCoord ( cellPoint.mX, cellPoint.mY ); int width = this->mGridSpace.GetWidth (); int height = this->mGridSpace.GetHeight (); int xTotal = ( width < 2 ) ? 1 : 2; int yTotal = ( height < 2 ) ? 1 : 2; for ( int y = 0; y < yTotal; ++y ) { for ( int x = 0; x < xTotal; ++x ) { MOAICellCoord offset = this->mGridSpace.WrapCellCoord ( coord.mX + x, coord.mY - y ); int addr = this->mGridSpace.GetCellAddr ( offset ); this->mCells [ addr ].GatherProps ( results, ignore, point, mask ); } } }
//----------------------------------------------------------------// 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 ); } }
//----------------------------------------------------------------// void MOAITextDesigner::BuildLayout ( MOAITextBox& textBox ) { if ( !textBox.mStyleMap.GetTop ()) return; this->mStr = textBox.mText; this->mIdx = textBox.mCurrentPageIdx; this->mStyleSpan = 0; this->mStyle = 0; int tokenIdx = this->mIdx; int lineIdx = this->mIdx; float width = textBox.mFrame.Width (); float height = textBox.mFrame.Height (); u32 lineStart = 0; u32 lineSize = 0; u32 tokenStart = 0; u32 tokenSize = 0; USRect lineRect; lineRect.Init ( 0.0f, 0.0f, 0.0f, 0.0f ); USRect tokenRect; tokenRect.Init ( 0.0f, 0.0f, 0.0f, 0.0f ); float tokenAscent = 0.0f; float lineAscent = 0.0f; USVec2D pen; pen.Init ( 0.0f, 0.0f ); MOAIGlyph* glyph = 0; MOAIGlyph* prevGlyph = 0; textBox.mMore = true; bool more = true; while ( more ) { u32 c = this->NextChar ( textBox ); float scale = textBox.mGlyphScale * ( this->mStyle ? this->mStyle->mScale : 1.0f ); bool acceptToken = false; bool acceptLine = false; if ( MOAIFont::IsControl ( c )) { if ( c == '\n' ) { tokenIdx = this->mIdx - 1; tokenStart = textBox.mSprites.GetTop (); acceptToken = true; acceptLine = true; if ( !tokenRect.Height ()) { tokenRect.mYMax += this->mDeck->mHeight * scale; } } else if ( c == 0 ) { textBox.mMore = false; tokenIdx = this->mIdx - 1; tokenStart = textBox.mSprites.GetTop (); acceptToken = true; acceptLine = true; more = false; } } else { glyph = this->mDeck->GetGlyph ( c ); if ( !glyph ) continue; if ( glyph->mAdvanceX == 0.0f ) continue; // apply kerning if ( prevGlyph ) { MOAIKernVec kernVec = prevGlyph->GetKerning ( glyph->mCode ); pen.mX += kernVec.mX * scale; } prevGlyph = glyph; if ( MOAIFont::IsWhitespace ( c )) { if ( tokenSize ) { acceptToken = true; } } else { float glyphBottom = pen.mY + ( this->mDeck->mHeight * scale ); // handle new token if ( !tokenSize ) { tokenIdx = this->mIdx - 1; tokenStart = textBox.mSprites.GetTop (); tokenRect.Init ( pen.mX, pen.mY, pen.mX, glyphBottom ); tokenAscent = this->mDeck->mAscent * scale; } // check for overrun float glyphRight = pen.mX + (( glyph->mBearingX + glyph->mWidth ) * scale ); bool overrun = glyphRight > width; acceptLine = ( lineSize && overrun ); if ( acceptLine || !overrun ) { textBox.PushSprite ( this->mIdx - 1, *glyph, *this->mStyle, pen.mX, pen.mY, scale ); tokenRect.mXMax = glyphRight; tokenSize++; } } pen.mX += glyph->mAdvanceX * scale; } if ( acceptToken ) { lineRect.Grow ( tokenRect ); lineSize += tokenSize; lineAscent = tokenAscent > lineAscent ? tokenAscent : lineAscent; tokenSize = 0; } if ( acceptLine ) { textBox.PushLine ( lineStart, lineSize, lineRect, lineAscent ); // end line pen.mY += lineRect.Height () + textBox.mLineSpacing; lineRect.Init ( 0.0f, pen.mY, 0.0f, pen.mY ); // next line lineIdx = tokenIdx; lineStart = tokenStart; lineSize = 0; lineAscent = 0.0f; prevGlyph = 0; if ( tokenSize ){ // slide the current token (if any) back to the origin for ( u32 i = 0; i < tokenSize; ++i ) { MOAITextSprite& sprite = textBox.mSprites [ tokenStart + i ]; sprite.mX -= tokenRect.mXMin; sprite.mY = pen.mY; } pen.mX -= tokenRect.mXMin; tokenRect.Init ( 0.0f, pen.mY, tokenRect.Width (), pen.mY + tokenRect.Height ()); } else { pen.mX = 0.0f; tokenRect.Init ( 0.0f, pen.mY, 0.0f, pen.mY + this->mDeck->mHeight ); } } // if we overrun height, then back up to the start of the current line if ( tokenRect.mYMax > height ) { textBox.mSprites.SetTop ( lineStart ); textBox.mNextPageIdx = lineIdx; more = false; } } if ( textBox.mSprites.GetTop () == 0 ) { textBox.mMore = false; return; } float yOff = textBox.mFrame.mYMin; float layoutHeight = lineRect.mYMax; switch ( textBox.mVAlign ) { case MOAITextBox::CENTER_JUSTIFY: yOff = ( yOff + ( height * 0.5f )) - ( layoutHeight * 0.5f ); case MOAITextBox::LEFT_JUSTIFY: break; case MOAITextBox::RIGHT_JUSTIFY: yOff = textBox.mFrame.mYMax - layoutHeight; } u32 totalLines = textBox.mLines.GetTop (); for ( u32 i = 0; i < totalLines; ++i ) { MOAITextLine& line = textBox.mLines [ i ]; float xOff = textBox.mFrame.mXMin; float lineWidth = line.mRect.Width (); switch ( textBox.mHAlign ) { case MOAITextBox::CENTER_JUSTIFY: xOff = ( xOff + ( width * 0.5f )) - ( lineWidth * 0.5f ); case MOAITextBox::LEFT_JUSTIFY: break; case MOAITextBox::RIGHT_JUSTIFY: xOff = textBox.mFrame.mXMax - lineWidth; } line.mRect.Offset ( xOff, yOff ); float spriteYOff = yOff + line.mAscent; MOAIAnimCurve* curve = 0; if ( textBox.mCurves ) { curve = textBox.mCurves [ i % textBox.mCurves.Size ()]; } for ( u32 j = 0; j < line.mSize; ++j ) { MOAITextSprite& sprite = textBox.mSprites [ line.mStart + j ]; sprite.mX += xOff; if ( curve ) { sprite.mY += spriteYOff + curve->GetFloatValue (( sprite.mX - textBox.mFrame.mXMin ) / width ); } else { sprite.mY += spriteYOff; } } } }