#pragma once

#include "tpixelutils.h"

namespace {

enum { SUBSTITUTE, PATTERNTYPE, ADD, SUBTRACT, MULTIPLY, LIGHTEN, DARKEN };

typedef void (*func32)(TPixel32 &pixmask, const TPixel32 &pixtext, double v);

typedef void (*func64)(TPixel64 &pixmask, const TPixel64 &pixtext, double v);

//=======================================================================================

//  Pixel operations

//-----------------------------------------------------------------------------

//! Make \b pixout completely opaque if \b pixcomp is not fully transparent.

//! This helps

//! in avoiding antialias merge problems when overing palette filtered masks

//! with their

//! inverses.

template <class t=""></class>

inline void makeOpaque(T &pixout, const T &pixcomp, double v) {

  if (pixcomp.m > 0) {

    double k = T::maxChannelValue / (double)pixout.m;

    pixout.r = troundp(k * pixout.r);

    pixout.g = troundp(k * pixout.g);

    pixout.b = troundp(k * pixout.b);

    pixout.m = T::maxChannelValue;

  }

}

//---------------------------------------------------------------------------------------

//! Copies \b pixin into \b pixout - while matte components are multiplied.

template <class t=""></class>

inline void substitute(T &pixout, const T &pixin, double v) {

  double k = pixout.m / (double)T::maxChannelValue;

  pixout.r = k * pixin.r;

  pixout.g = k * pixin.g;

  pixout.b = k * pixin.b;

  pixout.m = k * pixin.m;

}

//---------------------------------------------------------------------------------------

//! Decrease \b pixout's rgb colors proportionally to \b pixin's value. The

//! matte channel

//! is kept unaltered.

inline void pattern32(TPixel32 &pixout, const TPixel32 &pixin, double v) {

  double val = TPixelGR8::from(pixin).value / 255.0;

  pixout.r   = troundp(val * pixout.r);

  pixout.g   = troundp(val * pixout.g);

  pixout.b   = troundp(val * pixout.b);

}

inline void pattern64(TPixel64 &pixout, const TPixel64 &pixin, double v) {

  double val = TPixelGR16::from(pixin).value / 65535.0;

  pixout.r   = troundp(val * pixout.r);

  pixout.g   = troundp(val * pixout.g);

  pixout.b   = troundp(val * pixout.b);

}

//---------------------------------------------------------------------------------------

template <class t=""></class>

void textureAdd(T &pixout, const T &pixin, double v) {

  if (pixin.m > 0) {

    TINT32 pixoutm = pixout.m;

    double k = T::maxChannelValue / (double)pixoutm;

    pixout.r = pixout.r * k;

    pixout.g = pixout.g * k;

    pixout.b = pixout.b * k;

    pixout.m = T::maxChannelValue;

    add(pixout, pixin, v);

    k        = pixoutm / (double)T::maxChannelValue;

    pixout.r = pixout.r * k;

    pixout.g = pixout.g * k;

    pixout.b = pixout.b * k;

    pixout.m = pixoutm;

  }

}

//---------------------------------------------------------------------------------------

template <class t=""></class>

void textureSub(T &pixout, const T &pixin, double v) {

  if (pixin.m > 0) {

    TINT32 pixoutm = pixout.m;

    double k = T::maxChannelValue / (double)pixoutm;

    pixout.r = pixout.r * k;

    pixout.g = pixout.g * k;

    pixout.b = pixout.b * k;

    pixout.m = T::maxChannelValue;

    sub(pixout, pixin, v);

    k        = pixoutm / (double)T::maxChannelValue;

    pixout.r = pixout.r * k;

    pixout.g = pixout.g * k;

    pixout.b = pixout.b * k;

    pixout.m = pixoutm;

  }

}

//---------------------------------------------------------------------------------------

template <class t=""></class>

void textureMult(T &pixout, const T &pixin, double v) {

  TINT32 pixoutm = pixout.m;

  double k = T::maxChannelValue / (double)pixoutm;

  pixout.r = pixout.r * k;

  pixout.g = pixout.g * k;

  pixout.b = pixout.b * k;

  pixout.m = T::maxChannelValue;

  mult(pixout, pixin, v);

  k        = pixoutm / (double)T::maxChannelValue;

  pixout.r = pixout.r * k;

  pixout.g = pixout.g * k;

  pixout.b = pixout.b * k;

  pixout.m = pixoutm;

}

//---------------------------------------------------------------------------------------

template <class t=""></class>

void textureLighten(T &pixout, const T &pixin, double v) {

  TINT32 pixoutm = pixout.m;

  double k = T::maxChannelValue / (double)pixoutm;

  pixout.r = pixout.r * k;

  pixout.g = pixout.g * k;

  pixout.b = pixout.b * k;

  pixout.m = T::maxChannelValue;

  lighten(pixout, pixin, v);

  k        = pixoutm / (double)T::maxChannelValue;

  pixout.r = pixout.r * k;

  pixout.g = pixout.g * k;

  pixout.b = pixout.b * k;

  pixout.m = pixoutm;

}

//---------------------------------------------------------------------------------------

template <class t=""></class>

void textureDarken(T &pixout, const T &pixin, double v) {

  TINT32 pixoutm = pixout.m;

  double k = T::maxChannelValue / (double)pixoutm;

  pixout.r = pixout.r * k;

  pixout.g = pixout.g * k;

  pixout.b = pixout.b * k;

  pixout.m = T::maxChannelValue;

  darken(pixout, pixin, v);

  k        = pixoutm / (double)T::maxChannelValue;

  pixout.r = pixout.r * k;

  pixout.g = pixout.g * k;

  pixout.b = pixout.b * k;

  pixout.m = pixoutm;

}

//=======================================================================================

void myOver32(const TRaster32P &rasOut, const TRasterP &rasUp, func32 func,

              double v) {

  assert(rasOut->getSize() == rasUp->getSize());

  TRaster32P rasUp32 = rasUp;

  assert(rasUp32);

  for (int y = rasOut->getLy(); --y >= 0;) {

    TPixel32 *out_pix       = rasOut->pixels(y);

    TPixel32 *const out_end = out_pix + rasOut->getLx();

    const TPixel32 *up_pix  = rasUp32->pixels(y);

    for (; out_pix < out_end; ++out_pix, ++up_pix) {

      if (out_pix->m > 0) (*func)(*out_pix, *up_pix, v);

    }

  }

}

void myOver64(const TRaster64P &rasOut, const TRasterP &rasUp, func64 func,

              double v) {

  assert(rasOut->getSize() == rasUp->getSize());

  TRaster64P rasUp64 = rasUp;

  assert(rasUp64);

  for (int y = rasOut->getLy(); --y >= 0;) {

    TPixel64 *out_pix       = rasOut->pixels(y);

    TPixel64 *const out_end = out_pix + rasOut->getLx();

    const TPixel64 *up_pix  = rasUp64->pixels(y);

    for (; out_pix < out_end; ++out_pix, ++up_pix) {

      if (out_pix->m > 0) (*func)(*out_pix, *up_pix, v);

    }

  }

}

}