C:/development/RenderTools/src/factory/ShadowProxy.cpp

Go to the documentation of this file.

#ifndef RT_GLES1

#include "ShadowProxy.h"
#include "Error.h"
#include "Camera.h"
#include "Sampler.h"
#include "Rendergroup.h"
#include "Program.h"
#include "RelationalNode.h"
#include "Rendernode.h"
#include "Stateset.h"

namespace RenderTools {

RelationalNodePtr                                       ShadowProxy::s_model = RelationalNodePtr();
ShadowProxyList                 ShadowProxy::s_proxies;
GLfloat                                 ShadowProxy::s_offset = 0.0f;
CameraPtr                               ShadowProxy::s_camera = CameraPtr();
GLfloat *                               ShadowProxy::s_data = 0;
Mat4Ptr                                 ShadowProxy::s_params = 0;
GLint                                   ShadowProxy::s_gridSize[2];
GLint                                   ShadowProxy::s_mapSize[2];
GLint                                   ShadowProxy::s_mapSize2[2];
GLint                                   ShadowProxy::s_cellSize[2];
GLint                                   ShadowProxy::s_numProxies;
GLint                                   ShadowProxy::s_maxProxiesPerCell;
GLint                                   ShadowProxy::s_maxUniqueProxies;
SamplerPtr                              ShadowProxy::s_map = SamplerPtr();

PropertyPtr ShadowProxy::create( const XMLNodePtr & xml ){
        if( ! s_model ){
                s_model = RelationalNodePtr( new RelationalNode() );
                s_model->createProperties();
                createProperty( s_model.get(), "offset", & s_offset );
                s_model->setName( xml );
                s_model->setProperties( xml, false );
        }
        else {
                Error::error( Error::REINITIALIZATION, __FILE__, __LINE__ );
        }
        return( dynamic_pointer_cast< AbstractProperty, RelationalNode >( s_model ) );
}

const string ShadowProxy::getTypeName( bool ofComponent ) const {
        return( "ShadowProxy" );
}

SamplerPtr ShadowProxy::getMap( void ){ 
        return( s_map ); 
}

Vec2 ShadowProxy::getMapSize( void ){ 
        return( Vec2( s_mapSize[0], s_mapSize[1] ) ); 
}

Vec2 ShadowProxy::getMapSize2( void ){ 
        return( Vec2( s_mapSize2[0], s_mapSize2[1] ) ); 
}

Vec2 ShadowProxy::getGridSize( void ){ 
        return( Vec2( s_gridSize[0], s_gridSize[1] ) ); 
}

ShadowProxyPtr ShadowProxy::addProxy( ProxyType type, const Vec3 & size, const Vec3 & color, const RendernodePtr node, const Mat4 & matrix ){
        ShadowProxyPtr proxy = ShadowProxyPtr( new ShadowProxy( type, size, color, node, matrix ) );
        s_proxies.push_back( proxy );
        return( proxy );
}

void ShadowProxy::setCamera( const CameraPtr camera ){
        s_camera = camera;
}

void ShadowProxy::onInitialize( void ){

        if( ! s_camera ){
                Error::error( Error::NULL_POINTER, __FILE__, __LINE__ );
        }

        s_gridSize[0] = ( GLint )s_camera->getViewport()[2] / 16;
        s_gridSize[1] = ( GLint )s_camera->getViewport()[3] / 16;

        s_mapSize[0] = s_gridSize[0] * 3;
        s_mapSize[1] = s_gridSize[1] * 3;

        s_mapSize2[0] = 1;
        s_mapSize2[1] = 1;
        while( s_mapSize2[0] < s_mapSize[0] )s_mapSize2[0] *= 2;
        while( s_mapSize2[1] < s_mapSize[1] )s_mapSize2[1] *= 2;

        s_cellSize[0] = ( GLint )s_camera->getViewport()[2] / s_gridSize[0];
        s_cellSize[1] = ( GLint )s_camera->getViewport()[3] / s_gridSize[1];

        s_maxProxiesPerCell = ( s_mapSize[0] / s_gridSize[0] ) * ( s_mapSize[1] / s_gridSize[1] ) * 4;
        s_maxUniqueProxies      = 100;

        s_params = ( Mat4Ptr )realloc( s_params, s_maxUniqueProxies * sizeof( Mat4 ) );

        s_data = ( GLfloat * )realloc( s_data, s_mapSize2[0] * s_mapSize2[1] * 4 * sizeof( GLfloat ) );

        XMLNodePtr xml = XMLNodePtr( new XMLNode() );
        xml->setTagName( "Sampler" );
        xml->setAttrib<string>( "name", "ProxyMap" );
        xml->addChild( "width", toString( s_mapSize2[0] ) );
        xml->addChild( "height", toString( s_mapSize2[1] ) );
        xml->addChild( "mode", "GL_MODULATE" );
        xml->addChild( "wrap_mode", "GL_CLAMP" );
        xml->addChild( "filter", "GL_NEAREST" );
        xml->addChild( "mipmap", "GL_FALSE" );
        xml->addChild( "format", "GL_RGBA" );
        xml->addChild( "type", "GL_FLOAT" );
        xml->addChild( "internal_format", "GL_RGBA32F_ARB" );

        s_map = dynamic_pointer_cast< Sampler, AbstractProperty >( Sampler::create( xml ) );

        PropertyList unif;
        RendergroupList list = (RendergroupList)Rendergroup::findRendergroups();
        for( int li = 0; li < (int)list.size(); li++ ){
                RendergroupPtr group = list[ li ];

                unif = group->findUniforms( "ProxyMap" );
                for( unsigned int i = 0; i < unif.size(); i++ ){
                        unif[ i ]->setValue( toString( s_map ) );
                }
                unif = group->findUniforms( "proxy_map_size" );
                Vec2 v( s_mapSize[0], s_mapSize[1] );
                for( unsigned int i = 0; i < unif.size(); i++ ){
                        unif[ i ]->setValue( toString( v ) );
                }
                unif = group->findUniforms( "proxy_map_size2" );
                v = Vec2( s_mapSize2[0], s_mapSize2[1] );
                for( unsigned int i = 0; i < unif.size(); i++ ){
                        unif[ i ]->setValue( toString( v ) );
                }
                unif = group->findUniforms( "proxy_grid_size" );
                v = Vec2( s_gridSize[0], s_gridSize[1] );
                for( unsigned int i = 0; i < unif.size(); i++ ){
                        unif[ i ]->setValue( toString( v ) );
                }
        }
}

void ShadowProxy::project( void ){
        if( ! s_camera ){
                Error::error( Error::NULL_POINTER, __FILE__, __LINE__, string( "you MUST call ShadowProxy::initialize( camera ) first !" ) );
        }
        int i, k, m;

        // clean up before we start
        for( i = 0; i < s_mapSize2[0] * s_mapSize2[1] * 4; i++ ){
                s_data[ i ] = -1.0;
        }
        // no proxies yet
        s_numProxies = 0;

        if( ! Rendergroup::getActiveRendergroup() )return;
        PropertyPtr unif = Rendergroup::getActiveRendergroup()->findUniform( "proxyOffset" );
        if( ! unif )return;
        GLfloat proxyOffset;
        stringstream value( unif->getValue() );
        value >> proxyOffset;

        // prepare the camera
        s_camera->bind();

        for( i = 0; i < (int)s_proxies.size() && s_numProxies < s_maxUniqueProxies; i++ ){
                // get a quick reference
                ShadowProxyPtr proxy = s_proxies[ i ];
                // get the global transform, assuming it has been updated
                Mat4 matrix;
                matrix = proxy->getAssociatedRendernode()->getLocal();
                // multiply by the local offset
                matrix *= proxy->getLocal();
                // retrieve the position into a Vec4
                Vec4 position;
                Vec3 p3;
                p3 = matrix.getCol(3).xyz();
                position = Vec4( p3[0], p3[1], p3[2], 1.0 );
                // the rotation as two pairs of polar coords as a Vec4
                Vec4 rotation = matrix.toPolar();
                // get the axis-aligned bounding box of this proxy and project it onto the camera
                Rectangle rect = s_camera->project( proxy->getAABB( Vec3( proxyOffset, proxyOffset, proxyOffset ) ), matrix );
                // get the minimum/maximum horizontal/vertical cell-index 
                GLint minx = ( GLint )floor( rect[0] / s_cellSize[0] );
                GLint maxx = ( GLint )floor( rect[1] / s_cellSize[0] );
                GLint miny = ( GLint )floor( rect[2] / s_cellSize[1] );
                GLint maxy = ( GLint )floor( rect[3] / s_cellSize[1] );
                // skip if not in view
                if( maxx < 0 )continue;
                if( maxy < 0 )continue;
                if( minx >= s_gridSize[0] )continue;
                if( miny >= s_gridSize[1] )continue;
                // clamp against legal (visible) values
                if( minx < 0 )minx = 0;
                if( miny < 0 )miny = 0;
                if( maxx >= s_gridSize[0] )maxx = s_gridSize[0] - 1;
                if( maxy >= s_gridSize[1] )maxy = s_gridSize[1] - 1;
                // get the proxy-specific parameters
                // the size is m_size + m_proxyOffset
                Vec3 size = proxy->getSize( Vec3( proxyOffset, proxyOffset, proxyOffset ) );
                // get the type of geometry
                const int type = proxy->getType();
                // get the proxy color
                const Vec3 & color = proxy->getColor();
                // add the proxy to the collection
                int proxyIndex = addProxy( position, rotation, color, type, size );
                if( proxyIndex == -1 ){
                        // could not add proxy; max proxies ?
                        Error::warning( Error::TOO_MANY_ITEMS, __FILE__, __LINE__, "maximum shadow proxies reached" );
                        continue;
                }
                // run through the gridcells that are overlapped 
                // by this proxy and register the proxy for that cell
                for( k = minx; k <= maxx; k++ ){
                        for( m = miny; m <= maxy; m++ ){
                                addIndex( k, m, proxyIndex );
                        }
                }
        }

        s_map->setData( s_data );

        PropertyList uniforms = Rendergroup::getActiveRendergroup()->findUniforms( "proxyParams" );
        for( unsigned int i = 0; i < uniforms.size(); i++ ){
                for( int j = 0; j < s_numProxies; j++ ){
                        uniforms[ i ]->setValue( toString( s_params[ j ] ), j );
                }
        }
        Error::assertNoErrors( __FILE__, __LINE__ );
}

void ShadowProxy::deleteAssociatedProxies( const RendernodePtr node ){
        for( int i = 0; i < (int)s_proxies.size(); i++ ){
                if( s_proxies[ i ]->getAssociatedRendernode() == node ){
                        s_proxies[ i ] = s_proxies[ s_proxies.size() - 1 ];
                        s_proxies.pop_back();
                        i--;
                }
        }
}

void ShadowProxy::deleteAssociatedProxies( string path ){
        for( int i = 0; i < (int)s_proxies.size(); i++ ){
                if( s_proxies[ i ]->getAssociatedRendernode()->getPath() == path ){
                        s_proxies[ i ] = s_proxies[ s_proxies.size() - 1 ];
                        s_proxies.pop_back();
                        i--;
                }
        }
}

int ShadowProxy::retrieveIndex( const RendernodePtr node ){
        for( int i = 0; i < (int)s_proxies.size(); i++ ){
                if( s_proxies[ i ]->getAssociatedRendernode() == node ){
                        return( i );
                }
        }
        return( -1 );
}

void ShadowProxy::render( bool showGrid ){
#ifndef RT_GLES2
        glMatrixMode( GL_MODELVIEW );
        glPushMatrix();
        glLoadIdentity();

        s_camera->bind();

//      glPushAttrib( GL_ALL_ATTRIB_BITS );
        glEnable( GL_BLEND );
#ifdef GL_ALPHA_TEST 
        glEnable( GL_ALPHA_TEST );
#endif
#ifdef GL_SRC_ALPHA
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); 
#endif
        glLineWidth( 1.0 );

        for( int i = 0; i < (int)s_proxies.size(); i++ ){
                s_proxies[ i ]->render( );
        }

        if( showGrid ){

                glDisable( GL_TEXTURE_2D );
/*
                s_camera->alignViewportToScreen();

                float sx = ( s_camera->getViewport()[2] / s_gridSize[0] );
                float sy = ( s_camera->getViewport()[3] / s_gridSize[1] );
                for( int i = 0; i < s_gridSize[0]; i++ ){
                        for( int j = 0; j < s_gridSize[1]; j++ ){
                                int num = getNumProxies( i, j );
                                glBegin( GL_QUADS );
                                if( num ){
                                        glColor4f( 0,1,0,0.5 * ( 0.1 * ( num > 5 ? 5 : num + 2 ) ) );
                                }
                                else{
                                        glColor4f( 0,1,0,0.1);
                                }
                                glVertex2f( i * sx, j * sy );
                                glVertex2f( ( i + 1 ) * sx , j * sy );
                                glVertex2f( ( i + 1 ) * sx, ( j + 1 ) * sy );
                                glVertex2f( i * sx, ( j + 1 ) * sy );
                                glEnd();
                        }
                }
                for( int i = 0; i < s_gridSize[0]; i++ ){
                        for( int j = 0; j < s_gridSize[1]; j++ ){
                                int num = getNumProxies( i, j );
                                if( num ){
                                        glLineWidth( 2.0 );
                                        glBegin( GL_LINE_LOOP );
                                        glColor4f( 0,1,0,0.5 * ( 0.1 * ( num > 5 ? 5 : num  + 2 ) ) );
                                }
                                else{
                                        glLineWidth( 1.0 );
                                        glBegin( GL_LINE_LOOP );
                                        glColor4f( 0,1,0,0.1);
                                }
                                glVertex2f( i * sx, j * sy );
                                glVertex2f( ( i + 1 ) * sx , j * sy );
                                glVertex2f( ( i + 1 ) * sx, ( j + 1 ) * sy );
                                glVertex2f( i * sx, ( j + 1 ) * sy );
                                glEnd();
                        }
                }
*/
        }

        glMatrixMode( GL_MODELVIEW );
        glPopMatrix();
#endif
}

int ShadowProxy::getNumProxies( int x, int y ){
        if( ! s_camera ){
                Error::error( Error::NULL_POINTER, __FILE__, __LINE__, string( "you MUST call ShadowProxy::initialize( camera ) first !" ) );
        }
        int ncx = s_gridSize[0];
        int ncy = s_gridSize[1];
        int csx = s_mapSize[0] / ncx;
        int csy = s_mapSize[1] / ncy;

        int rowlen = s_mapSize2[0] * 4;

        int count = 0;

        int offset1 = y * rowlen * csy + x * csx * 4;

        int i, j;
        for( j = 0; j < csy; j++ ){
                for( i = 0; i < csx * 4; i++ ){
                        int offset2 = offset1 + j * rowlen + i;
                        if( s_data[ offset2 ] >= 0.0 ){
                                count++;
                        }
                        else{
                                break;
                        }
                }
        }

        return( count );

}

void ShadowProxy::addIndex( int x, int y, int idx ){
        if( ! s_camera ){
                Error::error( Error::NULL_POINTER, __FILE__, __LINE__, string( "you MUST call ShadowProxy::initialize( camera ) first !" ) );
        }
        int ncx = s_gridSize[0];
        int ncy = s_gridSize[1];
        int csx = s_mapSize[0] / ncx;
        int csy = s_mapSize[1] / ncy;

        int rowlen = s_mapSize2[0] * 4;

        int offset1 = y * rowlen * csy + x * csx * 4;

        int i, j;
        for( j = 0; j < csy; j++ ){
                for( i = 0; i < csx * 4; i++ ){
                        int offset2 = offset1 + j * rowlen + i;
                        if( s_data[ offset2 ] < 0.0 ){
                                s_data[ offset2 ] = (float)idx;
                                return;
                        }
                }
        }
}

int ShadowProxy::addProxy( const Vec4 & position, const Vec4 & rotation, const Vec3 & color, int type, const Vec3 & size ){
        if( ! s_camera ){
                Error::error( Error::NULL_POINTER, __FILE__, __LINE__, string( "you MUST call ShadowProxy::initialize( camera ) first !" ) );
        }
        if( s_numProxies >= s_maxUniqueProxies )return( -1 );

        GLfloat glm[16];
        glm[0] = position[0];
        glm[1] = position[1];
        glm[2] = position[2];
        glm[3] = position[3];

        glm[4] = rotation[0];
        glm[5] = rotation[1];
        glm[6] = rotation[2];
        glm[7] = rotation[3];

        glm[8] = color[0];
        glm[9] = color[1];
        glm[10] = color[2];
        glm[11] = type;

        glm[12] = size[0];
        glm[13] = size[1];
        glm[14] = size[2];
        glm[15] = 0.0; // unused

        for( int i = 0; i < s_numProxies; i++ ){
                if( s_params[i].equals( glm, 0.0001 ) )return( i );
        }
        s_params[ s_numProxies ] = Mat4( glm );

        return( s_numProxies++ );
}

ShadowProxy::ShadowProxy(       ProxyType type,
                                                        const Vec3 & size,
                                                        const Vec3 & color,
                                                        const RendernodePtr node, 
                                                        const Mat4 & local ):
        m_type( type ),
        m_size( size ),
        m_color( color ),
        m_associatedRendernode( node ),
        m_local( local ){

}

const int ShadowProxy::getType() const { 
        return( m_type ); 
}

Vec3 ShadowProxy::getSize( const Vec3 & offset ) const { 
        return( m_size + offset ); 
}

void ShadowProxy::setSize( const Vec3 & size ){ 
        m_size = size; 
}

const Vec3 & ShadowProxy::getColor( void ) const { 
        return( m_color ); 
}

const Mat4 & ShadowProxy::getLocal( void ) const { 
        return( m_local ); 
}

AABB ShadowProxy::getAABB( const Vec3 & offset ){ 
        return( AABB( m_size + offset ) ); 
}

const RendernodePtr ShadowProxy::getAssociatedRendernode( void ) const { 
        return( m_associatedRendernode ); 
}

void ShadowProxy::render( void ){

#ifndef RT_GLES2

        glMatrixMode( GL_MODELVIEW );
        glPushMatrix();

        Mat4 ogl( m_associatedRendernode->getLocal() * m_local );
        glLoadMatrixf( * ogl );

        if( ! Rendergroup::getActiveRendergroup() )return;

        PropertyPtr unif = Rendergroup::getActiveRendergroup()->findUniform( "proxyOffset" );

        if( ! unif )return;

        GLfloat proxyOffset;
        stringstream value( unif->getValue() );
        value >> proxyOffset;

        Vec3 sizeFactor = ( m_size + Vec3( proxyOffset, proxyOffset, proxyOffset ) ) / m_size;

        glLineWidth( 1.0 );

        switch( m_type ){
                case SPHERE:
#if glScalef
                        glScalef( m_size[0], m_size[1], m_size[2] );
#endif
                        glColor4f( 1,0,0,0.5 );
                        wireSphere( 1.0, 12, 12 );

#if glScalef
                        glScalef( sizeFactor[0], sizeFactor[1], sizeFactor[2] );
#endif
                        glColor4f( 1,0,0,0.2 );
                        wireSphere( 1.0, 12, 12 );
                        break;
                case CYLINDER:
                        //glPushAttrib( GL_POLYGON_BIT );
#ifdef GL_QUAD_STRIP 
                        glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
                        glColor4f( 1,0,0,0.5 );
                        glBegin( GL_QUAD_STRIP );
                        for( int i = 0; i <= 24; i++ ){
                                float a = ( (float)i / 24.0 ) * 2.0 * M_PI;
                                float x = cos( a ) * m_size[0];
                                float y = sin( a ) * m_size[1];
                                float z = m_size[2];
                                glVertex3f( x, y, z );
                                glVertex3f( x, y, -z );
                        }
                        glEnd();
                        glColor4f( 1,0,0,0.2 );
                        glBegin( GL_QUAD_STRIP );
                        for( int i = 0; i <= 24; i++ ){
                                float a = ( (float)i / 24.0 ) * 2.0 * M_PI;
                                float x = cos( a ) * m_size[0] * sizeFactor[0];
                                float y = sin( a ) * m_size[1] * sizeFactor[1];
                                float z = m_size[2] * sizeFactor[2];
                                glVertex3f( x, y, z );
                                glVertex3f( x, y, -z );
                        }
                        glEnd();
#endif
                        //glPopAttrib();

                        break;
                case BOX:
#if glScalef
                        glScalef( m_size[0], m_size[1], m_size[2] );
#endif
                        glColor4f( 1,0,0,0.5 );
                        wireCube( 2.0 );

                        glColor4f( 1,0,0,0.2 );
#if glScalef
                        glScalef( sizeFactor[0], sizeFactor[1], sizeFactor[2] );
#endif
                        wireCube( 2.0 );
                        break;
        }
        glPopMatrix();
#endif // OpenGL|ES 2.0
}

}; // namespace

#endif // OpenGL|ES 1.0

int ______forced_public_symbol = 0;

---