ShVariable.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 SHVARIABLE_HPP
#define SHVARIABLE_HPP

#include "ShDllExport.hpp"
#include "ShRefCount.hpp"
#include "ShVariableNode.hpp"
#include "ShSwizzle.hpp"
#include "ShUtility.hpp"
#include "ShMetaForwarder.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() {}

  ShVariable& operator=(const ShProgram& prg);
  
  bool null() const; 
  
  bool uniform() const; 
  bool hasValues() const; 

  
  int size() const; 



  
  void range(ShVariableNode::ValueType low, ShVariableNode::ValueType high);
  ShVariableNode::ValueType lowBound() const;
  ShVariableNode::ValueType highBound() const;

  
  const ShSwizzle& swizzle() const;

  const ShVariableNodePtr& node() const;

  bool neg() const;

  bool& neg();
  
  void getValues(ShVariableNode::ValueType dest[]) const;
  ShVariableNode::ValueType getValue(int index) const;
  
  void setValues(ShVariableNode::ValueType values[]);
  void setValue(int index, ShVariableNode::ValueType value);
  
  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;

  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

---