---

hybridchannel.cpp

/**********************************************************************************
* Copyright (c) 2003, Christoph Rueegg <opendev@cdrnet.ch> and Matthias Bader     *
* Partially based on ideas of Tim Weyrich <weyrich@inf.ethz.ch>                   *
* and/or the Swiss Federal Institute of Technology http://www.ethz.ch             *
* All rights reserved.                                                            *
*                                                                                 *
* Project Website: http://www.cdrnet.net/projects/painter/                        *
*                                                                                 *
* Redistribution and use in source and binary forms, with or without modification,*
* are permitted provided that the following conditions are met:                   *
*                                                                                 *
* 1. Redistributions of source code must retain the above copyright notice,       *
* this list of conditions and the following disclaimer.                           *
*                                                                                 *
* 2. Redistributions in binary form must reproduce the above copyright notice,    *
* this list of conditions and the following disclaimer in the documentation       *
* and/or other materials provided with the distribution.                          *
*                                                                                 *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"     *
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE       *
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE      *
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE        *
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR             *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF            *
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS        *
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN         *
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)         *
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF          *
* THE POSSIBILITY OF SUCH DAMAGE.                                                 *
**********************************************************************************/

#ifndef __HYBRIDCHANNEL_GNX__
#define __HYBRIDCHANNEL_GNX__

#include "channel.cpp"

template<class T>
struct RgbaPixel
{
  T r;   // red value
  T g;   // green value
  T b;   // blue value
  T a;   // alpha value (not used -> alpha channel)
};


template<class T>
class HybridRgbaChannel : public Channel<T>
{
private:
  RgbaPixel<T> *data;
public:
  HybridRgbaChannel(const int height, const int width);
  HybridRgbaChannel();
  virtual ~HybridRgbaChannel();
  virtual inline T Get(const int x, const int y);
  virtual inline void Set(const int x, const int y, const T val);
  virtual RgbaPixel<T>** GetRawRgbData(); //workaround
  Channel<T>* EmptyClone();
  virtual void Normalize(int* x, int* y);
  virtual void Normalize(int* topleftx, int* toplefty, int* bottomrightx, int* bottomrighty);
};

template<class T>
HybridRgbaChannel<T>::HybridRgbaChannel(const int height, const int width) : Channel<T>()
{
  data = new RgbaPixel<T>[width*height];
  for(int i = 0;i<width*height;i++)
  {
    data[i].r = 20;
    data[i].g = 40;
    data[i].b = 60;
    data[i].a = 100;
  }
  //data = new RgbaPixel<T>[width*height];
  this->width = width;
  this->height = height;
}

template<class T>
HybridRgbaChannel<T>::HybridRgbaChannel() : Channel<T>()
{
  data = 0;
}

template<class T>
HybridRgbaChannel<T>::~HybridRgbaChannel()
{
  if(data != 0 && GetId() == 1) //avoid undefined behavior (=crash) on multideletion (shared data hack)
    delete [] data;
}

template<class T>
inline T HybridRgbaChannel<T>::Get(const int x, const int y)
{
  switch(GetId())
  {
    case 1:  // Red
      return(data[x+y*GetWidth()].r);
    case 2:  //Green
      return(data[x+y*GetWidth()].g);
    case 3:  //Blue
      return(data[x+y*GetWidth()].b);
    default:
      return(data[x+y*GetWidth()].a);
  }
}

template<class T>
inline void HybridRgbaChannel<T>::Set(const int x, const int y, const T val)
{
  switch(GetId())
  {
    case 1:  //Red
      data[x+y*GetWidth()].r = val;
      break;
    case 2:  //Green
      data[x+y*GetWidth()].g = val;
      break;
    case 3:  //Blue
      data[x+y*GetWidth()].b = val;
      break;
  }
}

//RgbaPixel<T>** HybridRgbaChannel<T>::GetRawData()
template<class T>
RgbaPixel<T>** HybridRgbaChannel<T>::GetRawRgbData()
{
  return(&data);
}

template<class T>
Channel<T>* HybridRgbaChannel<T>::EmptyClone()
{
  HybridRgbaChannel<T> *copy = new HybridRgbaChannel<T>(height, width);
  *(copy->GetRawRgbData()) = data;
  return(copy);
}

template<class T>
void HybridRgbaChannel<T>::Normalize(int* x, int* y)
{
  if(*x<0)
    *x = 0;
  if(*y<0)
    *y = 0;
  if(*x >= GetWidth())
    *x = GetWidth();
  if(*y >= GetHeight())
    *y = GetHeight();
}

template<class T>
void HybridRgbaChannel<T>::Normalize(int* topleftx, int* toplefty, int* bottomrightx, int* bottomrighty)
{
  int temp;
  Normalize(topleftx,toplefty);
  Normalize(bottomrightx,bottomrighty);
  if(*topleftx > *bottomrightx)
  {
    temp = *topleftx;
    *topleftx = *bottomrightx;
    *bottomrightx = temp;
  }
  if(*toplefty > *bottomrighty)
  {
    temp = *toplefty;
    *toplefty = *bottomrighty;
    *bottomrighty = temp;
  }
}

#endif

---