ShManipulator.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 SHMANIPULATOR_HPP
#define SHMANIPULATOR_HPP

#include "ShProgram.hpp"
#include <vector>
#include <string>
#include <sstream>

namespace SH {

template<typename T> 
struct storage_trait {
  typedef T StorageType;
};

template<>
struct storage_trait<const char*> {
  typedef std::string StorageType; 
};

enum OffsetRangeErrors {
  OFFSET_RANGE_BAD_OFFSET = -1,
  OFFSET_RANGE_BAD_INDEX = -2
};

template<typename T>
class OffsetRange {
  public:
    OffsetRange(); 
    OffsetRange( T start, T end );
    OffsetRange( T start, int startOffset, T end, int endOffset );

    int absStartIndex( const ShProgramNode::VarList vars ) const; 
    int absEndIndex( const ShProgramNode::VarList vars ) const; 

    std::string toString() const; 

  private:
    T start, end;
    int startOffset, endOffset;
    int absIndex( T index, int offset, const ShProgramNode::VarList &vars ) const;
};


template<typename T>
class ShManipulator {
  public:
    typedef typename storage_trait<T>::StorageType StorageType;
    typedef OffsetRange<StorageType> IndexRange;
    typedef std::vector<IndexRange> IndexRangeVector;

    ShManipulator();
    ~ShManipulator();

    ShManipulator<T>& operator()(T i);
    ShManipulator<T>& operator()(T start, T end);
    ShManipulator<T>& operator()(const IndexRange &range); 

    // converts ranges to a sequence of integer ranges using given var list 
    IndexRangeVector getRanges() const; 

    // converts to string for debugging/error messages
    std::string toString() const;
    
  protected:
    IndexRangeVector m_ranges; 

    // converts indices to positive integer indices. 
    // If it cannot be found, raises AlgebraException.
    // if the index has an offset that makes it invalid, then valid is set to false
    OffsetRange<int> convertRange(IndexRange range, const ShProgramNode::VarList &v) const;
};

template<typename T>
ShProgram operator<<(const ShProgram &p, const ShManipulator<T> &m); 

template<typename T>
ShProgram operator<<(const ShManipulator<T> &m, const ShProgram &p);


// shader outputs based on given indices
//
template<typename T>
ShManipulator<T> shSwizzle(T i0);

template<typename T>
ShManipulator<T> shSwizzle(T i0, T i1);

template<typename T>
ShManipulator<T> shSwizzle(T i0, T i1, T i2);

template<typename T>
ShManipulator<T> shSwizzle(T i0, T i1, T i2, T i3);

template<typename T>
ShManipulator<T> shSwizzle(T i0, T i1, T i2, T i3, T i4);

template<typename T>
ShManipulator<T> shSwizzle(T i0, T i1, T i2, T i3, T i4, T i5);

template<typename T>
ShManipulator<T> shSwizzle(T i0, T i1, T i2, T i3, T i4, T i5, T i6);

template<typename T>
ShManipulator<T> shSwizzle(T i0, T i1, T i2, T i3, T i4, T i5, T i6, T i7);

template<typename T>
ShManipulator<T> shSwizzle(T i0, T i1, T i2, T i3, T i4, T i5, T i6, T i7, T i8);

template<typename T>
ShManipulator<T> shSwizzle(T i0, T i1, T i2, T i3, T i4, T i5, T i6, T i7, T i8, T i9);

template<typename T>
ShManipulator<T> shSwizzle(std::vector<T> indices);

// outputs based on given indices
template<typename T>
ShManipulator<T> shRange(T i);

template<typename T>
ShManipulator<T> shRange(T start, T end);

template<typename T>
ShManipulator<T> shExtract(T k); 

template<typename T>
ShManipulator<T> shInsert(T k); 

template<typename T>
ShManipulator<T> shDrop(T k);

typedef ShManipulator<int> ShPositionManipulator;
typedef ShManipulator<char*> ShNameManipulator;

}

#include "ShManipulatorImpl.hpp"

#endif

---