ShAttribImpl.hpp

// WARNING - DO NOT EDIT THIS FILE:
// This file was automatically generated from ../../sh-trunk/src/scripts/ShAttribImpl.hpp.py.
// If you wish to change it, edit that file instead.
//
// ---
//
// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2005 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 SH_SHATTRIBIMPL_HPP
#define SH_SHATTRIBIMPL_HPP

#include "ShAttrib.hpp"
#include "ShContext.hpp"
#include "ShStatement.hpp"
#include "ShDebug.hpp"

namespace SH {

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>::ShAttrib()
  : ShGeneric<N, T>(new ShVariableNode(Binding, N, ShStorageTypeInfo<T>::value_type, Semantic))
{
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>::ShAttrib(const ShGeneric<N, T2>& other)
  : ShGeneric<N, T>(new ShVariableNode(Binding, N, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>::ShAttrib(const ShAttrib<N, Binding, T, Semantic, Swizzled>& other)
  : ShGeneric<N, T>(new ShVariableNode(Binding, N, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>::ShAttrib(const ShAttrib<N, Binding, T2, Semantic, Swizzled>& other)
  : ShGeneric<N, T>(new ShVariableNode(Binding, N, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>::ShAttrib(const ShVariableNodePtr& node,
  const ShSwizzle& swizzle, bool neg)
  : ShGeneric<N, T>(node, swizzle, neg)
{
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>::ShAttrib(host_type data[N])
  : ShGeneric<N, T>(new ShVariableNode(Binding, N, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    for (int i = 0; i < N; i++) setValue(i, data[i]);
  } else {
    (*this) = ShAttrib<N, SH_CONST, T, Semantic>(data);
  }
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>::~ShAttrib()
{
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator=(const ShGeneric<N, T2>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator=(const ShAttrib<N, Binding, T, Semantic, Swizzled>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator=(const ShAttrib<N, Binding, T2, Semantic, Swizzled>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator=(const ShProgram& prg)
{
  ParentType::operator=(prg);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator++()
{
  ParentType::operator++();
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator--()
{
  ParentType::operator--();
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator+=(const ShGeneric<N, T2>& right)
{
  ParentType::operator+=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator-=(const ShGeneric<N, T2>& right)
{
  ParentType::operator-=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator*=(const ShGeneric<N, T2>& right)
{
  ParentType::operator*=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator/=(const ShGeneric<N, T2>& right)
{
  ParentType::operator/=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator%=(const ShGeneric<N, T2>& right)
{
  ParentType::operator%=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator+=(host_type right)
{
  ParentType::operator+=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator-=(host_type right)
{
  ParentType::operator-=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator*=(host_type right)
{
  ParentType::operator*=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator/=(host_type right)
{
  ParentType::operator/=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator%=(host_type right)
{
  ParentType::operator%=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator+=(const ShGeneric<1, T2>& right)
{
  ParentType::operator+=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator-=(const ShGeneric<1, T2>& right)
{
  ParentType::operator-=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator*=(const ShGeneric<1, T2>& right)
{
  ParentType::operator*=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator/=(const ShGeneric<1, T2>& right)
{
  ParentType::operator/=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<N, Binding, T, Semantic, Swizzled>&
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator%=(const ShGeneric<1, T2>& right)
{
  ParentType::operator%=(right);
  return *this;
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, true>
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator()(int s0) const
{
  return ShAttrib<1, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(N, s0), this->m_neg);
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, true>
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1) const
{
  return ShAttrib<2, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(N, s0, s1), this->m_neg);
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, true>
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1, int s2) const
{
  return ShAttrib<3, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(N, s0, s1, s2), this->m_neg);
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, true>
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1, int s2, int s3) const
{
  return ShAttrib<4, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(N, s0, s1, s2, s3), this->m_neg);
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<int N2>
ShAttrib<N2, Binding, T, Semantic, true>
ShAttrib<N, Binding, T, Semantic, Swizzled>::swiz(int indices[]) const
{
  return ShAttrib<N2, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(N, N2, indices), this->m_neg);
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, true>
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator[](int s0) const
{
  return ShAttrib<1, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(N, s0), this->m_neg);
}

template<int N, ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>
ShAttrib<N, Binding, T, Semantic, Swizzled>::operator-() const
{
  return ShAttrib<N, Binding, T, Semantic, Swizzled>(this->m_node, this->m_swizzle, !this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>::ShAttrib()
  : ShGeneric<1, T>(new ShVariableNode(Binding, 1, ShStorageTypeInfo<T>::value_type, Semantic))
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<1, Binding, T, Semantic, Swizzled>::ShAttrib(const ShGeneric<1, T2>& other)
  : ShGeneric<1, T>(new ShVariableNode(Binding, 1, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>::ShAttrib(const ShAttrib<1, Binding, T, Semantic, Swizzled>& other)
  : ShGeneric<1, T>(new ShVariableNode(Binding, 1, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<1, Binding, T, Semantic, Swizzled>::ShAttrib(const ShAttrib<1, Binding, T2, Semantic, Swizzled>& other)
  : ShGeneric<1, T>(new ShVariableNode(Binding, 1, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>::ShAttrib(const ShVariableNodePtr& node,
  const ShSwizzle& swizzle, bool neg)
  : ShGeneric<1, T>(node, swizzle, neg)
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>::ShAttrib(host_type data[1])
  : ShGeneric<1, T>(new ShVariableNode(Binding, 1, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    for (int i = 0; i < 1; i++) setValue(i, data[i]);
  } else {
    (*this) = ShAttrib<1, SH_CONST, T, Semantic>(data);
  }
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>::ShAttrib(host_type s0)
  : ShGeneric<1, T>(new ShVariableNode(Binding, 1, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    setValue(0, s0);
  } else {
    (*this) = ShAttrib<1, SH_CONST, T, Semantic>(s0);
  }
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>::~ShAttrib()
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator=(const ShGeneric<1, T2>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator=(const ShAttrib<1, Binding, T, Semantic, Swizzled>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator=(const ShAttrib<1, Binding, T2, Semantic, Swizzled>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator=(host_type other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator=(const ShProgram& prg)
{
  ParentType::operator=(prg);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator++()
{
  ParentType::operator++();
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator--()
{
  ParentType::operator--();
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator+=(const ShGeneric<1, T2>& right)
{
  ParentType::operator+=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator-=(const ShGeneric<1, T2>& right)
{
  ParentType::operator-=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator*=(const ShGeneric<1, T2>& right)
{
  ParentType::operator*=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator/=(const ShGeneric<1, T2>& right)
{
  ParentType::operator/=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator%=(const ShGeneric<1, T2>& right)
{
  ParentType::operator%=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator+=(host_type right)
{
  ParentType::operator+=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator-=(host_type right)
{
  ParentType::operator-=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator*=(host_type right)
{
  ParentType::operator*=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator/=(host_type right)
{
  ParentType::operator/=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>&
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator%=(host_type right)
{
  ParentType::operator%=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, true>
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator()(int s0) const
{
  return ShAttrib<1, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(1, s0), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, true>
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1) const
{
  return ShAttrib<2, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(1, s0, s1), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, true>
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1, int s2) const
{
  return ShAttrib<3, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(1, s0, s1, s2), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, true>
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1, int s2, int s3) const
{
  return ShAttrib<4, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(1, s0, s1, s2, s3), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<int N2>
ShAttrib<N2, Binding, T, Semantic, true>
ShAttrib<1, Binding, T, Semantic, Swizzled>::swiz(int indices[]) const
{
  return ShAttrib<N2, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(1, N2, indices), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, true>
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator[](int s0) const
{
  return ShAttrib<1, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(1, s0), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>
ShAttrib<1, Binding, T, Semantic, Swizzled>::operator-() const
{
  return ShAttrib<1, Binding, T, Semantic, Swizzled>(this->m_node, this->m_swizzle, !this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>::ShAttrib()
  : ShGeneric<2, T>(new ShVariableNode(Binding, 2, ShStorageTypeInfo<T>::value_type, Semantic))
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>::ShAttrib(const ShGeneric<2, T2>& other)
  : ShGeneric<2, T>(new ShVariableNode(Binding, 2, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>::ShAttrib(const ShAttrib<2, Binding, T, Semantic, Swizzled>& other)
  : ShGeneric<2, T>(new ShVariableNode(Binding, 2, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>::ShAttrib(const ShAttrib<2, Binding, T2, Semantic, Swizzled>& other)
  : ShGeneric<2, T>(new ShVariableNode(Binding, 2, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>::ShAttrib(const ShVariableNodePtr& node,
  const ShSwizzle& swizzle, bool neg)
  : ShGeneric<2, T>(node, swizzle, neg)
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>::ShAttrib(host_type data[2])
  : ShGeneric<2, T>(new ShVariableNode(Binding, 2, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    for (int i = 0; i < 2; i++) setValue(i, data[i]);
  } else {
    (*this) = ShAttrib<2, SH_CONST, T, Semantic>(data);
  }
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>::ShAttrib(host_type s0, host_type s1)
  : ShGeneric<2, T>(new ShVariableNode(Binding, 2, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    host_type data[2] = {s0, s1};
    setValues(data);
  } else {
    (*this) = ShAttrib<2, SH_CONST, T, Semantic>(s0, s1);
  }
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2, typename T3>
ShAttrib<2, Binding, T, Semantic, Swizzled>::ShAttrib(const ShGeneric<1, T2>& s0, const ShGeneric<1, T3>& s1)
  : ShGeneric<2, T>(new ShVariableNode(Binding, 2, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    SH_DEBUG_ASSERT(s0.hasValues());
    SH_DEBUG_ASSERT(s1.hasValues());
    host_type data[2] = {s0.getValue(0), s1.getValue(0)};
    setValues(data);
  } else {
    (*this)[0] = s0;
    (*this)[1] = s1;
  }
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>::~ShAttrib()
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator=(const ShGeneric<2, T2>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator=(const ShAttrib<2, Binding, T, Semantic, Swizzled>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator=(const ShAttrib<2, Binding, T2, Semantic, Swizzled>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator=(const ShProgram& prg)
{
  ParentType::operator=(prg);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator++()
{
  ParentType::operator++();
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator--()
{
  ParentType::operator--();
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator+=(const ShGeneric<2, T2>& right)
{
  ParentType::operator+=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator-=(const ShGeneric<2, T2>& right)
{
  ParentType::operator-=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator*=(const ShGeneric<2, T2>& right)
{
  ParentType::operator*=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator/=(const ShGeneric<2, T2>& right)
{
  ParentType::operator/=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator%=(const ShGeneric<2, T2>& right)
{
  ParentType::operator%=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator+=(host_type right)
{
  ParentType::operator+=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator-=(host_type right)
{
  ParentType::operator-=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator*=(host_type right)
{
  ParentType::operator*=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator/=(host_type right)
{
  ParentType::operator/=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator%=(host_type right)
{
  ParentType::operator%=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator+=(const ShGeneric<1, T2>& right)
{
  ParentType::operator+=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator-=(const ShGeneric<1, T2>& right)
{
  ParentType::operator-=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator*=(const ShGeneric<1, T2>& right)
{
  ParentType::operator*=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator/=(const ShGeneric<1, T2>& right)
{
  ParentType::operator/=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<2, Binding, T, Semantic, Swizzled>&
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator%=(const ShGeneric<1, T2>& right)
{
  ParentType::operator%=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, true>
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator()(int s0) const
{
  return ShAttrib<1, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(2, s0), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, true>
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1) const
{
  return ShAttrib<2, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(2, s0, s1), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, true>
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1, int s2) const
{
  return ShAttrib<3, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(2, s0, s1, s2), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, true>
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1, int s2, int s3) const
{
  return ShAttrib<4, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(2, s0, s1, s2, s3), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<int N2>
ShAttrib<N2, Binding, T, Semantic, true>
ShAttrib<2, Binding, T, Semantic, Swizzled>::swiz(int indices[]) const
{
  return ShAttrib<N2, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(2, N2, indices), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, true>
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator[](int s0) const
{
  return ShAttrib<1, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(2, s0), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>
ShAttrib<2, Binding, T, Semantic, Swizzled>::operator-() const
{
  return ShAttrib<2, Binding, T, Semantic, Swizzled>(this->m_node, this->m_swizzle, !this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>::ShAttrib()
  : ShGeneric<3, T>(new ShVariableNode(Binding, 3, ShStorageTypeInfo<T>::value_type, Semantic))
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>::ShAttrib(const ShGeneric<3, T2>& other)
  : ShGeneric<3, T>(new ShVariableNode(Binding, 3, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>::ShAttrib(const ShAttrib<3, Binding, T, Semantic, Swizzled>& other)
  : ShGeneric<3, T>(new ShVariableNode(Binding, 3, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>::ShAttrib(const ShAttrib<3, Binding, T2, Semantic, Swizzled>& other)
  : ShGeneric<3, T>(new ShVariableNode(Binding, 3, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>::ShAttrib(const ShVariableNodePtr& node,
  const ShSwizzle& swizzle, bool neg)
  : ShGeneric<3, T>(node, swizzle, neg)
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>::ShAttrib(host_type data[3])
  : ShGeneric<3, T>(new ShVariableNode(Binding, 3, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    for (int i = 0; i < 3; i++) setValue(i, data[i]);
  } else {
    (*this) = ShAttrib<3, SH_CONST, T, Semantic>(data);
  }
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>::ShAttrib(host_type s0, host_type s1, host_type s2)
  : ShGeneric<3, T>(new ShVariableNode(Binding, 3, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    host_type data[3] = {s0, s1, s2};
    setValues(data);
  } else {
    (*this) = ShAttrib<3, SH_CONST, T, Semantic>(s0, s1, s2);
  }
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2, typename T3, typename T4>
ShAttrib<3, Binding, T, Semantic, Swizzled>::ShAttrib(const ShGeneric<1, T2>& s0, const ShGeneric<1, T3>& s1, const ShGeneric<1, T4>& s2)
  : ShGeneric<3, T>(new ShVariableNode(Binding, 3, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    SH_DEBUG_ASSERT(s0.hasValues());
    SH_DEBUG_ASSERT(s1.hasValues());
    SH_DEBUG_ASSERT(s2.hasValues());
    host_type data[3] = {s0.getValue(0), s1.getValue(0), s2.getValue(0)};
    setValues(data);
  } else {
    (*this)[0] = s0;
    (*this)[1] = s1;
    (*this)[2] = s2;
  }
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>::~ShAttrib()
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator=(const ShGeneric<3, T2>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator=(const ShAttrib<3, Binding, T, Semantic, Swizzled>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator=(const ShAttrib<3, Binding, T2, Semantic, Swizzled>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator=(const ShProgram& prg)
{
  ParentType::operator=(prg);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator++()
{
  ParentType::operator++();
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator--()
{
  ParentType::operator--();
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator+=(const ShGeneric<3, T2>& right)
{
  ParentType::operator+=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator-=(const ShGeneric<3, T2>& right)
{
  ParentType::operator-=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator*=(const ShGeneric<3, T2>& right)
{
  ParentType::operator*=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator/=(const ShGeneric<3, T2>& right)
{
  ParentType::operator/=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator%=(const ShGeneric<3, T2>& right)
{
  ParentType::operator%=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator+=(host_type right)
{
  ParentType::operator+=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator-=(host_type right)
{
  ParentType::operator-=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator*=(host_type right)
{
  ParentType::operator*=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator/=(host_type right)
{
  ParentType::operator/=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator%=(host_type right)
{
  ParentType::operator%=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator+=(const ShGeneric<1, T2>& right)
{
  ParentType::operator+=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator-=(const ShGeneric<1, T2>& right)
{
  ParentType::operator-=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator*=(const ShGeneric<1, T2>& right)
{
  ParentType::operator*=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator/=(const ShGeneric<1, T2>& right)
{
  ParentType::operator/=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<3, Binding, T, Semantic, Swizzled>&
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator%=(const ShGeneric<1, T2>& right)
{
  ParentType::operator%=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, true>
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator()(int s0) const
{
  return ShAttrib<1, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(3, s0), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, true>
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1) const
{
  return ShAttrib<2, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(3, s0, s1), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, true>
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1, int s2) const
{
  return ShAttrib<3, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(3, s0, s1, s2), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, true>
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1, int s2, int s3) const
{
  return ShAttrib<4, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(3, s0, s1, s2, s3), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<int N2>
ShAttrib<N2, Binding, T, Semantic, true>
ShAttrib<3, Binding, T, Semantic, Swizzled>::swiz(int indices[]) const
{
  return ShAttrib<N2, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(3, N2, indices), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, true>
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator[](int s0) const
{
  return ShAttrib<1, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(3, s0), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>
ShAttrib<3, Binding, T, Semantic, Swizzled>::operator-() const
{
  return ShAttrib<3, Binding, T, Semantic, Swizzled>(this->m_node, this->m_swizzle, !this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>::ShAttrib()
  : ShGeneric<4, T>(new ShVariableNode(Binding, 4, ShStorageTypeInfo<T>::value_type, Semantic))
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>::ShAttrib(const ShGeneric<4, T2>& other)
  : ShGeneric<4, T>(new ShVariableNode(Binding, 4, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>::ShAttrib(const ShAttrib<4, Binding, T, Semantic, Swizzled>& other)
  : ShGeneric<4, T>(new ShVariableNode(Binding, 4, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>::ShAttrib(const ShAttrib<4, Binding, T2, Semantic, Swizzled>& other)
  : ShGeneric<4, T>(new ShVariableNode(Binding, 4, ShStorageTypeInfo<T>::value_type, Semantic))
{
  shASN(*this, other);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>::ShAttrib(const ShVariableNodePtr& node,
  const ShSwizzle& swizzle, bool neg)
  : ShGeneric<4, T>(node, swizzle, neg)
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>::ShAttrib(host_type data[4])
  : ShGeneric<4, T>(new ShVariableNode(Binding, 4, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    for (int i = 0; i < 4; i++) setValue(i, data[i]);
  } else {
    (*this) = ShAttrib<4, SH_CONST, T, Semantic>(data);
  }
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>::ShAttrib(host_type s0, host_type s1, host_type s2, host_type s3)
  : ShGeneric<4, T>(new ShVariableNode(Binding, 4, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    host_type data[4] = {s0, s1, s2, s3};
    setValues(data);
  } else {
    (*this) = ShAttrib<4, SH_CONST, T, Semantic>(s0, s1, s2, s3);
  }
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2, typename T3, typename T4, typename T5>
ShAttrib<4, Binding, T, Semantic, Swizzled>::ShAttrib(const ShGeneric<1, T2>& s0, const ShGeneric<1, T3>& s1, const ShGeneric<1, T4>& s2, const ShGeneric<1, T5>& s3)
  : ShGeneric<4, T>(new ShVariableNode(Binding, 4, ShStorageTypeInfo<T>::value_type, Semantic))
{
  if (Binding == SH_CONST) {
    SH_DEBUG_ASSERT(s0.hasValues());
    SH_DEBUG_ASSERT(s1.hasValues());
    SH_DEBUG_ASSERT(s2.hasValues());
    SH_DEBUG_ASSERT(s3.hasValues());
    host_type data[4] = {s0.getValue(0), s1.getValue(0), s2.getValue(0), s3.getValue(0)};
    setValues(data);
  } else {
    (*this)[0] = s0;
    (*this)[1] = s1;
    (*this)[2] = s2;
    (*this)[3] = s3;
  }
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>::~ShAttrib()
{
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator=(const ShGeneric<4, T2>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator=(const ShAttrib<4, Binding, T, Semantic, Swizzled>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator=(const ShAttrib<4, Binding, T2, Semantic, Swizzled>& other)
{
  ParentType::operator=(other);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator=(const ShProgram& prg)
{
  ParentType::operator=(prg);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator++()
{
  ParentType::operator++();
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator--()
{
  ParentType::operator--();
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator+=(const ShGeneric<4, T2>& right)
{
  ParentType::operator+=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator-=(const ShGeneric<4, T2>& right)
{
  ParentType::operator-=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator*=(const ShGeneric<4, T2>& right)
{
  ParentType::operator*=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator/=(const ShGeneric<4, T2>& right)
{
  ParentType::operator/=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator%=(const ShGeneric<4, T2>& right)
{
  ParentType::operator%=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator+=(host_type right)
{
  ParentType::operator+=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator-=(host_type right)
{
  ParentType::operator-=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator*=(host_type right)
{
  ParentType::operator*=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator/=(host_type right)
{
  ParentType::operator/=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator%=(host_type right)
{
  ParentType::operator%=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator+=(const ShGeneric<1, T2>& right)
{
  ParentType::operator+=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator-=(const ShGeneric<1, T2>& right)
{
  ParentType::operator-=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator*=(const ShGeneric<1, T2>& right)
{
  ParentType::operator*=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator/=(const ShGeneric<1, T2>& right)
{
  ParentType::operator/=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<typename T2>
ShAttrib<4, Binding, T, Semantic, Swizzled>&
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator%=(const ShGeneric<1, T2>& right)
{
  ParentType::operator%=(right);
  return *this;
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, true>
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator()(int s0) const
{
  return ShAttrib<1, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(4, s0), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<2, Binding, T, Semantic, true>
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1) const
{
  return ShAttrib<2, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(4, s0, s1), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<3, Binding, T, Semantic, true>
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1, int s2) const
{
  return ShAttrib<3, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(4, s0, s1, s2), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, true>
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator()(int s0, int s1, int s2, int s3) const
{
  return ShAttrib<4, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(4, s0, s1, s2, s3), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
template<int N2>
ShAttrib<N2, Binding, T, Semantic, true>
ShAttrib<4, Binding, T, Semantic, Swizzled>::swiz(int indices[]) const
{
  return ShAttrib<N2, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(4, N2, indices), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<1, Binding, T, Semantic, true>
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator[](int s0) const
{
  return ShAttrib<1, Binding, T, Semantic, true>(this->m_node, this->m_swizzle * ShSwizzle(4, s0), this->m_neg);
}

template<ShBindingType Binding, typename T, ShSemanticType Semantic, bool Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>
ShAttrib<4, Binding, T, Semantic, Swizzled>::operator-() const
{
  return ShAttrib<4, Binding, T, Semantic, Swizzled>(this->m_node, this->m_swizzle, !this->m_neg);
}


} // namespace SH

#endif // SH_SHATTRIBIMPL_HPP

---