Crank.h

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     3-20-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

/// Crank.h

/// the grinder's driver class, turn the crank to see the monkey dance!!
///  A base class for specialized grinders, a grinder should only produce
///  one thing, fragment/vertex/shader programs, you should link 
///  vertex and fragment (etc..) grinders to a shader grinder...

///  specialized Crank base classes are defined at the bottom!!!

#ifndef __GRINDER_CRANK_DOT_H
#define __GRINDER_CRANK_DOT_H

#include <simBase/simBase.h>
#include <stateGlift.h>
#include "Tape.h"
#include <volume/Volume.h>
#include <mathGutz.h>
#include "GrinderKeys.h"
#include "GrinderKinds.h"
#include "MetaProg.h"
#include <arrayGutz.h>

class Crank : public SimBase {
public:
   virtual ~Crank() {}

   /// from <GrinderKinds.h>
   int getKind() const { return _kind; }

   /// Vertex Shader
   virtual glift::VertexShaderSP getVertShader() 
   { return glift::VertexShaderSP(0); }
   
   /// Pixel Shader
   virtual glift::PixelShaderSP  getPixelShader()
   { return glift::PixelShaderSP(0); }

   /// a complete shader specification
   virtual glift::ProgShaderSP   getShader()     
   { return glift::ProgShaderSP(0); }

   ////////////////////////////////////////////////////
   //// meta program management.
   int        addMP(MetaProgSP m);
   int        insertMP(int idx, MetaProgSP m);
   void       setMP(SNameType name, MetaProgSP m);
   void       setMP(int idx, MetaProgSP m);
   MetaProgSP getMP(int idx);
   MetaProgSP getMP(SNameType name);
   int        getMPIdx(SNameType name);
   int        getMPIdx(MetaProgSP m);
   MetaProgSP delMP(int idx);
   MetaProgSP delMP(SNameType name);
   MetaProgSP delMP(MetaProgSP m);

protected:
   Crank() : _kind(GK_UNKNOWN), _lastCh(1,-1) {}
   Crank(int kind) : _kind(kind) {}
   Crank(const Crank &c);

   //// Customize behavior of MP management:

   //// you might want to be smarter about how
   ////  you check kinds....
   //// this is called with every modification to
   //// the meta-prog vector, from management ^^^
   /// false = valid kind, true = invalid kind
   virtual bool   checkKind(MetaProgSP m)
   {
      if(_kind == GK_UNKNOWN) return false;
      if(m.isNull()) return true;
      if(m->getKind() == GK_UNKNOWN) return false;
      return !(_kind == m->getKind());
   }
   /// this prints when you have a bad kind...
   /// might want to print an err insteand of a derr
   virtual void kindErr(const char *where = 0)
   {
      derr("Invalid Kind", where);
   }

   bool mpsChanged();
   gutz::arrayo1i _lastCh; ///keep track of changes

   /// generic tape management
   void   addTape(TapeSPVec &v, TapeSP t);
   void   insertTape(TapeSPVec &v, int i, TapeSP t);
   void   setTape(TapeSPVec &v, int i, TapeSP t);
   TapeSP getTape(TapeSPVec &v, int i);
   void   delTape(TapeSPVec &v, int i);
   void   delTape(TapeSPVec &v, TapeSP t);

   virtual GrinderKeysSP buildFPEnvKeys();

   MetaProgSPVec _mprogs;
   
   int _kind;
};

//////////////////////////////////////////////////////////////////
/// typed base classes for specific cranks
//////////////////////////////////////////////////////////////////

///////////////////////
/// vertex
///////////////////////

class VPCrank : public Crank {
public:
   virtual ~VPCrank() {}

   virtual glift::VertexShaderSP getVertShader() = 0;

protected:
   VPCrank() : Crank(GK_VERTEX) {}
   VPCrank(const VPCrank &vpc);

   glift::VertexShaderSP _lastVP;
};

///////////////////////
/// fragment
///////////////////////

class FPCrank : public Crank {
public:
   virtual ~FPCrank() {}

   virtual glift::PixelShaderSP getPixelShader() = 0;

protected:
   FPCrank() : Crank(GK_FRAGMENT) {}
   FPCrank(const FPCrank &vpc);

   glift::PixelShaderSP _lastPS;
};

#endif

---

Send questions, comments, and bug reports to: