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 "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() {}

  ShVariable& operator=(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(ShVariantCPtr other, bool neg, const ShSwizzle &writemask);
  // @}
 
  void setVariant(const ShVariant* other, int index);
  void setVariant(ShVariantCPtr other, int index);
  // @}

  void setVariant(const ShVariant* other);
  void setVariant(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;

  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

---