ShVariable.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2006 Serious Hack Inc.
// 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
// MA  02110-1301, USA
#ifndef SHVARIABLE_HPP
#define SHVARIABLE_HPP

#include "ShDllExport.hpp"
#include "ShRefCount.hpp"
#include "ShSwizzle.hpp"
#include "ShUtility.hpp"
#include "ShMetaForwarder.hpp"
#include "ShVariant.hpp"
#include "ShVariableNode.hpp"

namespace SH {

class ShProgram;

class 
SH_DLLEXPORT ShVariable : public ShMetaForwarder {
public:
  ShVariable();
  ShVariable(const ShVariableNodePtr& node);
  ShVariable(const ShVariableNodePtr& node, const ShSwizzle& swizzle, bool neg);

  ~ShVariable() {}

  /* Executes a program and assigns the result to this variable.
   *
   * In retained mode, the prg gets inserted into the ShProgram currently
   * being defined.
   */
  ShVariable& operator=(const ShProgram& prg);
 
  /* Attaches a ShProgram to this variable, making it a dependent uniform. */
  void attach(const ShProgram& prg);
  
  bool null() const; 
  
  bool uniform() const; 
  bool hasValues() const; 

  
  int size() const; 

                    
  ShValueType valueType() const; 


  
  // TODO check if this works when swizzle contains one index more than once
  void rangeVariant(const ShVariant* low, const ShVariant* high);

  // @{
  ShVariantPtr lowBoundVariant() const;

  ShVariantPtr highBoundVariant() const;

  
  const ShSwizzle& swizzle() const;

  const ShVariableNodePtr& node() const;

  bool neg() const;

  bool& neg();

  
  ShVariantPtr getVariant() const;
  ShVariantPtr getVariant(int index) const;

  bool loadVariant(ShVariant *&result) const;
  void updateVariant();
  // @}

  
  void setVariant(const ShVariant* other, bool neg, const ShSwizzle &writemask); 
  void setVariant(const ShVariantCPtr& other, bool neg, const ShSwizzle &writemask); 
  // @}
 
  void setVariant(const ShVariant* other, int index); 
  void setVariant(const ShVariantCPtr& other, int index); 
  // @}

  void setVariant(const ShVariant* other);
  void setVariant(const ShVariantCPtr& other);
  // @}


  ShVariable operator()() const; 
  ShVariable operator()(int) const;
  ShVariable operator()(int, int) const;
  ShVariable operator()(int, int, int) const;
  ShVariable operator()(int, int, int, int) const;
  ShVariable operator()(int size, int indices[]) const;
  ShVariable operator()(const ShSwizzle &swizzle) const;

  
  ShVariable operator-() const;

  bool operator==(const ShVariable& other) const;
  bool operator!=(const ShVariable& other) const { return !((*this) == other); }

  void clone(const ShVariable& other);
  
protected:
  
  ShVariableNodePtr m_node; 
  ShSwizzle m_swizzle; 
  bool m_neg; 

  friend SH_DLLEXPORT std::ostream& operator<<(std::ostream& out, const ShVariable& shVariableToPrint);
};

}

#endif

---