ShVariable.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2005 Serious Hack Inc.
// 
// 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() {}

  /* 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(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 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

---