Torque3D/Engine/source/gfx/gfxDrawUtil.cpp

//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------

#include "platform/platform.h"
#include "gfx/gfxDrawUtil.h"

#include "core/frameAllocator.h"
#include "core/strings/stringFunctions.h"
#include "core/strings/unicode.h"
#include "math/util/frustum.h"
#include "math/util/sphereMesh.h"
#include "math/mathUtils.h"
#include "gfx/gfxFontRenderBatcher.h"
#include "gfx/gfxTransformSaver.h"
#include "gfx/gfxPrimitiveBuffer.h"
#include "gfx/primBuilder.h"
#include "gfx/gfxDebugEvent.h"

#include "math/mPolyhedron.impl.h"


GFXDrawUtil::GFXDrawUtil( GFXDevice * d)
{
   mDevice = d;
   mBitmapModulation.set(0xFF, 0xFF, 0xFF, 0xFF);
   mTextAnchorColor.set(0xFF, 0xFF, 0xFF, 0xFF);
   mFontRenderBatcher = new FontRenderBatcher();

   _setupStateBlocks();   
}

GFXDrawUtil::~GFXDrawUtil()
{
   delete mFontRenderBatcher;
}

void GFXDrawUtil::_setupStateBlocks()
{
   // DrawBitmapStretchSR
   GFXStateBlockDesc bitmapStretchSR;
   bitmapStretchSR.setCullMode(GFXCullNone);
   bitmapStretchSR.setZReadWrite(false);
   bitmapStretchSR.setBlend(true, GFXBlendSrcAlpha, GFXBlendInvSrcAlpha);
   bitmapStretchSR.samplersDefined = true;

   // Linear: Create wrap SB
   bitmapStretchSR.samplers[0] = GFXSamplerStateDesc::getWrapLinear();
   mBitmapStretchWrapLinearSB = mDevice->createStateBlock(bitmapStretchSR);

   // Linear: Create clamp SB
   bitmapStretchSR.samplers[0] = GFXSamplerStateDesc::getClampLinear();
   mBitmapStretchLinearSB = mDevice->createStateBlock(bitmapStretchSR);

   // Point:
   bitmapStretchSR.samplers[0].minFilter = GFXTextureFilterPoint;
   bitmapStretchSR.samplers[0].mipFilter = GFXTextureFilterPoint;
   bitmapStretchSR.samplers[0].magFilter = GFXTextureFilterPoint;

   // Point: Create clamp SB, last created clamped so no work required here
   mBitmapStretchSB = mDevice->createStateBlock(bitmapStretchSR);

   // Point: Create wrap SB, have to do this manually because getWrapLinear doesn't
   bitmapStretchSR.samplers[0].addressModeU = GFXAddressWrap;
   bitmapStretchSR.samplers[0].addressModeV = GFXAddressWrap;
   bitmapStretchSR.samplers[0].addressModeW = GFXAddressWrap;
   mBitmapStretchWrapSB = mDevice->createStateBlock(bitmapStretchSR);

   GFXStateBlockDesc rectFill;
   rectFill.setCullMode(GFXCullNone);
   rectFill.setZReadWrite(false);
   rectFill.setBlend(true, GFXBlendSrcAlpha, GFXBlendInvSrcAlpha);
   mRectFillSB = mDevice->createStateBlock(rectFill);
}

//-----------------------------------------------------------------------------
// Color Modulation
//-----------------------------------------------------------------------------
void GFXDrawUtil::setBitmapModulation( const ColorI &modColor )
{
   mBitmapModulation = modColor;
}

void GFXDrawUtil::clearBitmapModulation()
{
   mBitmapModulation.set( 255, 255, 255, 255 );
}

void GFXDrawUtil::getBitmapModulation( ColorI *color )
{
   mBitmapModulation.getColor( color );
}

void GFXDrawUtil::setTextAnchorColor( const ColorI &ancColor )
{
   mTextAnchorColor = ancColor;
}

//-----------------------------------------------------------------------------
// Draw Text
//-----------------------------------------------------------------------------
U32 GFXDrawUtil::drawText( GFont *font, const Point2I &ptDraw, const UTF16 *in_string, 
                          const ColorI *colorTable, const U32 maxColorIndex, F32 rot )
{
   return drawTextN( font, ptDraw, in_string, dStrlen(in_string), colorTable, maxColorIndex, rot );
}

U32 GFXDrawUtil::drawText( GFont *font, const Point2I &ptDraw, const UTF8 *in_string, 
                          const ColorI *colorTable, const U32 maxColorIndex, F32 rot )
{
   return drawTextN( font, ptDraw, in_string, dStrlen(in_string), colorTable, maxColorIndex, rot );
}

U32 GFXDrawUtil::drawText( GFont *font, const Point2F &ptDraw, const UTF8 *in_string, const ColorI *colorTable /*= NULL*/, const U32 maxColorIndex /*= 9*/, F32 rot /*= 0.f */ )
{
   return drawText(font,Point2I((S32)ptDraw.x,(S32)ptDraw.y),in_string,colorTable,maxColorIndex,rot);
}

U32 GFXDrawUtil::drawText( GFont *font, const Point2F &ptDraw, const UTF16 *in_string, const ColorI *colorTable /*= NULL*/, const U32 maxColorIndex /*= 9*/, F32 rot /*= 0.f */ )
{
   return drawText(font,Point2I((S32)ptDraw.x,(S32)ptDraw.y),in_string,colorTable,maxColorIndex,rot);
}

U32 GFXDrawUtil::drawTextN( GFont *font, const Point2I &ptDraw, const UTF8 *in_string, U32 n,
                           const ColorI *colorTable, const U32 maxColorIndex, F32 rot )
{
   // return on zero length strings
   if( n == 0 )
      return ptDraw.x;

   // Convert to UTF16 temporarily.
   n++; // space for null terminator
   FrameTemp<UTF16> ubuf( n );
   convertUTF8toUTF16N(in_string, ubuf, n);

   return drawTextN( font, ptDraw, ubuf, n, colorTable, maxColorIndex, rot );
}

U32 GFXDrawUtil::drawTextN( GFont *font, const Point2I &ptDraw, const UTF16 *in_string, 
                           U32 n, const ColorI *colorTable, const U32 maxColorIndex, F32 rot )
{
   // return on zero length strings
   if( n == 0 )
      return ptDraw.x;

   // If it's over about 4000 verts we want to break it up
   if( n > 666 )
   {
      U32 left = drawTextN(font, ptDraw, in_string, 666, colorTable, maxColorIndex, rot);

      Point2I newDrawPt(left, ptDraw.y);
      const UTF16* str = (const UTF16*)in_string;

      return drawTextN(font, newDrawPt, &(str[666]), n - 666, colorTable, maxColorIndex, rot);
   }

   PROFILE_START(GFXDevice_drawTextN);

   const PlatformFont::CharInfo *tabci = NULL;

   S32 ptX = 0;

   // Queue everything for render.   
   mFontRenderBatcher->init(font, n);

   U32 i;
   UTF16 c;   
   for (i = 0, c = in_string[i]; i < n && in_string[i]; i++, c = in_string[i])
   {
      switch(c)
      {
         // We have to do a little dance here since \t = 0x9, \n = 0xa, and \r = 0xd
      case 1: case 2: case 3: case 4: case 5: case 6: case 7:
      case 11: case 12:
      case 14:
         {
            // Color code
            if (colorTable) 
            {
               static U8 remap[15] = 
               { 
                  0x0, // 0 special null terminator
                  0x0, // 1 ascii start-of-heading??
                  0x1, 
                  0x2, 
                  0x3, 
                  0x4, 
                  0x5, 
                  0x6, 
                  0x0, // 8 special backspace
                  0x0, // 9 special tab
                  0x0, // a special \n
                  0x7, 
                  0x8,
                  0x0, // a special \r
                  0x9 
               };

               U8 remapped = remap[c];

               // Ignore if the color is greater than the specified max index:
               if ( remapped <= maxColorIndex )
               {
                  const ColorI &clr = colorTable[remapped];
                  mBitmapModulation = clr;
               }
            }

            // And skip rendering this character.
            continue;
         }

         // reset color?
      case 15:
         {
            mBitmapModulation = mTextAnchorColor;

            // And skip rendering this character.
            continue;
         }

         // push color:
      case 16:
         {
            mTextAnchorColor = mBitmapModulation;

            // And skip rendering this character.
            continue;
         }

         // pop color:
      case 17:
         {
            mBitmapModulation = mTextAnchorColor;

            // And skip rendering this character.
            continue;
         }

         // Tab character
      case dT('\t'): 
         {
            if ( tabci == NULL )
               tabci = &(font->getCharInfo( dT(' ') ));

            const U32	fontTabIncrement = tabci->xIncrement * GFont::TabWidthInSpaces;

            ptX += fontTabIncrement;

            // And skip rendering this character.
            continue;
         }

         // Don't draw invalid characters.
      default:
         {
            if( !font->isValidChar( c ) ) 
               continue;
         }
      }

      // Queue char for rendering..
      mFontRenderBatcher->queueChar(c, ptX, mBitmapModulation);
   }


   mFontRenderBatcher->render(rot, Point2F((F32)ptDraw.x, (F32)ptDraw.y));

   PROFILE_END();

   return ptX + ptDraw.x;
}

U32 GFXDrawUtil::drawTextN( GFont *font, const Point2F &ptDraw, const UTF8 *in_string, U32 n, const ColorI *colorTable /*= NULL*/, const U32 maxColorIndex /*= 9*/, F32 rot /*= 0.f */ )
{
   return drawTextN(font,Point2I((S32)ptDraw.x,(S32)ptDraw.y),in_string,n,colorTable,maxColorIndex,rot);
}

U32 GFXDrawUtil::drawTextN( GFont *font, const Point2F &ptDraw, const UTF16 *in_string, U32 n, const ColorI *colorTable /*= NULL*/, const U32 maxColorIndex /*= 9*/, F32 rot /*= 0.f */ )
{
   return drawTextN(font,Point2I((S32)ptDraw.x,(S32)ptDraw.y),in_string,n,colorTable,maxColorIndex,rot);
}

//-----------------------------------------------------------------------------
// Draw Bitmaps
//-----------------------------------------------------------------------------
void GFXDrawUtil::drawBitmap( GFXTextureObject* texture, const Point2I &in_rAt, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/ )
{
   drawBitmap(texture,Point2F((F32)in_rAt.x,(F32)in_rAt.y),in_flip,filter,in_wrap);
}

void GFXDrawUtil::drawBitmapStretch( GFXTextureObject* texture, const RectI &dstRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/ )
{
   drawBitmapStretch(texture,RectF((F32)dstRect.point.x,(F32)dstRect.point.y,(F32)dstRect.extent.x,(F32)dstRect.extent.y),in_flip,filter,in_wrap);
}

void GFXDrawUtil::drawBitmapSR( GFXTextureObject* texture, const Point2I &in_rAt, const RectI &srcRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/ )
{
   drawBitmapSR(texture,Point2F((F32)in_rAt.x,(F32)in_rAt.y),RectF((F32)srcRect.point.x,(F32)srcRect.point.y,(F32)srcRect.extent.x,(F32)srcRect.extent.y),in_flip,filter,in_wrap);
}

void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject *texture, const RectI &dstRect, const RectI &srcRect, const GFXBitmapFlip in_flip, const GFXTextureFilterType filter , bool in_wrap /*= true*/ ) 
{
   RectF dstRectF = RectF((F32)dstRect.point.x,(F32)dstRect.point.y,(F32)dstRect.extent.x,(F32)dstRect.extent.y);
   RectF srcRectF = RectF((F32)srcRect.point.x,(F32)srcRect.point.y,(F32)srcRect.extent.x,(F32)srcRect.extent.y);
   drawBitmapStretchSR(texture,dstRectF,srcRectF,in_flip,filter,in_wrap);
}

void GFXDrawUtil::drawBitmap( GFXTextureObject*texture, const Point2F &in_rAt, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/ )
{
   AssertFatal( texture != 0, "No texture specified for drawBitmap()" );

   RectI subRegion( 0, 0, texture->mBitmapSize.x, texture->mBitmapSize.y );
   RectI stretch( in_rAt.x, in_rAt.y, texture->mBitmapSize.x, texture->mBitmapSize.y );
   drawBitmapStretchSR( texture, stretch, subRegion, in_flip, filter, in_wrap );
}

void GFXDrawUtil::drawBitmapStretch( GFXTextureObject*texture, const RectF &dstRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/ )
{
   AssertFatal( texture != 0, "No texture specified for drawBitmapStretch()" );

   RectF subRegion( 0.f, 0.f, (F32)texture->mBitmapSize.x, (F32)texture->mBitmapSize.y );
   drawBitmapStretchSR( texture, dstRect, subRegion, in_flip, filter, in_wrap );
}

void GFXDrawUtil::drawBitmapSR( GFXTextureObject*texture, const Point2F &in_rAt, const RectF &srcRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/ )
{
   AssertFatal( texture != 0, "No texture specified for drawBitmapSR()" );

   RectF stretch( in_rAt.x, in_rAt.y, srcRect.len_x(), srcRect.len_y() );
   drawBitmapStretchSR( texture, stretch, srcRect, in_flip, filter, in_wrap );
}

void GFXDrawUtil::drawBitmapStretchSR( GFXTextureObject* texture, const RectF &dstRect, const RectF &srcRect, const GFXBitmapFlip in_flip /*= GFXBitmapFlip_None*/, const GFXTextureFilterType filter /*= GFXTextureFilterPoint */ , bool in_wrap /*= true*/ )
{
   // Sanity if no texture is specified.
   if(!texture)
      return;   

   GFXVertexBufferHandle<GFXVertexPCT> verts(mDevice, 4, GFXBufferTypeVolatile );
   verts.lock();

   F32 texLeft   = (srcRect.point.x)                    / (texture->mTextureSize.x);
   F32 texRight  = (srcRect.point.x + srcRect.extent.x) / (texture->mTextureSize.x);
   F32 texTop    = (srcRect.point.y)                    / (texture->mTextureSize.y);
   F32 texBottom = (srcRect.point.y + srcRect.extent.y) / (texture->mTextureSize.y);

   F32 screenLeft   = dstRect.point.x;
   F32 screenRight  = (dstRect.point.x + dstRect.extent.x);
   F32 screenTop    = dstRect.point.y;
   F32 screenBottom = (dstRect.point.y + dstRect.extent.y);

   if( in_flip & GFXBitmapFlip_X ) 
   {
      F32 temp = texLeft;
      texLeft = texRight;
      texRight = temp;
   }
   if( in_flip & GFXBitmapFlip_Y ) 
   {
      F32 temp = texTop;
      texTop = texBottom;
      texBottom = temp;
   }

   const F32 fillConv = mDevice->getFillConventionOffset();
   verts[0].point.set( screenLeft  - fillConv, screenTop    - fillConv, 0.f );
   verts[1].point.set( screenRight - fillConv, screenTop    - fillConv, 0.f );
   verts[2].point.set( screenLeft  - fillConv, screenBottom - fillConv, 0.f );
   verts[3].point.set( screenRight - fillConv, screenBottom - fillConv, 0.f );

   verts[0].color = verts[1].color = verts[2].color = verts[3].color = mBitmapModulation;

   verts[0].texCoord.set( texLeft,  texTop );
   verts[1].texCoord.set( texRight, texTop );
   verts[2].texCoord.set( texLeft,  texBottom );
   verts[3].texCoord.set( texRight, texBottom );

   verts.unlock();

   mDevice->setVertexBuffer( verts );

   switch (filter)
   {
   case GFXTextureFilterPoint :
      mDevice->setStateBlock(in_wrap ? mBitmapStretchWrapSB : mBitmapStretchSB);
      break;
   case GFXTextureFilterLinear :
      mDevice->setStateBlock(in_wrap ? mBitmapStretchWrapLinearSB : mBitmapStretchLinearSB);
      break;
   default:
      AssertFatal(false, "No GFXDrawUtil state block defined for this filter type!");
      mDevice->setStateBlock(mBitmapStretchSB);
      break;
   }   
   mDevice->setTexture( 0, texture );
   mDevice->setupGenericShaders( GFXDevice::GSModColorTexture );

   mDevice->drawPrimitive( GFXTriangleStrip, 0, 2 );
}

//-----------------------------------------------------------------------------
// Draw Rectangle
//-----------------------------------------------------------------------------
void GFXDrawUtil::drawRect( const Point2I &upperLeft, const Point2I &lowerRight, const ColorI &color ) 
{
   drawRect( Point2F((F32)upperLeft.x,(F32)upperLeft.y),Point2F((F32)lowerRight.x,(F32)lowerRight.y),color);
}

void GFXDrawUtil::drawRect( const RectI &rect, const ColorI &color )
{
   drawRect( rect.point, Point2I(rect.point.x + rect.extent.x - 1, rect.point.y + rect.extent.y - 1), color );
}

void GFXDrawUtil::drawRect( const RectF &rect, const ColorI &color )
{
   drawRect( rect.point, Point2F(rect.point.x + rect.extent.x - 1, rect.point.y + rect.extent.y - 1), color );
}

void GFXDrawUtil::drawRect( const Point2F &upperLeft, const Point2F &lowerRight, const ColorI &color )
{
   //
   // Convert Box   a----------x
   //               |          |
   //               x----------b
   //
   // Into Triangle-Strip Outline
   //               v0-----------v2
   //               | a         x |
   //               |  v1-----v3  |
   //               |   |     |   |
   //               |  v7-----v5  |
   //               | x         b |
   //               v6-----------v4
   //

   // NorthWest and NorthEast facing offset vectors
   // These adjust the thickness of the line, it'd be neat if one day
   // they were passed in as arguments.
   Point2F nw(-0.5f,-0.5f); /*  \  */
   Point2F ne(0.5f,-0.5f); /*  /  */

   GFXVertexBufferHandle<GFXVertexPC> verts (mDevice, 10, GFXBufferTypeVolatile );
   verts.lock();

   F32 ulOffset = 0.5f - mDevice->getFillConventionOffset();

   verts[0].point.set( upperLeft.x + ulOffset + nw.x, upperLeft.y + ulOffset + nw.y, 0.0f );
   verts[1].point.set( upperLeft.x + ulOffset - nw.x, upperLeft.y + ulOffset - nw.y, 0.0f );
   verts[2].point.set( lowerRight.x + ne.x, upperLeft.y + ulOffset + ne.y, 0.0f );
   verts[3].point.set( lowerRight.x - ne.x, upperLeft.y + ulOffset - ne.y, 0.0f );
   verts[4].point.set( lowerRight.x - nw.x, lowerRight.y - nw.y, 0.0f );
   verts[5].point.set( lowerRight.x + nw.x, lowerRight.y + nw.y, 0.0f );
   verts[6].point.set( upperLeft.x + ulOffset - ne.x, lowerRight.y - ne.y, 0.0f );
   verts[7].point.set( upperLeft.x + ulOffset + ne.x, lowerRight.y + ne.y, 0.0f );
   verts[8].point.set( upperLeft.x + ulOffset + nw.x, upperLeft.y + ulOffset + nw.y, 0.0f ); // same as 0
   verts[9].point.set( upperLeft.x + ulOffset - nw.x, upperLeft.y + ulOffset - nw.y, 0.0f ); // same as 1

   for (S32 i=0; i<10; i++)
      verts[i].color = color;

   verts.unlock();
   mDevice->setVertexBuffer( verts );

   mDevice->setStateBlock(mRectFillSB);
   mDevice->setupGenericShaders();
   mDevice->drawPrimitive( GFXTriangleStrip, 0, 8 );
}

//-----------------------------------------------------------------------------
// Draw Rectangle Fill
//-----------------------------------------------------------------------------
void GFXDrawUtil::drawRectFill( const RectF &rect, const ColorI &color )
{
   drawRectFill(rect.point, Point2F(rect.extent.x + rect.point.x - 1, rect.extent.y + rect.point.y - 1), color );
}

void GFXDrawUtil::drawRectFill( const Point2I &upperLeft, const Point2I &lowerRight, const ColorI &color ) 
{   
   drawRectFill(Point2F((F32)upperLeft.x, (F32)upperLeft.y), Point2F((F32)lowerRight.x, (F32)lowerRight.y), color);
}

void GFXDrawUtil::drawRectFill( const RectI &rect, const ColorI &color )
{
   drawRectFill(rect.point, Point2I(rect.extent.x + rect.point.x - 1, rect.extent.y + rect.point.y - 1), color );
}

void GFXDrawUtil::drawRectFill( const Point2F &upperLeft, const Point2F &lowerRight, const ColorI &color )
{
   //
   // Convert Box   a----------x
   //               |          |
   //               x----------b
   // Into Quad
   //               v0---------v1
   //               | a       x |
   //               |           |
   //               | x       b |
   //               v2---------v3
   //

   // NorthWest and NorthEast facing offset vectors
   Point2F nw(-0.5,-0.5); /*  \  */
   Point2F ne(0.5,-0.5); /*  /  */

   GFXVertexBufferHandle<GFXVertexPC> verts(mDevice, 4, GFXBufferTypeVolatile);
   verts.lock();

   F32 ulOffset = 0.5f - mDevice->getFillConventionOffset();
   
   verts[0].point.set( upperLeft.x + nw.x + ulOffset, upperLeft.y + nw.y + ulOffset, 0.0f);
   verts[1].point.set( lowerRight.x + ne.x + ulOffset, upperLeft.y + ne.y + ulOffset, 0.0f);
   verts[2].point.set( upperLeft.x - ne.x + ulOffset, lowerRight.y - ne.y + ulOffset, 0.0f);
   verts[3].point.set( lowerRight.x - nw.x + ulOffset, lowerRight.y - nw.y + ulOffset, 0.0f);

   for (S32 i=0; i<4; i++)
      verts[i].color = color;

   verts.unlock();

   mDevice->setStateBlock(mRectFillSB);
   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();
   mDevice->drawPrimitive( GFXTriangleStrip, 0, 2 );
}

void GFXDrawUtil::draw2DSquare( const Point2F &screenPoint, F32 width, F32 spinAngle )
{
   width *= 0.5;

   Point3F offset( screenPoint.x, screenPoint.y, 0.0 );

   GFXVertexBufferHandle<GFXVertexPC> verts( mDevice, 4, GFXBufferTypeVolatile );
   verts.lock();

   verts[0].point.set( -width, -width, 0.0f );
   verts[1].point.set( -width, width, 0.0f );
   verts[2].point.set( width,  -width, 0.0f );
   verts[3].point.set( width,  width, 0.0f );

   verts[0].color = verts[1].color = verts[2].color = verts[3].color = mBitmapModulation;

   if (spinAngle == 0.0f)
   {
      for( S32 i = 0; i < 4; i++ )
         verts[i].point += offset;
   }
   else
   {
      MatrixF rotMatrix( EulerF( 0.0, 0.0, spinAngle ) );

      for( S32 i = 0; i < 4; i++ )
      {
         rotMatrix.mulP( verts[i].point );
         verts[i].point += offset;
      }
   }

   verts.unlock();
   mDevice->setVertexBuffer( verts );

   mDevice->setStateBlock(mRectFillSB);
   mDevice->setupGenericShaders();

   mDevice->drawPrimitive( GFXTriangleStrip, 0, 2 );
}

//-----------------------------------------------------------------------------
// Draw Line
//-----------------------------------------------------------------------------
void GFXDrawUtil::drawLine( const Point3F &startPt, const Point3F &endPt, const ColorI &color )
{
   drawLine( startPt.x, startPt.y, startPt.z, endPt.x, endPt.y, endPt.z, color );
}

void GFXDrawUtil::drawLine( const Point2F &startPt, const Point2F &endPt, const ColorI &color )
{
   drawLine( startPt.x, startPt.y, 0.0f, endPt.x, endPt.y, 0.0f, color );
}

void GFXDrawUtil::drawLine( const Point2I &startPt, const Point2I &endPt, const ColorI &color )
{
   drawLine( startPt.x, startPt.y, 0.0f, endPt.x, endPt.y, 0.0f, color );
}

void GFXDrawUtil::drawLine( F32 x1, F32 y1, F32 x2, F32 y2, const ColorI &color )
{
   drawLine( x1, y1, 0.0f, x2, y2, 0.0f, color );
}

void GFXDrawUtil::drawLine( F32 x1, F32 y1, F32 z1, F32 x2, F32 y2, F32 z2, const ColorI &color )
{
   GFXVertexBufferHandle<GFXVertexPC> verts( mDevice, 2, GFXBufferTypeVolatile );
   verts.lock();

   verts[0].point.set( x1, y1, z1 );
   verts[1].point.set( x2, y2, z2 );

   verts[0].color = color;
   verts[1].color = color;

   verts.unlock();

   mDevice->setVertexBuffer( verts );
   mDevice->setStateBlock( mRectFillSB );
   mDevice->setupGenericShaders();
   mDevice->drawPrimitive( GFXLineList, 0, 1 );
}

//-----------------------------------------------------------------------------
// 3D World Draw Misc
//-----------------------------------------------------------------------------

static SphereMesh gSphere;

void GFXDrawUtil::drawSphere( const GFXStateBlockDesc &desc, F32 radius, const Point3F &pos, const ColorI &color, bool drawTop, bool drawBottom, const MatrixF *xfm )
{
   MatrixF mat;
   if ( xfm )
      mat = *xfm;
   else
      mat = MatrixF::Identity;

   mat.scale(Point3F(radius,radius,radius));
   mat.setPosition(pos);
   GFX->pushWorldMatrix();
   GFX->multWorld(mat);

   const SphereMesh::TriangleMesh * sphereMesh = gSphere.getMesh(2);
   S32 numPoly = sphereMesh->numPoly;
   S32 totalPoly = 0;
   GFXVertexBufferHandle<GFXVertexPC> verts(mDevice, numPoly*3, GFXBufferTypeVolatile);
   verts.lock();
   S32 vertexIndex = 0;
   for (S32 i=0; i<numPoly; i++)
   {
      if (!drawBottom)
      {
         if (sphereMesh->poly[i].pnt[0].z < -0.01f || sphereMesh->poly[i].pnt[1].z < -0.01f || sphereMesh->poly[i].pnt[2].z < -0.01f)
            continue;
      }
      if (!drawTop)
      {
         if (sphereMesh->poly[i].pnt[0].z > 0.01f || sphereMesh->poly[i].pnt[1].z > 0.01f || sphereMesh->poly[i].pnt[2].z > 0.01f)
            continue;
      }
      totalPoly++;

      verts[vertexIndex].point = sphereMesh->poly[i].pnt[0];
      verts[vertexIndex].color = color;
      vertexIndex++;

      verts[vertexIndex].point = sphereMesh->poly[i].pnt[1];
      verts[vertexIndex].color = color;
      vertexIndex++;

      verts[vertexIndex].point = sphereMesh->poly[i].pnt[2];
      verts[vertexIndex].color = color;
      vertexIndex++;
   }
   verts.unlock();

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();

   mDevice->drawPrimitive( GFXTriangleList, 0, totalPoly );

   GFX->popWorldMatrix();
}

//-----------------------------------------------------------------------------

static const Point3F cubePoints[8] = 
{
   Point3F(-1, -1, -1), Point3F(-1, -1,  1), Point3F(-1,  1, -1), Point3F(-1,  1,  1),
   Point3F( 1, -1, -1), Point3F( 1, -1,  1), Point3F( 1,  1, -1), Point3F( 1,  1,  1)
};

static const U32 cubeFaces[6][4] = 
{
   { 0, 4, 6, 2 }, { 0, 2, 3, 1 }, { 0, 1, 5, 4 },
   { 3, 2, 6, 7 }, { 7, 6, 4, 5 }, { 3, 7, 5, 1 }
};

void GFXDrawUtil::drawTriangle( const GFXStateBlockDesc &desc, const Point3F &p0, const Point3F &p1, const Point3F &p2, const ColorI &color, const MatrixF *xfm )
{
   if ( desc.fillMode == GFXFillWireframe )
      _drawWireTriangle( desc, p0, p1, p2, color, xfm );
   else
      _drawSolidTriangle( desc, p0, p1, p2, color, xfm );
}

void GFXDrawUtil::_drawWireTriangle( const GFXStateBlockDesc &desc, const Point3F &p0, const Point3F &p1, const Point3F &p2, const ColorI &color, const MatrixF *xfm )
{
   GFXVertexBufferHandle<GFXVertexPC> verts(mDevice, 4, GFXBufferTypeVolatile);
   verts.lock();

   // Set up the line strip
   verts[0].point = p0;
   verts[0].color = color;
   verts[1].point = p1;
   verts[1].color = color;
   verts[2].point = p2;
   verts[2].color = color;
   verts[3].point = p0;
   verts[3].color = color;

   // Apply xfm if we were passed one.
   if ( xfm != NULL )
   {
      for ( U32 i = 0; i < 4; i++ )
         xfm->mulP( verts[i].point );
   }

   verts.unlock();

   GFXStateBlockRef sb = mDevice->createStateBlock( desc );
   mDevice->setStateBlock( sb );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();

   mDevice->drawPrimitive( GFXLineStrip, 0, 3 );
}

void GFXDrawUtil::_drawSolidTriangle( const GFXStateBlockDesc &desc, const Point3F &p0, const Point3F &p1, const Point3F &p2, const ColorI &color, const MatrixF *xfm )
{
   GFXVertexBufferHandle<GFXVertexPC> verts(mDevice, 3, GFXBufferTypeVolatile);
   verts.lock();

   // Set up the line strip
   verts[0].point = p0;
   verts[0].color = color;
   verts[1].point = p1;
   verts[1].color = color;
   verts[2].point = p2;
   verts[2].color = color;

   // Apply xfm if we were passed one.
   if ( xfm != NULL )
   {
      for ( U32 i = 0; i < 3; i++ )
         xfm->mulP( verts[i].point );
   }

   verts.unlock();

   GFXStateBlockRef sb = mDevice->createStateBlock( desc );
   mDevice->setStateBlock( sb );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();

   mDevice->drawPrimitive( GFXTriangleList, 0, 1 );
}

void GFXDrawUtil::drawPolygon( const GFXStateBlockDesc& desc, const Point3F* points, U32 numPoints, const ColorI& color, const MatrixF* xfm /* = NULL */ )
{
   const bool isWireframe = ( desc.fillMode == GFXFillWireframe );
   const U32 numVerts = isWireframe ? numPoints + 1 : numPoints;
   GFXVertexBufferHandle< GFXVertexPC > verts( mDevice, numVerts, GFXBufferTypeVolatile );

   verts.lock();
   for( U32 i = 0; i < numPoints; ++ i )
   {
      verts[ i ].point = points[ i ];
      verts[ i ].color = color;
   }

   if( xfm )
   {
      for( U32 i = 0; i < numPoints; ++ i )
         xfm->mulP( verts[ i ].point );
   }
   
   if( isWireframe )
   {
      verts[ numVerts - 1 ].point = verts[ 0 ].point;
      verts[ numVerts - 1 ].color = color;
   }

   verts.unlock();

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();

   if( desc.fillMode == GFXFillWireframe )
      mDevice->drawPrimitive( GFXLineStrip, 0, numPoints );
   else
      mDevice->drawPrimitive( GFXTriangleFan, 0, numPoints - 2 );
}

void GFXDrawUtil::drawCube( const GFXStateBlockDesc &desc, const Box3F &box, const ColorI &color, const MatrixF *xfm )
{
   drawCube( desc, box.getExtents(), box.getCenter(), color, xfm );
}

void GFXDrawUtil::drawCube( const GFXStateBlockDesc &desc, const Point3F &size, const Point3F &pos, const ColorI &color, const MatrixF *xfm )
{
   if ( desc.fillMode == GFXFillWireframe )
      _drawWireCube( desc, size, pos, color, xfm );
   else
      _drawSolidCube( desc, size, pos, color, xfm );
}

void GFXDrawUtil::_drawWireCube( const GFXStateBlockDesc &desc, const Point3F &size, const Point3F &pos, const ColorI &color, const MatrixF *xfm )
{
   GFXVertexBufferHandle<GFXVertexPC> verts(mDevice, 30, GFXBufferTypeVolatile);
   verts.lock();

   Point3F halfSize = size * 0.5f;

   // setup 6 line loops
   U32 vertexIndex = 0;
   for(S32 i = 0; i < 6; i++)
   {
      for(S32 j = 0; j < 5; j++)
      {
         S32 idx = cubeFaces[i][j%4];

         verts[vertexIndex].point = cubePoints[idx] * halfSize;
         verts[vertexIndex].color = color;
         vertexIndex++;
      }
   }

   // Apply xfm if we were passed one.
   if ( xfm != NULL )
   {
      for ( U32 i = 0; i < 30; i++ )
         xfm->mulP( verts[i].point );
   }

   // Apply position offset
   for ( U32 i = 0; i < 30; i++ )
      verts[i].point += pos;

   verts.unlock();

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();

   for( U32 i=0; i<6; i++ )
      mDevice->drawPrimitive( GFXLineStrip, i*5, 4 );
}

void GFXDrawUtil::_drawSolidCube( const GFXStateBlockDesc &desc, const Point3F &size, const Point3F &pos, const ColorI &color, const MatrixF *xfm )
{
   GFXVertexBufferHandle<GFXVertexPC> verts(mDevice, 36, GFXBufferTypeVolatile);
   verts.lock();

   Point3F halfSize = size * 0.5f;

   // setup 6 line loops
   U32 vertexIndex = 0;
   U32 idx;
   for(S32 i = 0; i < 6; i++)
   {
      idx = cubeFaces[i][0];
      verts[vertexIndex].point = cubePoints[idx] * halfSize;      
      verts[vertexIndex].color = color;
      vertexIndex++;

      idx = cubeFaces[i][1];
      verts[vertexIndex].point = cubePoints[idx] * halfSize;
      verts[vertexIndex].color = color;
      vertexIndex++;

      idx = cubeFaces[i][3];
      verts[vertexIndex].point = cubePoints[idx] * halfSize;
      verts[vertexIndex].color = color;
      vertexIndex++;

      idx = cubeFaces[i][1];
      verts[vertexIndex].point = cubePoints[idx] * halfSize;
      verts[vertexIndex].color = color;
      vertexIndex++;

      idx = cubeFaces[i][2];
      verts[vertexIndex].point = cubePoints[idx] * halfSize;
      verts[vertexIndex].color = color;
      vertexIndex++;

      idx = cubeFaces[i][3];
      verts[vertexIndex].point = cubePoints[idx] * halfSize;
      verts[vertexIndex].color = color;
      vertexIndex++;
   }

   // Apply xfm if we were passed one.
   if ( xfm != NULL )
   {
      for ( U32 i = 0; i < 36; i++ )
         xfm->mulV( verts[i].point );
   }

   // Apply position offset
   for ( U32 i = 0; i < 36; i++ )
      verts[i].point += pos;

   verts.unlock();

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();

   mDevice->drawPrimitive( GFXTriangleList, 0, 12 );
}

void GFXDrawUtil::drawPolyhedron( const GFXStateBlockDesc &desc, const AnyPolyhedron &poly, const ColorI &color, const MatrixF *xfm )
{
   if ( desc.fillMode == GFXFillWireframe )
      _drawWirePolyhedron( desc, poly, color, xfm );
   else
      _drawSolidPolyhedron( desc, poly, color, xfm );
}

void GFXDrawUtil::_drawWirePolyhedron( const GFXStateBlockDesc &desc, const AnyPolyhedron &poly, const ColorI &color, const MatrixF *xfm )
{
   GFXDEBUGEVENT_SCOPE( GFXDrawUtil_DrawWirePolyhedron, ColorI::GREEN );

   const U32 numEdges = poly.getNumEdges();
   const Point3F* points = poly.getPoints();
   const Polyhedron::Edge* edges = poly.getEdges();

   // Allocate a temporary vertex buffer.

   GFXVertexBufferHandle< GFXVertexPC > verts( mDevice, numEdges * 2, GFXBufferTypeVolatile);

   // Fill it with the vertices for the edges.
   
   verts.lock();
   for( U32 i = 0; i < numEdges; ++ i )
   {
      const U32 nvert = i * 2;
      verts[ nvert + 0 ].point = points[ edges[ i ].vertex[ 0 ] ];
      verts[ nvert + 0 ].color = color;

      verts[ nvert + 1 ].point = points[ edges[ i ].vertex[ 1 ] ];
      verts[ nvert + 1 ].color = color;
   }

   if( xfm )
   {
      for( U32 i = 0; i < numEdges; ++ i )
      {
         xfm->mulP( verts[ i + 0 ].point );
         xfm->mulP( verts[ i + 1 ].point );
      }
   }
   verts.unlock();

   // Render the line list.

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();

   mDevice->drawPrimitive( GFXLineList, 0, numEdges );
}

void GFXDrawUtil::_drawSolidPolyhedron( const GFXStateBlockDesc &desc, const AnyPolyhedron &poly, const ColorI &color, const MatrixF *xfm )
{
   GFXDEBUGEVENT_SCOPE( GFXDrawUtil_DrawSolidPolyhedron, ColorI::GREEN );

   const U32 numPoints = poly.getNumPoints();
   const Point3F* points = poly.getPoints();
   const PlaneF* planes = poly.getPlanes();
   const Point3F viewDir = GFX->getViewMatrix().getForwardVector();

   // Create a temp buffer for the vertices and
   // put all the polyhedron's points in there.

   GFXVertexBufferHandle< GFXVertexPC > verts( mDevice, numPoints, GFXBufferTypeVolatile );
   
   verts.lock();
   for( U32 i = 0; i < numPoints; ++ i )
   {
      verts[ i ].point = points[ i ];
      verts[ i ].color = color;
   }

   if( xfm )
   {
      for( U32 i = 0; i < numPoints; ++ i )
         xfm->mulP( verts[ i ].point );
   }
   verts.unlock();

   // Allocate a temp buffer for the face indices.

   const U32 numIndices = poly.getNumEdges() * 2;
   const U32 numPlanes = poly.getNumPlanes();

   GFXPrimitiveBufferHandle prims( mDevice, numIndices, 0, GFXBufferTypeVolatile );

   // Unfortunately, since polygons may have varying numbers of
   // vertices, we also need to retain that information.

   FrameTemp< U32 > numIndicesForPoly( numPlanes );
   U32 numPolys = 0;

   // Create all the polygon indices.

   U16* indices;
   prims.lock( &indices );
   U32 idx = 0;
   for( U32 i = 0; i < numPlanes; ++ i )
   {
      // Since face extraction is somewhat costly, don't bother doing it for
      // backfacing polygons if culling is enabled.

      if( !desc.cullDefined || desc.cullMode != GFXCullNone )
      {
         F32 dot = mDot( planes[ i ], viewDir );

         // See if it faces *the same way* as the view direction.  This would
         // normally mean that the face is *not* backfacing but since we expect
         // planes on the polyhedron to be facing *inwards*, we need to reverse
         // the logic here.

         if( dot > 0.f )
            continue;
      }

      U32 numPoints = poly.extractFace( i, &indices[ idx ], numIndices - idx );
      numIndicesForPoly[ numPolys ] = numPoints;
      idx += numPoints;

      numPolys ++;
   }
   prims.unlock();

   // Set up state.

   mDevice->setStateBlockByDesc( desc );
   mDevice->setupGenericShaders();

   mDevice->setVertexBuffer( verts );
   mDevice->setPrimitiveBuffer( prims );

   // Render one triangle fan for each polygon.

   U32 startIndex = 0;
   for( U32 i = 0; i < numPolys; ++ i )
   {
      U32 numVerts = numIndicesForPoly[ i ];
      mDevice->drawIndexedPrimitive( GFXTriangleFan, 0, 0, numPoints, startIndex, numVerts - 2 );
      startIndex += numVerts;
   }
}

void GFXDrawUtil::drawObjectBox( const GFXStateBlockDesc &desc, const Point3F &size, const Point3F &pos, const MatrixF &objMat, const ColorI &color )
{
   GFXTransformSaver saver;

   mDevice->setStateBlockByDesc( desc );

   MatrixF scaledObjMat( true );
   scaledObjMat = objMat;

   scaledObjMat.scale( size );
   scaledObjMat.setPosition( pos );

   PrimBuild::color( color );
   PrimBuild::begin( GFXLineList, 48 );

   static const Point3F cubePoints[8] = 
   {
      Point3F(-0.5, -0.5, -0.5), Point3F(-0.5, -0.5,  0.5), Point3F(-0.5,  0.5, -0.5), Point3F(-0.5,  0.5,  0.5),
      Point3F( 0.5, -0.5, -0.5), Point3F( 0.5, -0.5,  0.5), Point3F( 0.5,  0.5, -0.5), Point3F( 0.5,  0.5,  0.5)
   };

   // 8 corner points of the box   
   for ( U32 i = 0; i < 8; i++ )
   {
      //const Point3F &start = cubePoints[i];  

      // 3 lines per corner point
      for ( U32 j = 0; j < 3; j++ )
      {
         Point3F start = cubePoints[i];
         Point3F end = start;
         end[j] *= 0.8f;

         scaledObjMat.mulP(start);
         PrimBuild::vertex3fv(start);
         scaledObjMat.mulP(end);
         PrimBuild::vertex3fv(end);            
      }
   }

   PrimBuild::end();
}

static const Point2F circlePoints[] = 
{
   Point2F(0.707107f, 0.707107f),
   Point2F(0.923880f, 0.382683f),
   Point2F(1.000000f, 0.000000f),
   Point2F(0.923880f, -0.382684f),
   Point2F(0.707107f, -0.707107f),
   Point2F(0.382683f, -0.923880f),
   Point2F(0.000000f, -1.000000f),
   Point2F(-0.382683f, -0.923880f),
   Point2F(-0.707107f, -0.707107f),
   Point2F(-0.923880f, -0.382684f),
   Point2F(-1.000000f, 0.000000f),
   Point2F(-0.923879f, 0.382684f),
   Point2F(-0.707107f, 0.707107f),
   Point2F(-0.382683f, 0.923880f),
   Point2F(0.000000f, 1.000000f),
   Point2F(0.382684f, 0.923879f)
};

void GFXDrawUtil::drawCapsule( const GFXStateBlockDesc &desc, const Point3F &center, F32 radius, F32 height, const ColorI &color, const MatrixF *xfm )
{
   if ( desc.fillMode == GFXFillWireframe )
      _drawWireCapsule( desc, center, radius, height, color, xfm );
   else
      _drawSolidCapsule( desc, center, radius, height, color, xfm );
}

void GFXDrawUtil::_drawSolidCapsule( const GFXStateBlockDesc &desc, const Point3F &center, F32 radius, F32 height, const ColorI &color, const MatrixF *xfm )
{	
   MatrixF mat;
   if ( xfm )
      mat = *xfm;      
   else
      mat = MatrixF::Identity;

   S32 numPoints = sizeof(circlePoints)/sizeof(Point2F);
   GFXVertexBufferHandle<GFXVertexPC> verts(mDevice, numPoints * 2 + 2, GFXBufferTypeVolatile);
   verts.lock();

   for (S32 i=0; i<numPoints + 1; i++)
   {
      S32 imod = i % numPoints;      
      verts[2 * i].point = Point3F( circlePoints[imod].x * radius, circlePoints[imod].y * radius, height );
      verts[2 * i].color = color;
      verts[2 * i + 1].point = Point3F( circlePoints[imod].x * radius, circlePoints[imod].y * radius, -height );
      verts[2 * i + 1].color = color;
   }

   S32 totalNumPnts = numPoints * 2 + 2;

   // Apply xfm if we were passed one.
   for ( U32 i = 0; i < totalNumPnts; i++ )
      mat.mulP( verts[i].point );

   // Apply position offset
   for ( U32 i = 0; i < totalNumPnts; i++ )
      verts[i].point += center;

   verts.unlock();

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();

   mDevice->drawPrimitive( GFXTriangleStrip, 0, 2 * numPoints );

   Point3F sphereCenter;
   MatrixF sphereMat;

   if ( xfm )
      sphereMat = *xfm;
   else
      sphereMat = MatrixF::Identity;   

   sphereCenter.set( 0, 0, 0.5f * height );
   mat.mulV( sphereCenter );
   sphereCenter += center;

   drawSphere( desc, radius, sphereCenter, color, true, false, &sphereMat );

   sphereCenter.set( 0, 0, -0.5f * height );
   mat.mulV( sphereCenter );
   sphereCenter += center;

   drawSphere( desc, radius, sphereCenter, color, false, true, &sphereMat );
}

void GFXDrawUtil::_drawWireCapsule( const GFXStateBlockDesc &desc, const Point3F &center, F32 radius, F32 height, const ColorI &color, const MatrixF *xfm )
{
   MatrixF mat;
   if ( xfm )
      mat = *xfm;
   else
      mat = MatrixF::Identity;

   mat.scale( Point3F(radius,radius,height*0.5f) );
   mat.setPosition(center);
   mDevice->pushWorldMatrix();
   mDevice->multWorld(mat);

   S32 numPoints = sizeof(circlePoints)/sizeof(Point2F);
   GFXVertexBufferHandle<GFXVertexPC> verts(mDevice, numPoints, GFXBufferTypeVolatile);
   verts.lock();
   for (S32 i=0; i< numPoints; i++)
   {
      S32 idx = i & (~1); // just draw the even ones
      F32 z = i & 1 ? 1.0f : -1.0f;
      verts[i].point = Point3F(circlePoints[idx].x,circlePoints[idx].y, z);
      verts[i].color = color;
   }
   verts.unlock();

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();

   for (S32 i=0; i<numPoints; i += 2)
      mDevice->drawPrimitive(GFXLineStrip, i, 1);

   mDevice->popWorldMatrix();

   Point3F sphereCenter;
   sphereCenter.z = center.z + 0.5f * height;
   drawSphere( desc, radius,sphereCenter,color,true,false);
   sphereCenter.z = center.z - 0.5f * height;
   drawSphere( desc, radius,sphereCenter,color,false,true);
}

void GFXDrawUtil::drawCone( const GFXStateBlockDesc &desc, const Point3F &basePnt, const Point3F &tipPnt, F32 baseRadius, const ColorI &color )
{   
   VectorF uvec = tipPnt - basePnt;
   F32 height = uvec.len();
   uvec.normalize();
   MatrixF mat( true );
   MathUtils::getMatrixFromUpVector( uvec, &mat );   
   mat.setPosition(basePnt);

   Point3F scale( baseRadius, baseRadius, height );
   mat.scale(scale);

   GFXTransformSaver saver;

   mDevice->pushWorldMatrix();
   mDevice->multWorld(mat);

   S32 numPoints = sizeof(circlePoints)/sizeof(Point2F);
   GFXVertexBufferHandle<GFXVertexPC> verts(mDevice, numPoints + 2, GFXBufferTypeVolatile);
   verts.lock();
   verts[0].point = Point3F(0.0f,0.0f,1.0f);
   verts[0].color = color;
   for (S32 i=0; i<numPoints + 1; i++)
   {
      S32 imod = i % numPoints;
      verts[i + 1].point = Point3F(circlePoints[imod].x,circlePoints[imod].y, 0.0f);
      verts[i + 1].color = color;
   }
   verts.unlock();

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders( GFXDevice::GSModColorTexture );

   mDevice->drawPrimitive( GFXTriangleFan, 0, numPoints );
   mDevice->drawPrimitive( GFXTriangleFan, 1, numPoints-1 );

   mDevice->popWorldMatrix();
}

void GFXDrawUtil::drawCylinder( const GFXStateBlockDesc &desc, const Point3F &basePnt, const Point3F &tipPnt, F32 radius, const ColorI &color )
{
   VectorF uvec = tipPnt - basePnt;
   F32 height = uvec.len();
   uvec.normalize();
   MatrixF mat( true );
   MathUtils::getMatrixFromUpVector( uvec, &mat );   
   mat.setPosition(basePnt);

   Point3F scale( radius, radius, height * 2 );
   mat.scale(scale);
   GFXTransformSaver saver;

   mDevice->pushWorldMatrix();
   mDevice->multWorld(mat);

   S32 numPoints = sizeof(circlePoints)/sizeof(Point2F);
   GFXVertexBufferHandle<GFXVertexPC> verts(mDevice, numPoints * 4 + 4, GFXBufferTypeVolatile);
   verts.lock();
   for (S32 i=0; i<numPoints + 1; i++)
   {
      S32 imod = i % numPoints;
      verts[i].point = Point3F(circlePoints[imod].x,circlePoints[imod].y, 0.5f);
      verts[i].color = color;
      verts[i + numPoints + 1].point = Point3F(circlePoints[imod].x,circlePoints[imod].y, 0);
      verts[i + numPoints + 1].color = color;

      verts[2*numPoints + 2 + 2 * i].point = Point3F(circlePoints[imod].x,circlePoints[imod].y, 0.5f);
      verts[2*numPoints + 2 + 2 * i].color = color;
      verts[2*numPoints + 2 + 2 * i + 1].point = Point3F(circlePoints[imod].x,circlePoints[imod].y, 0);
      verts[2*numPoints + 2 + 2 * i + 1].color = color;
   }
   verts.unlock();

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders( GFXDevice::GSModColorTexture );

   mDevice->drawPrimitive( GFXTriangleFan, 0, numPoints );
   mDevice->drawPrimitive( GFXTriangleFan, numPoints + 1, numPoints );
   mDevice->drawPrimitive( GFXTriangleStrip, 2 * numPoints + 2, 2 * numPoints);

   mDevice->popWorldMatrix();
}

void GFXDrawUtil::drawArrow( const GFXStateBlockDesc &desc, const Point3F &start, const Point3F &end, const ColorI &color )
{   
   GFXTransformSaver saver;

   // Direction and length of the arrow.
   VectorF dir = end - start;
   F32 len = dir.len();
   dir.normalize();   
   len *= 0.2f;      

   // Base of the cone will be a distance back from the end of the arrow
   // proportional to the total distance of the arrow... 0.3f looks about right.
   Point3F coneBase = end - dir * len * 0.3f;

   // Calculate the radius of the cone given that we want the cone to have
   // an angle of 25 degrees (just because it looks good).
   F32 coneLen = ( end - coneBase ).len();
   F32 coneDiameter = mTan( mDegToRad(25.0f) ) * coneLen;

   // Draw the cone on at the arrow's tip.
   drawCone( desc, coneBase, end, coneDiameter / 2.0f, color );

   // Get the difference in length from
   // the start of the cone to the end
   // of the cylinder so we can put the
   // end of the cylinder right against where
   // the cone starts.
   Point3F coneDiff = end - coneBase;

   // Draw the cylinder.
   F32 stickRadius = len * 0.025f;   
   drawCylinder( desc, start, end - coneDiff, stickRadius, color );
}

void GFXDrawUtil::drawFrustum( const Frustum &f, const ColorI &color )
{
   const Point3F  *points = f.getPoints();

   // Draw near and far planes.
   for (U32 offset = 0; offset < 8; offset+=4)
   {      
      drawLine(points[offset+0], points[offset+1], color);
      drawLine(points[offset+2], points[offset+3], color);
      drawLine(points[offset+0], points[offset+2], color);
      drawLine(points[offset+1], points[offset+3], color);            
   }

   // connect the near and far planes
   drawLine(points[Frustum::NearTopLeft], points[Frustum::FarTopLeft], color);
   drawLine(points[Frustum::NearTopRight], points[Frustum::FarTopRight], color);
   drawLine(points[Frustum::NearBottomLeft], points[Frustum::FarBottomLeft], color);
   drawLine(points[Frustum::NearBottomRight], points[Frustum::FarBottomRight], color);
}

void GFXDrawUtil::drawSolidPlane( const GFXStateBlockDesc &desc, const Point3F &pos, const Point2F &size, const ColorI &color )
{
   GFXVertexBufferHandle<GFXVertexPC> verts(mDevice, 4, GFXBufferTypeVolatile);
   verts.lock();

   verts[0].point = pos + Point3F( -size.x / 2.0f, -size.y / 2.0f, 0 );
   verts[0].color = color;
   verts[1].point = pos + Point3F( -size.x / 2.0f, size.y / 2.0f, 0 );
   verts[1].color = color;
   verts[2].point = pos + Point3F( size.x / 2.0f, size.y / 2.0f, 0 );
   verts[2].color = color;
   verts[3].point = pos + Point3F( size.x / 2.0f, -size.y / 2.0f, 0 );
   verts[3].color = color;

   verts.unlock();

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();

   mDevice->drawPrimitive( GFXTriangleFan, 0, 2 );
}

void GFXDrawUtil::drawPlaneGrid( const GFXStateBlockDesc &desc, const Point3F &pos, const Point2F &size, const Point2F &step, const ColorI &color, Plane plane )
{
   // Note that when calculating the number of steps, we +0.5 to round up,
   // and +1 for the last line (ie. 4 steps needs 5 lines to be rendered)
   U32 uSteps = 0;
   if( step.x > 0 )
      uSteps = size.x / step.x + 0.5 + 1;

   U32 vSteps = 0;
   if( step.y > 0 )
      vSteps = size.y / step.y + 0.5 + 1;
      
   if( uSteps <= 1 || vSteps <= 1 )
      return;
      
   const U32 numVertices = uSteps * 2 + vSteps * 2;
   const U32 numLines = uSteps + vSteps;
   
   Point3F origin;
   switch( plane )
   {
      case PlaneXY:
         origin = Point3F( pos.x - ( size.x / 2.0f ), pos.y - ( size.y / 2.0f ), pos.z );
         break;

      case PlaneXZ:
         origin = Point3F( pos.x - ( size.x / 2.0f ), pos.y, pos.z - ( size.y / 2.0f ) );
         break;

      case PlaneYZ:
         origin = Point3F( pos.x, pos.y - ( size.x / 2.0f ), pos.z - ( size.y / 2.0f ) );
         break;
   }

   GFXVertexBufferHandle<GFXVertexPC> verts( mDevice, numVertices, GFXBufferTypeVolatile );
   verts.lock();

   U32 vertCount = 0;

   if( plane == PlaneXY || plane == PlaneXZ )
   {
      F32 start = mFloor( origin.x / step.x + 0.5f ) * step.x;
      for ( U32 i = 0; i < uSteps; i++ )
      {
         verts[vertCount].point = Point3F( start + step.x * i, origin.y, origin.z );
         verts[vertCount].color = color;
         ++vertCount;

         if( plane == PlaneXY )
            verts[vertCount].point = Point3F( start + step.x * i, origin.y + size.y, origin.z );
         else
            verts[vertCount].point = Point3F( start + step.x * i, origin.y,  origin.z + size.y );
            
         verts[vertCount].color = color;
         ++vertCount;
      }
   }

   if( plane == PlaneXY || plane == PlaneYZ )
   {      
      U32 num;
      F32 stp;
      if( plane == PlaneXY )
      {
         num = vSteps;
         stp = step.y;
      }
      else
      {
         num = uSteps;
         stp = step.x;
      }

      F32 start = mFloor( origin.y / stp + 0.5f ) * stp;
         
      for ( U32 i = 0; i < num; i++ )
      {
         verts[vertCount].point = Point3F( origin.x, start + stp * i, origin.z );
         verts[vertCount].color = color;
         ++vertCount;

         if( plane == PlaneXY )
            verts[vertCount].point = Point3F( origin.x + size.x, start + stp * i, origin.z );
         else
            verts[vertCount].point = Point3F( origin.x, start + stp * i, origin.z + size.x );
            
         verts[vertCount].color = color;
         ++vertCount;
      }
   }

   if( plane == PlaneXZ || plane == PlaneYZ )
   {
      F32 start = mFloor( origin.z / step.y + 0.5f ) * step.y;
      for ( U32 i = 0; i < vSteps; i++ )
      {
         verts[vertCount].point = Point3F( origin.x, origin.y, start + step.y * i );
         verts[vertCount].color = color;
         ++vertCount;

         if( plane == PlaneXZ )
            verts[vertCount].point = Point3F( origin.x + size.x, origin.y, start + step.y * i );
         else
            verts[vertCount].point = Point3F( origin.x, origin.y + size.x, start + step.y * i );
            
         verts[vertCount].color = color;
         ++vertCount;
      }
   }

   verts.unlock();

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();

   mDevice->drawPrimitive( GFXLineList, 0, numLines );
}

void GFXDrawUtil::drawTransform( const GFXStateBlockDesc &desc, const MatrixF &mat, const Point3F *scale, const ColorI colors[3] )
{
   GFXTransformSaver saver;

   GFX->multWorld( mat );

   GFXVertexBufferHandle<GFXVertexPC> verts( mDevice, 6, GFXBufferTypeVolatile );
   verts.lock();

   const static ColorI defColors[3] = 
   {
      ColorI::RED,
      ColorI::GREEN,
      ColorI::BLUE
   };

   const ColorI *colArray = ( colors != NULL ) ? colors : defColors;

   verts[0].point = Point3F::Zero;
   verts[0].color = colArray[0];
   verts[1].point = Point3F( 1, 0, 0 );
   verts[1].color = colArray[0];
   verts[2].point = Point3F::Zero;
   verts[2].color = colArray[1];
   verts[3].point = Point3F( 0, 1, 0 );
   verts[3].color = colArray[1];
   verts[4].point = Point3F::Zero;
   verts[4].color = colArray[2];
   verts[5].point = Point3F( 0, 0, 1 );
   verts[5].color = colArray[2];

   if ( scale )
   {
      verts[1].point *= *scale;
      verts[3].point *= *scale;
      verts[5].point *= *scale;      
   }

   verts.unlock();

   mDevice->setStateBlockByDesc( desc );

   mDevice->setVertexBuffer( verts );
   mDevice->setupGenericShaders();
   mDevice->drawPrimitive( GFXLineList, 0, 3 );
}