computeSlab.cpp

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////
// 6/18/02      Aaron Lefohn    Scientific Computing and Imaging Institute
// School of Computing          University of Utah
//////////////////////////////////////////////////////////////////////

#include "computeSlab.h"
#include <mm.h>
#include <assert.h>

ComputeSlab::ComputeSlab( const VecTexPtr& vecInTex, GlewShadeLang lang, const Vec2i& dimen, GLfloat z )
{
        initInputMembers( vecInTex, lang, NULL, NULL, dimen, z );
}

ComputeSlab::ComputeSlab( const VecTexPtr& vecInTex, GlewShadeLang lang, PBuffer* pbuffDest, 
                                                  const Vec2i& dimen, GLfloat z )
{
        if( pbuffDest==NULL ) {
                err() << "ComputeSlab(...) Error:\n"
                         << "\tpbuffDest == NULL.\n";
                exit(1);
        }

        initInputMembers( vecInTex, lang, pbuffDest, NULL, dimen, z );
}

ComputeSlab::ComputeSlab( const VecTexPtr& vecInTex, GlewShadeLang lang, BasicTexture* texDest, 
                                                  const Vec2i& dimen, GLfloat z )
{
        if( texDest==NULL ) {
                err() << "ComputeSlab(...) Error:\n"
                         << "\ttexDest == NULL.\n";
                exit(1);
        }

        initInputMembers( vecInTex, lang, NULL, texDest, dimen, z );
}

void ComputeSlab::initInputMembers( const VecTexPtr& vecInTex, GlewShadeLang lang,
                                                                    PBuffer* pbuffDest, BasicTexture* texDest, 
                                                                        const Vec2i& dimen, GLfloat z )
{
        m_texInput      = new MultiTexture( vecInTex ); // Create the texture set
        m_lang          = lang;
        m_pbuffDest = pbuffDest;
        m_texDest       = texDest;
        m_dimen         = dimen;
        m_z                     = z;

        m_pass           = NULL;
        m_pixShader  = NULL;
        m_texPerturb = NULL;
        m_progShader = NULL;
        m_shader         = NULL;
        m_quad           = NULL;
        m_shadedPrim = NULL;
}

void ComputeSlab::create( PixelShader* pixShader )
{
        // Create Programmable Shader
        m_pixShader      = pixShader;
        m_texPerturb = texPerturbs( m_dimen );  // Calls subclass-def'd virtual function
        m_progShader = new ProgShader( numTexUnits(), m_pixShader, m_texPerturb );

        m_shader         = new Shader( m_texInput, m_progShader );  // Create the complete shader
        m_quad           = new PlanarQuad( Vec2f(0.0), Vec2f(m_dimen.w, m_dimen.h), m_z, true ); // The geometry/texCoords
        m_shadedPrim = new ShadedPrim( m_quad, m_shader );                                                                       // Combine shader, texCoords/perturbs, geom
        m_pass           = new RenderPass(  m_shadedPrim, m_texDest, m_pbuffDest );
        //m_shadedPrim->compile();

        assert( m_pixShader != NULL );
        assert( m_progShader != NULL );
        assert( m_shader != NULL );
        assert( m_quad != NULL );
        assert( m_shadedPrim != NULL );
        assert( nand(m_pbuffDest, m_texDest) );//One or both of these MUST be NULL.
        assert( m_pass != NULL );
                
        derr("ComputeSlab::create(...): RenderPass created.);
}

ComputeSlab::ComputeSlab( const ComputeSlab& rhs )
{
        copyMembers(rhs);
}

ComputeSlab& ComputeSlab::operator=( const ComputeSlab& rhs )
{
        if( &rhs != this ) {
                copyMembers(rhs);
        }
        return *this;
}

void ComputeSlab::copyMembers( const ComputeSlab& rhs )
{
        copyMembers( rhs.m_pass, rhs.m_dimen, rhs.m_z, rhs.m_pbuffDest, rhs.m_texDest, rhs.m_lang,
                                 rhs.m_texInput, rhs.m_pixShader, rhs.m_shadedPrim, rhs.m_progShader, 
                                 rhs.m_quad, rhs.m_shader, rhs.m_texPerturb );
}

void ComputeSlab::copyMembers( RenderPass* pass, const Vec2i& dimen, GLfloat z, PBuffer* pbuffDest, 
                                                           BasicTexture* texDest, GlewShadeLang lang,
                                                           MultiTexture* texInput, PixelShader* pixShader, ShadedPrim* shadedPrim, 
                                                           ProgShader* progShader, RawPrim* quad, Shader* shader, 
                                                           TexCoordPerturb* texPerturb )
{
        // These are input vars so they are shallow-copied.
        m_dimen = dimen;
        m_z             = z;
        m_pbuffDest = pbuffDest;
        m_texDest   = texDest;
        m_lang          = lang;

        reset(); // Delete all instance-allocated memory.

        // These are generated by each intance so they get deep-copied.
        // TODO: Call ->clone() on all of these...make a clone for ALL objects!!!
        m_texInput = texInput;
        m_pass  = pass;
        m_pixShader = pixShader;
        m_shadedPrim = shadedPrim;
        m_progShader = progShader;
        m_quad = quad;
        m_shader = shader;
        m_texPerturb = texPerturb;
}

ComputeSlab::~ComputeSlab()
{
        reset();
}

void ComputeSlab::reset()
{
        delete m_pass;
        delete m_pixShader;
        delete m_shadedPrim;
        delete m_progShader;
        delete m_quad;
        delete m_shader;
        delete m_texPerturb;
        delete m_texInput;
}

void ComputeSlab::render()
{
        // This is here b/c we need the fully-constructed "this" pointer for initialization
        // so the constructor cannot do it (not ANSI-safe to do so even though VS 6.0 allows it).
        if( !m_pass ) {
                create( makePixShader(this) );
        }
        
        m_pass->render();
}

void ComputeSlab::resetShader()
{
        if( !m_pixShader ) {
                create( makePixShader(this) );
        }
        
        m_pixShader->reset();
}

TexCoordPerturb* ComputeSlab::getTexPerturbs( const Vec2i& dimen )
{
        return NULL;
}

void ComputeSlab::pixShaderATI()  
{
        err() << "pixShaderATI() Error:\n"
                 << "\tVirtual Function not defined in base class.\n";
        exit(1);
}

void ComputeSlab::pixShaderNV20() 
{
        err() << "pixShaderNV20() Error:\n"
                 << "\tVirtual Function not defined in base class.\n";
        exit(1);
}

void ComputeSlab::pixShaderNV30() 
{
        err() << "pixShaderNV30() Error:\n"
                 << "\tVirtual Function not defined in base class.\n";
        exit(1);
}

void ComputeSlab::pixShaderCG()   
{
        err() << "pixShaderCG() Error:\n"
                 << "\tVirtual Function not defined in base class.\n";
        exit(1);
}

---

Send questions, comments, and bug reports to: