ArbCode.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright (c) 2003 University of Waterloo Computer Graphics Laboratory
// Project administrator: Michael D. McCool
// Authors: Zheng Qin, Stefanus Du Toit, Kevin Moule, Tiberiu S. Popa,
//          Michael D. McCool
// 
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// 
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 
// 1. The origin of this software must not be misrepresented; you must
// not claim that you wrote the original software. If you use this
// software in a product, an acknowledgment in the product documentation
// would be appreciated but is not required.
// 
// 2. Altered source versions must be plainly marked as such, and must
// not be misrepresented as being the original software.
// 
// 3. This notice may not be removed or altered from any source
// distribution.
#ifndef ARBCODE_HPP
#define ARBCODE_HPP

#include "GlBackend.hpp"
#include "ShTransformer.hpp"
#include "ShVariableNode.hpp"
#include "ShVariable.hpp"
#include "ShCtrlGraph.hpp"
#include "ShTextureNode.hpp"
#include "ShProgram.hpp"
#include "ShSwizzle.hpp"
#include "ShRefCount.hpp"
#include "ShStructural.hpp"
#include "ArbLimits.hpp"
#include "ArbReg.hpp"
#include "ArbInst.hpp"

namespace shgl {

class ArbCode;
class ArbBindingSpecs;
class ArbMapping;

// Filters for code emission and environment setup
const unsigned int SH_ARB_ANY   = 0x0000; // All targets
const unsigned int SH_ARB_FP    = 0x0001; // ARB_fragment_program
const unsigned int SH_ARB_VP    = 0x0002; // ARB_vertex_program
const unsigned int SH_ARB_NVFP  = 0x0004; // NV_fragment_program_option
const unsigned int SH_ARB_NVFP2 = 0x0008; // NV_fragment_program2
const unsigned int SH_ARB_ATIDB = 0x0010; // ATI_draw_buffers
const unsigned int SH_ARB_NVVP2 = 0x0020; // NV_vertex_program2_option
const unsigned int SH_ARB_NVVP3 = 0x0040; // NV_vertex_program3
const unsigned int SH_ARB_VEC1  = 0x0080; // Maximum source has length 1
const unsigned int SH_ARB_VEC2  = 0x0100; // Maximum source has length 2
const unsigned int SH_ARB_VEC3  = 0x0200; // Maximum source has length 3
const unsigned int SH_ARB_VEC4  = 0x0400; // Maximum source has length 4
const unsigned int SH_ARB_END   = 0x1000; // Not a filter. End of
                                         // table.

class ArbCode : public SH::ShBackendCode {
public:
  ArbCode(const SH::ShProgramNodeCPtr& program, const std::string& target,
          TextureStrategy* texture);
  virtual ~ArbCode();

  virtual bool allocateRegister(const SH::ShVariableNodePtr& var);
  virtual void freeRegister(const SH::ShVariableNodePtr& var);
  
  virtual void upload();
  virtual void bind();
  virtual void update();
  virtual void updateUniform(const SH::ShVariableNodePtr& uniform);
  
  std::ostream& print(std::ostream& out);
  std::ostream& describe_interface(std::ostream& out);

  void generate();
  
private:

  void genNode(SH::ShCtrlGraphNodePtr node);

  void genStructNode(const SH::ShStructuralNodePtr& node);

  void emit(const SH::ShStatement& stmt);

  void emit_div(const SH::ShStatement& stmt);
  void emit_sqrt(const SH::ShStatement& stmt);
  void emit_lerp(const SH::ShStatement& stmt);
  void emit_dot2(const SH::ShStatement& stmt);
  void emit_eq(const SH::ShStatement& stmt);
  void emit_ceil(const SH::ShStatement& stmt);
  void emit_mod(const SH::ShStatement& stmt);
  void emit_trig(const SH::ShStatement& stmt);
  void emit_invtrig(const SH::ShStatement& stmt);
  void emit_tan(const SH::ShStatement& stmt);
  void emit_exp(const SH::ShStatement& stmt);
  void emit_log(const SH::ShStatement& stmt);
  void emit_norm(const SH::ShStatement& stmt);
  void emit_sgn(const SH::ShStatement& stmt);
  void emit_tex(const SH::ShStatement& stmt);
  void emit_nvcond(const SH::ShStatement& stmt);
  void emit_cmul(const SH::ShStatement& stmt);
  void emit_csum(const SH::ShStatement& stmt);
  void emit_kil(const SH::ShStatement& stmt);
  void emit_pal(const SH::ShStatement& stmt);
  
  void allocRegs();

  void allocInputs(const ArbLimits& limits);
  
  void allocOutputs(const ArbLimits& limits);
  
  void allocParam(const ArbLimits& limits, const SH::ShVariableNodePtr& node);

  void allocPalette(const ArbLimits& limits, const SH::ShPaletteNodePtr& node);

  void allocConsts(const ArbLimits& limits);

  void allocTemps(const ArbLimits& limits, bool half);

  void allocTextures(const ArbLimits& limits);

  void bindTextures();

  void bindTexture(const SH::ShTextureNodePtr& node);
    
  void bindSpecial(const SH::ShProgramNode::VarList::const_iterator& begin,
                   const SH::ShProgramNode::VarList::const_iterator& end,
                   const ArbBindingSpecs& specs, 
                   std::vector<int>& bindings,
                   ArbRegType type, int& num);

  std::ostream& printVar(std::ostream& out, bool dest, const SH::ShVariable& var,
                         bool collectingOp,
                         const SH::ShSwizzle& destSwiz,
                         bool do_swiz) const;

  bool printSamplingInstruction(std::ostream& out, const ArbInst& inst) const;

  int getLabel(SH::ShCtrlGraphNodePtr node);
  
  TextureStrategy* m_texture;
  // NOTE: These two pointer are deliberately not smart pointers
  // so that the circular referenece between a program and
  // its compiled code is broken
  SH::ShProgramNode* m_shader; // internally visible shader ShTransformered to fit this target (ARB)
  SH::ShProgramNode* m_originalShader; // original shader (should alway use this for external (e.g. globals))
  std::string m_unit;

  typedef std::vector<ArbInst> ArbInstList;
  ArbInstList m_instructions;

  std::list<int> m_tempRegs;

  int m_numTemps;

  int m_numHalfTemps;

  int m_numInputs;

  int m_numOutputs;

  int m_numParams;

  int m_numParamBindings;

  int m_numConsts;

  int m_numTextures;

  typedef std::map<SH::ShVariableNodePtr,
                   SH::ShPointer<ArbReg> > RegMap;
  RegMap m_registers;

  typedef std::list< SH::ShPointer<ArbReg> > RegList;
  RegList m_reglist;

  std::vector<int> m_outputBindings;
  std::vector<int> m_inputBindings;


  //@todo remove m_splits and m_converts with dependent uniforms 
  
  SH::ShTransformer::VarSplitMap m_splits;

  // floating point types
  //
  // @todo may want more intelligent conversion if hardware 
  SH::ShTransformer::ValueTypeMap m_convertMap;

  unsigned int m_programId;

  static ArbMapping table[];

  // Extensions and language alternatives available. See list above
  unsigned int m_environment;

  typedef std::map<SH::ShCtrlGraphNodePtr, int> LabelMap;
  LabelMap m_label_map; 
  int m_max_label;

  // For array lookup
  SH::ShVariable m_address_register;
};

typedef SH::ShPointer<ArbCode> ArbCodePtr;


}

#endif

---