SpherePointGen [T3D]

This is a SceneObject derived class that is intended as a helper for generating uniformly random distributed points within a sphere, allowing you to preview and tweak some parameters from within the WorldEditor, and then dump those points to file as a hlsl-style float3 array.

I created this as a helper for generating the sample points used by the T3D SSAO PostEffect.

Installation:
Place both source files in the engine/source/T3D folder and rebuild.

Usage:
Start T3D, open a level, open the WorldEditor, then type genericCreateObject("SpherePointGen"); in the console. Select it and tweak values from the Inspector. To dump the points to disk give your object a name and call the viewPoints method from the console.

Extensions:
It could be useful to extend this class to not ONLY do uniformly random distributions but also, for example, poisson distribution or even just applying a little bias.


spherePointGen.h

#ifndef _SPHEREPOINTGEN_H_
#define _SPHEREPOINTGEN_H_

#ifndef _SCENEOBJECT_H_
#include "sceneGraph/sceneObject.h"
#endif
#ifndef _GFXSTATEBLOCK_H_
#include "gfx/gfxStateBlock.h"
#endif
#ifndef _GFXVERTEXBUFFER_H_
#include "gfx/gfxVertexBuffer.h"
#endif
#ifndef _GFXPRIMITIVEBUFFER_H_
#include "gfx/gfxPrimitiveBuffer.h"
#endif
#ifndef _TVECTOR_H_
#include "core/util/tVector.h"
#endif


class SpherePointGen : public SceneObject
{
   typedef SceneObject Parent;

   enum MaskBits 
   {
      TransformMask = Parent::NextFreeMask << 0,
      UpdateMask    = Parent::NextFreeMask << 1,
      NextFreeMask  = Parent::NextFreeMask << 2
   };

   Vector<Point3F> mPoints;
   F32 mRadius;
   S32 mCount;
   U32 mSeed;
   F32 mPointRenderSize;
   bool mShowBoundingSphere;

public:

   SpherePointGen();
   virtual ~SpherePointGen();

   DECLARE_CONOBJECT(SpherePointGen);

   static void initPersistFields();
   virtual void inspectPostApply();

   virtual bool onAdd();
   virtual void onRemove();
   virtual void setTransform( const MatrixF &mat );
   virtual void setScale( const VectorF & scale );
   virtual U32 packUpdate( NetConnection *conn, U32 mask, BitStream *stream );
   virtual void unpackUpdate( NetConnection *conn, BitStream *stream );

   void createPoints();

   bool prepRenderImage( SceneState *state, const U32 stateKey, 
      const U32 startZone, const bool modifyBaseZoneState = false);

   void render( ObjectRenderInst *ri, SceneState *state, BaseMatInstance *overrideMat );

   void viewPoints();  
};

#endif // _SPHEREPOINTGEN_H_

spherePointGen.cpp

#include "platform/platform.h"
#include "T3D/spherePointGen.h"

#include "console/consoleTypes.h"
#include "math/mathIO.h"
#include "sceneGraph/sceneState.h"
#include "core/stream/bitStream.h"
#include "gfx/gfxDrawUtil.h"
#include "renderInstance/renderPassManager.h"
#include "core/stream/fileStream.h"

IMPLEMENT_CO_NETOBJECT_V1(SpherePointGen);


SpherePointGen::SpherePointGen()
 : mRadius( 1.0f ),
   mCount( 50 ),
   mSeed( 100 ),
   mPointRenderSize( 0.03f ),
   mShowBoundingSphere( true )
{
   mNetFlags.set( Ghostable | ScopeAlways );
   mTypeMask |= StaticObjectType;
}

SpherePointGen::~SpherePointGen()
{
}

void SpherePointGen::initPersistFields()
{
   addField( "radius", TypeF32, Offset( mRadius, SpherePointGen ) );
   addField( "count", TypeS32, Offset( mCount, SpherePointGen ) );
   addField( "seed", TypeS32, Offset( mSeed, SpherePointGen ) );
   addField( "pointRenderSize", TypeF32, Offset( mPointRenderSize, SpherePointGen ) );
   addField( "showBoundingSphere", TypeBool, Offset( mShowBoundingSphere, SpherePointGen ) );  
   
   Parent::initPersistFields();
}


void SpherePointGen::inspectPostApply()
{   
   mRadius = getMax( mRadius, 0.01f );
   mCount = mClamp( mCount, 1, 500 );
   mPointRenderSize = mClampF( mPointRenderSize, 0.001f, 100.0f );

   setMaskBits( UpdateMask );
   Parent::inspectPostApply();
}

bool SpherePointGen::onAdd()
{
   if ( !Parent::onAdd() )
      return false;

   mObjBox.set( Point3F( -0.5f, -0.5f, -0.5f ),
      Point3F(  0.5f,  0.5f,  0.5f ) );

   resetWorldBox();

   addToScene();

   if ( isClientObject() )
      createPoints();

   return true;
}

void SpherePointGen::onRemove()
{
   removeFromScene();

   Parent::onRemove();
}

void SpherePointGen::setTransform(const MatrixF & mat)
{
   Parent::setTransform( mat );

   setMaskBits( TransformMask );
}

void SpherePointGen::setScale( const VectorF & scale )
{  
   // Scale always equals the radius!
   VectorF overrideScale( mRadius, mRadius, mRadius );
   Parent::setScale( overrideScale );   
}

U32 SpherePointGen::packUpdate( NetConnection *conn, U32 mask, BitStream *stream )
{
   U32 retMask = Parent::packUpdate( conn, mask, stream );

   if ( stream->writeFlag( mask & TransformMask ) )
   {
      mathWrite(*stream, getTransform());
      mathWrite(*stream, getScale());
   }

   if ( stream->writeFlag( mask & UpdateMask ) )
   {
      stream->write( mRadius );
      stream->write( mCount );
      stream->write( mSeed );
      stream->write( mPointRenderSize );
      stream->writeFlag( mShowBoundingSphere );
   }

   return retMask;
}

void SpherePointGen::unpackUpdate(NetConnection *conn, BitStream *stream)
{
   Parent::unpackUpdate(conn, stream);

   if ( stream->readFlag() )  // TransformMask
   {
      mathRead(*stream, &mObjToWorld);
      mathRead(*stream, &mObjScale);

      setTransform( mObjToWorld );
   }

   if ( stream->readFlag() )   // UpdateMask
   {
      stream->read( &mRadius );
      stream->read( &mCount );
      stream->read( &mSeed );
      stream->read( &mPointRenderSize );
      mShowBoundingSphere = stream->readFlag();

      if ( isProperlyAdded() )
      {
         createPoints();
      }
   }
}


void SpherePointGen::createPoints()
{
   mPoints.clear();

   // Random distribution

   MRandomLCG rand( mSeed );

   for ( U32 i = 0; i < mCount; i++ )
   {
      Point3F pnt;

      U32 realityCheck = 0;
      while ( true )
      {
         pnt.set( rand.randF(-mRadius ,mRadius ), rand.randF(-mRadius ,mRadius ), rand.randF(-mRadius ,mRadius ) );         

         if ( pnt.len() <= mRadius )
            break;

         AssertFatal( ++realityCheck < 100, "SpherePointGen::createPoints - Something is wrong here!" );
      }

      mPoints.push_back( pnt );
   }
}

bool SpherePointGen::prepRenderImage( SceneState *state, const U32 stateKey, 
                                          const U32 startZone, const bool modifyBaseZoneState)
{
   if ( isLastState( state, stateKey ) )
      return false;

   setLastState(state, stateKey);

   if ( state->isObjectRendered( this ) ) 
   {
      ObjectRenderInst *ri = state->getRenderPass()->allocInst<ObjectRenderInst>();
      ri->renderDelegate.bind( this, &SpherePointGen::render );
      ri->type = RenderPassManager::RIT_Object;
      ri->defaultKey = 0;
      ri->defaultKey2 = 0;
      state->getRenderPass()->addInst( ri );
   }

   return false;
}

void SpherePointGen::render( ObjectRenderInst *ri, SceneState *state, BaseMatInstance *overrideMat )
{
   if ( overrideMat )
      return;      

   GFXDrawUtil *drawer = GFX->getDrawUtil();

   const MatrixF &objectMat = getRenderTransform();
   const Point3F &objectPos = objectMat.getPosition();

   GFXStateBlockDesc defaultDesc; 

   GFXStateBlockDesc sphereDesc;
   sphereDesc.setBlend( true );
   sphereDesc.setZReadWrite( true, false );
   sphereDesc.setCullMode( GFXCullNone );

   if ( mShowBoundingSphere )   
      drawer->drawSphere( sphereDesc, mRadius, objectPos, ColorI(0,0,150,30) );

   const U32 numPoints = mPoints.size();

   if ( numPoints == 0 )
      return;      
              
   ColorI pntColor;
   const Point3F pntSize( mPointRenderSize, mPointRenderSize, mPointRenderSize );

   for ( U32 i = 0; i < numPoints; i++ )
   {
      Point3F pnt = mPoints[i];
      objectMat.mulV( pnt );
      
      pntColor = ColorI::WHITE * ( 1.0f - pnt.len() / mRadius );

      drawer->drawCube( defaultDesc, pntSize, pnt + objectPos, pntColor );         
   }
}

void SpherePointGen::viewPoints()
{
   // Hack: if this gets called on the server object by accident
   // redirect to the local client object since its the
   // one that actually generates points.
   if ( isServerObject() )
   {
      if ( getClientObject() )
      {
         static_cast< SpherePointGen* >( getClientObject() )->viewPoints();
         return;
      }
   }

   String filename = Torque::FS::MakeUniquePath( "", "SpherePoints", "txt" );

   FileStream *fstream = FileStream::createAndOpen( filename, Torque::FS::File::Write );
   if ( !fstream )         
      return;
   
   char buff[256];
   dSprintf( buff, 256, "float3 spherePts[%d] =n{n", mPoints.size() );
   fstream->writeText( buff );
     
   for ( U32 i = 0; i < mPoints.size(); i++ )
   {
      const Point3F &pnt = mPoints[i];

      if ( i != mPoints.size() - 1 )
         dSprintf( buff, 256, "tfloat3( %f, %f, %f ),n", pnt.x, pnt.y, pnt.z );
      else
         dSprintf( buff, 256, "tfloat3( %f, %f, %f )n", pnt.x, pnt.y, pnt.z );  

      fstream->writeText( buff );
   }
   
   fstream->writeText( "};n" );

   fstream->close();
   delete fstream;  

   Platform::openFile( filename );
}

ConsoleMethod( SpherePointGen, viewPoints, void, 2, 2, "" )
{
   object->viewPoints();
}