---

/home/landauf/painter/miniproject/effects/geometric.cpp

Go to the documentation of this file.

#include "geometric.h"

// Ripple                                                                    //
ripple::ripple(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    glutSetWindowTitle("Paint Application | Ripple");

    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);

    imageRgbaCopy(img, temp);
    
    numModes = 4;
    value2 = 10; // strength
    limitValue2.set(1, 50);
    value1 = 5; // length
    limitValue1.set(1, 50);
    refresh = false;
    interpolate = false;
    inActionState = false;
    
    this->changeMode(1);
}

void ripple::idleAction()
{
    const int w = img->width;
    const int h = img->height;
    float newX, newY;
    if ((LBpressed || refresh) && mouse.x >= 0 && mouse.y >= 0 && mouse.x <= w && mouse.y <= h)
    {
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                if (mode == 1)
                {
                    newX = x + value2 * sin(sqrt((x - mouse.x)*(x - mouse.x) + (y - mouse.y)*(y - mouse.y)) / value1);
                    newY = y + value2 * sin(sqrt((x - mouse.x)*(x - mouse.x) + (y - mouse.y)*(y - mouse.y)) / value1);
                }
                else if (mode == 2)
                {
                    newX = x + value2 * sin((x - mouse.x) / value1);
                    newY = y;
                }
                else if (mode == 3)
                {
                    newX = x;
                    newY = y + value2 * sin((y - mouse.y) / value1);
                }
                else if (mode == 4)
                {
                    newX = x + value2 * sin((x - mouse.x) / value1);
                    newY = y + value2 * sin((y - mouse.y) / value1);
                }

                if (newX < lowArea.x)
                    newX = lowArea.x;
                if (newY < lowArea.y)
                    newY = lowArea.y;
                if (newX > highArea.x)
                    newX = highArea.x;
                if (newY > highArea.y)
                    newY = highArea.y;
                    
                if (interpolate)
                    img->data[int(x + w*y)] = imageRgbaInterpolate(temp, newX, newY);
                else
                    img->data[int(x + w*y)] = temp->data[int(newX) + w*int(newY)];

//                img->data[int(x + w*y)] = temp->data[int(1.0*x/w/2.0+0.5+1)+w*int(1.0*y/w/2.0+0.5)];
//                img->data[int(x + w*y)] = imageRgbaInterpolate(temp, 1+1.0*x/w, 1.0*y/w);
            }
        }
        refresh = false;
    }
}

void ripple::keyRIGHT()
{
    value1 += 1;
    if (value1 >= limitValue1.high)
        value1 = limitValue1.high;
}

void ripple::keyLEFT()
{
    value1 -= 1;
    if (value1 <= limitValue1.low)
        value1 = limitValue1.low;    
}

void ripple::keyUP()
{
    value2 += 2;
    if (value2 > limitValue2.high)
        value2 = limitValue2.high;
}

void ripple::keyDOWN()
{
    value2 -= 2;
    if (value2 < limitValue2.low)
        value2 = limitValue2.low;
}

void ripple::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Ripple | Mode 1: Radial");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Ripple | Mode 2: Vertical");
    else if (mode == 3)
        glutSetWindowTitle("Paint Application | Ripple | Mode 3: Horizontal");
    else if (mode == 4)
        glutSetWindowTitle("Paint Application | Ripple | Mode 4: Crossed");
        
    if (!LBpressed)
    {
        LBpressed = true;
        this->idleAction();
        LBpressed = false;
    }
    else
        this->idleAction();
}
        

// Bubble                                                                    //
bubble::bubble(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    glutSetWindowTitle("Paint Application | Bubble");

    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);

    imageRgbaCopy(img, temp);
    
    numModes = 4;
    value2 = 25; // strength
    limitValue2.set(1, 250);
    value1 = 100; // length
    limitValue1.set(10, 1000);
    refresh = false;
    interpolate = false;
    inActionState = false;
    
    this->changeMode(1);
}

void bubble::idleAction()
{
    const int w = img->width;
    const int h = img->height;
    float newX, newY, distance, factor;
    if ((LBpressed || refresh) && mouse.x >= 0 && mouse.y >= 0 && mouse.x <= w && mouse.y <= h)
    {
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                if (mode == 1 || mode == 2)
                    distance = sqrt((x - mouse.x)*(x - mouse.x) + (y - mouse.y)*(y - mouse.y));
                else if (mode == 3)
                    distance = (x - mouse.x);
                else if (mode == 4)
                    distance = (y - mouse.y);
                
                newX = x;
                newY = y;
                if ((fabs(distance) <= value1))
                {
                    if (mode == 1)
                    {
                        factor = pow((distance / value1), (value2 / 20.0));
                        newX = mouse.x + (x - mouse.x) * factor;
                        newY = mouse.y + (y - mouse.y) * factor;
                    }
                    else if (mode == 2)
                    {
                        factor = cbrt((distance / value1));
                        newX = mouse.x + (x - mouse.x) / factor;
                        newY = mouse.y + (y - mouse.y) / factor;
                    }
                    else if (mode == 3)
                    {
                        factor = pow((fabs(distance) / value1), (value2 / 20.0));
                        newX = mouse.x + distance * factor;
                    }
                    else if (mode == 4)
                    {
                        factor = pow((fabs(distance) / value1), (value2 / 20.0));
                        newY = mouse.y + distance * factor;
                    }
                    
                    if (newX < lowArea.x)
                        newX = lowArea.x;
                    if (newY < lowArea.y)
                        newY = lowArea.y;
                    if (newX > highArea.x)
                        newX = highArea.x;
                    if (newY > highArea.y)
                        newY = highArea.y;
                }
                
                if (interpolate && (distance <= value1))
                    img->data[int(x + w*y)] = imageRgbaInterpolate(temp, newX, newY);
                else
                    img->data[int(x + w*y)] = temp->data[int(newX) + w*int(newY)];
            }
        }
        refresh = false;
    }
}

void bubble::keyRIGHT()
{
    value1 += 5;
    if (value1 >= limitValue1.high)
        value1 = limitValue1.high;
}

void bubble::keyLEFT()
{
    value1 -= 5;
    if (value1 <= limitValue1.low)
        value1 = limitValue1.low;    
}

void bubble::keyUP()
{
    value2 += 5;
    if (value2 > limitValue2.high)
        value2 = limitValue2.high;
}

void bubble::keyDOWN()
{
    value2 -= 5;
    if (value2 < limitValue2.low)
        value2 = limitValue2.low;
}

void bubble::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Bubble | Mode 1: Convex");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Bubble | Mode 2: Concave");
    else if (mode == 3)
        glutSetWindowTitle("Paint Application | Bubble | Mode 3: Vertical");
    else if (mode == 4)
        glutSetWindowTitle("Paint Application | Bubble | Mode 4: Horizontal");
        
    if (!LBpressed)
    {
        LBpressed = true;
        this->idleAction();
        LBpressed = false;
    }
    else
        this->idleAction();
}

// Lens                                                                      //
lens::lens(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    glutSetWindowTitle("Paint Application | Lens");

    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);

    imageRgbaCopy(img, temp);
    
    numModes = 4;
    value2 = 190; // strength
    limitValue2.set(0, 359);
    value1 = 100; // length
    limitValue1.set(10, 1000);
    refresh = false;
    interpolate = false;
    inActionState = false;
    
    bColorMenu = true;
    myColor = (Rgba){0, 0, 0, 255};
    
    this->changeMode(1);
}

void lens::idleAction()
{
    const int w = img->width;
    const int h = img->height;
    float newX, newY, distance, factor;
    double angle;
    float newValue2 = value2 / 180.0 * M_PI;
    
    if ((LBpressed || refresh) && mouse.x >= 0 && mouse.y >= 0 && mouse.x <= w && mouse.y <= h)
    {
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                bool inArea = true;
                distance = sqrt((x - mouse.x)*(x - mouse.x) + (y - mouse.y)*(y - mouse.y));
                newX = x;
                newY = y;
                if (distance <= value1)
                {
                    if (mode == 1)
                    {
                        factor = pow((distance / value1), (newValue2 / 20.0));
                        newX = (mouse.x - x);
                        newY = (mouse.y - y);
                        
                        if (newY == 0 && newX > 0)
                            angle = M_PI / 2.0;
                        else
                            angle = atan(newX / newY);
                        
                        if (newX == 0 && newY == 0)
                            angle = 0;
                            
                        if (newY >= 0)
                            angle -= M_PI;
    
                        angle += newValue2;
                        
                        newX = mouse.x + sin(angle) * distance;
                        newY = mouse.y + cos(angle) * distance;
                    }
                    else if (mode == 2)
                    {
                        newValue2 = value2 / 36.0;
                        newX = mouse.x + (x - mouse.x) * newValue2;
                        newY = mouse.y + (y - mouse.y) * newValue2;
                    }
                    else if (mode == 3)
                    {
                        newX = mouse.x + (x - mouse.x) * -1;
                    }
                    else if (mode == 4)
                    {
                        newY = mouse.y + (y - mouse.y) * -1;
                    }
                    
                    if (newX < lowArea.x || newY < lowArea.y || newX > highArea.x || newY > highArea.y)
                        inArea = false;
                }
                if (inArea)
                {
                    if (interpolate && (distance <= value1))
                        img->data[int(x + w*y)] = imageRgbaInterpolate(temp, newX, newY);
                    else
                        img->data[int(x + w*y)] = temp->data[int(newX) + w*int(newY)];
                }
                else
                    img->data[int(x + w*y)] = myColor;
            }
        }
        refresh = false;
    }
}

void lens::keyRIGHT()
{
    value1 += 5;
    if (value1 >= limitValue1.high)
        value1 = limitValue1.high;
}

void lens::keyLEFT()
{
    value1 -= 5;
    if (value1 <= limitValue1.low)
        value1 = limitValue1.low;    
}

void lens::keyUP()
{
    value2 += 5;
    if (value2 > limitValue2.high)
        value2 = limitValue2.low;
}

void lens::keyDOWN()
{
    value2 -= 5;
    if (value2 < limitValue2.low)
        value2 = limitValue2.high;
}

void lens::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Lens | Mode 1: Turn");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Lens | Mode 2: Zoom");
    else if (mode == 3)
        glutSetWindowTitle("Paint Application | Lens | Mode 3: Flip vertical");
    else if (mode == 4)
        glutSetWindowTitle("Paint Application | Lens | Mode 4: Flip horizontal");
        
    if (!LBpressed)
    {
        LBpressed = true;
        this->idleAction();
        LBpressed = false;
    }
    else
        this->idleAction();
}


// Twirl                                                                     //
twirl::twirl(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    glutSetWindowTitle("Paint Application | Twirl");

    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);

    imageRgbaCopy(img, temp);
    
    numModes = 2;
    value2 = 180; // strength
    limitValue2.set(-1080, 1080);
    value1 = 100; // length
    limitValue1.set(10, 1000);
    refresh = false;
    interpolate = false;
    inActionState = false;
    
    this->changeMode(1);
}

void twirl::idleAction()
{
    int w, h;
    float newX, newY, distance, factor;
    double angle;
    float newValue2 = value2 / 180.0 * M_PI;

    w = img->width;
    h = img->height;
    if ((mode == 1) && (LBpressed || refresh)&& (mouse.x >= 0 && mouse.y >= 0 && mouse.x <= w && mouse.y <= h))
    {
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                distance = sqrt((x - mouse.x)*(x - mouse.x) + (y - mouse.y)*(y - mouse.y));
                newX = x;
                newY = y;
                if (distance <= value1)
                {
                    factor = pow((distance / value1), (newValue2 / 20.0));
                    newX = (mouse.x - x);
                    newY = (mouse.y - y);
                    
                    if (newY == 0 && newX > 0)
                        angle = M_PI / 2;
                    else
                        angle = atan(newX / newY);
                    
                    if (newX == 0 && newY == 0)
                        angle = 0;

                    if (newY >= 0)
                        angle += M_PI;
                    
                    angle += newValue2 * pow((value1 - distance) / value1, 2);

                    newX = mouse.x + sin(angle) * distance;
                    newY = mouse.y + cos(angle) * distance;
                    
                    if (newX < lowArea.x)
                        newX = lowArea.x;
                    if (newY < lowArea.y)
                        newY = lowArea.y;
                    if (newX > highArea.x)
                        newX = highArea.x;
                    if (newY > highArea.y)
                        newY = highArea.y;
                }
                if (interpolate && (distance <= value1))
                    img->data[int(x + w*y)] = imageRgbaInterpolate(temp, newX, newY);
                else
                    img->data[int(x + w*y)] = temp->data[int(newX) + w*int(newY)];
            }
        }
    }
    else if ((mode == 2) && (LBpressed || refresh))
    {
        int numW = int(value1 / 50 + 1);
        if (numW == 0)
            numW = 1;

        w = (highArea.x - lowArea.x + 1);
        h = (highArea.y - lowArea.y + 1);
        
        float newLength, xLength, yLength;
        xLength = w / numW;
        yLength = h / numW;
        if (w <= h)
            newLength = xLength / 2;
        else
            newLength = yLength / 2;
            
        for (int wy = 0; wy < numW; wy++)
        {
            for (int wx = 0; wx < numW; wx++)
            {
                for (int y = 0; y < int(yLength); y++)
                {
                    for (int x = 0; x < int(xLength); x++)
                    {
                        distance = sqrt((xLength/2 - x)*(xLength/2 - x) + (yLength/2 - y)*(yLength/2 - y));
                        newX = lowArea.x + wx*xLength + x;
                        newY = lowArea.y + wy*yLength + y;
                        if (distance <= newLength)
                        {
                            factor = pow((distance / newLength), (newValue2 / 20.0));
                            newX = (xLength/2 - x);
                            newY = (yLength/2 - y);

                            if (newY == 0 && newX > 0)
                                angle = M_PI / 2;
                            else
                                angle = atan(newX / newY);
                            
                            if (newX == 0 && newY == 0)
                                angle = 0;
        
                            if (newY >= 0)
                                angle += M_PI;
                                     
                            angle += newValue2 * pow((newLength - distance) / newLength, 2); //90.0/180.0*M_PI;
        
                            newX = lowArea.x + wx*xLength + xLength/2 + sin(angle) * distance;
                            newY = lowArea.y + wy*yLength + yLength/2 + cos(angle) * distance;
                            
                            if (newX < lowArea.x)
                                newX = lowArea.x;
                            if (newY < lowArea.y)
                                newY = lowArea.y;
                            if (newX > highArea.x)
                                newX = highArea.x;
                            if (newY > highArea.y)
                                newY = highArea.y;
                        }
                        img->data[int((lowArea.x + wx*xLength+x) + img->width*(lowArea.y + wy*yLength+y))] = imageRgbaInterpolate(temp, newX, newY);
                    }
                }
            }
        }
    }
    refresh = false;
}

void twirl::keyRIGHT()
{
    if (mode == 1)
        value1 += 10;
    else if (mode == 2)
    {
        value1 += 50;
        imageRgbaCopy(temp, img);
    }
    if (value1 >= limitValue1.high)
        value1 = limitValue1.high;    
}

void twirl::keyLEFT()
{
    if (mode == 1)
        value1 -= 10;
    else if (mode == 2)
    {
        value1 -= 50;
        imageRgbaCopy(temp, img);
    }
    if (value1 <= limitValue1.low)
        value1 = limitValue1.low;
}

void twirl::keyUP()
{
    value2 += 30;
    if (value2 > limitValue2.high)
        value2 = limitValue2.high;
}

void twirl::keyDOWN()
{
    value2 -= 30;
    if (value2 < limitValue2.low)
        value2 = limitValue2.low;
}

void twirl::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Twirl | Mode 1: Single Twirl");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Twirl | Mode 2: Multiple Twirl");
        
    if (!LBpressed)
    {
        LBpressed = true;
        this->idleAction();
        LBpressed = false;
    }
    else
        this->idleAction();
}

// Wave                                                                      //
wave::wave(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    glutSetWindowTitle("Paint Application | Wave");

    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);

    imageRgbaCopy(img, temp);
    
    numModes = 3;
    value2 = 10; // strength
    limitValue2.set(1, 50);
    value1 = 5; // length
    limitValue1.set(1, 50);
    refresh = false;
    interpolate = false;
    inActionState = false;
    
    this->changeMode(1);
}

void wave::idleAction()
{
    const int w = img->width;
    const int h = img->height;
    float newX, newY;
    if ((LBpressed || refresh) && mouse.x >= 0 && mouse.y >= 0 && mouse.x <= w && mouse.y <= h)
    {
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                if (mode == 1)
                {
                    newX = x + value2 * sin((y - mouse.y) / value1);
                    newY = y;
                }
                else if (mode == 2)
                {
                    newX = x;
                    newY = y + value2 * sin((x - mouse.x) / value1);
                }
                else if (mode == 3)
                {
                    newX = x + value2 * sin((y - mouse.y) / value1);
                    newY = y + value2 * sin((x - mouse.x) / value1);
                }

                if (newX < lowArea.x)
                    newX = lowArea.x;
                if (newY < lowArea.y)
                    newY = lowArea.y;
                if (newX > highArea.x)
                    newX = highArea.x;
                if (newY > highArea.y)
                    newY = highArea.y;
                    
                if (interpolate)
                    img->data[int(x + w*y)] = imageRgbaInterpolate(temp, newX, newY);
                else
                    img->data[int(x + w*y)] = temp->data[int(newX) + w*int(newY)];

//                img->data[int(x + w*y)] = temp->data[int(1.0*x/w/2.0+0.5+1)+w*int(1.0*y/w/2.0+0.5)];
//                img->data[int(x + w*y)] = imageRgbaInterpolate(temp, 1+1.0*x/w, 1.0*y/w);
            }
        }
        refresh = false;
    }
}

void wave::keyLEFT()
{
    value1 -= 1;
    if (value1 <= limitValue1.low)
        value1 = limitValue1.low;    
}

void wave::keyRIGHT()
{
    value1 += 1;
    if (value1 >= limitValue1.high)
        value1 = limitValue1.high;
}

void wave::keyUP()
{
    value2 += 2;
    if (value2 > limitValue2.high)
        value2 = limitValue2.high;
}

void wave::keyDOWN()
{
    value2 -= 2;
    if (value2 < limitValue2.low)
        value2 = limitValue2.low;
}

void wave::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Wave | Mode 1: Horizontal");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Wave | Mode 2: Vertical");
    else if (mode == 3)
        glutSetWindowTitle("Paint Application | Wave | Mode 3: Full");
        
    if (!LBpressed)
    {
        LBpressed = true;
        this->idleAction();
        LBpressed = false;
    }
    else
        this->idleAction();
}

// Buttonize                                                                 //
buttonize::buttonize(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    glutSetWindowTitle("Paint Application | Buttonize");

    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);

    imageRgbaCopy(img, temp);
    
    if ((highArea.x - lowArea.x + 1) < (highArea.y - lowArea.y + 1))
        limitValue1.set(0, int((highArea.x - lowArea.x + 1) / 2));
    else
        limitValue1.set(0, int((highArea.y - lowArea.y + 1) / 2));
    value1 = int(limitValue1.high / 4); // length

    numModes = 2;
    
    value2 = 50; // opacity
    limitValue2.set(0, 100);
    refresh = false;
    bColorMenu = true;
    myColor = (Rgba){0, 0, 0, 255};    

    this->changeMode(1);
}


void buttonize::colorChangeAction()
{
    if (!LBpressed)
    {
        LBpressed = true;
        this->LBAction();
        LBpressed = false;
    }
    else
        this->LBAction();
}

void buttonize::idleAction()
{
    this->LBAction();
}

void buttonize::LBAction()
{
    const int w = img->width;
    const int h = img->height;
    if ((LBpressed || refresh) && mouse.x >= 0 && mouse.y >= 0 && mouse.x <= w && mouse.y <= h)
    {
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                int location = x + img->width * y;
                float position, opacity;

                if ((y-lowArea.y) < value1 && (y-lowArea.y) <= (x-lowArea.x) && (y-lowArea.y) < (highArea.x - x))
                {
                    if (mode == 1)
                    {
                        position = 1 - (y-lowArea.y)/value1;
                        opacity =  (value2/100 * position);
                        img->data[location].r = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].r) + (opacity * myColor.r));
                        img->data[location].g = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].g) + (opacity * myColor.g));
                        img->data[location].b = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].b) + (opacity * myColor.b));
                    }
                    if (mode == 2)
                    {
                        opacity = value2 / 100;
                        img->data[location].r = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].r) + (opacity * (myColor.r + 50)));
                        img->data[location].g = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].g) + (opacity * (myColor.g + 50)));
                        img->data[location].b = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].b) + (opacity * (myColor.b + 50)));
                    }
                }
                else if (y >= (highArea.y - value1) && (y-highArea.y) > (x-highArea.x) && (highArea.y - y) <= (x - lowArea.x))
                {
                    if (mode == 1)
                    {
                        position = (y-(highArea.y - value1))/value1;
                        opacity =  (value2/100 * position);
                        img->data[location].r = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].r) + (opacity * myColor.r));
                        img->data[location].g = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].g) + (opacity * myColor.g));
                        img->data[location].b = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].b) + (opacity * myColor.b));
                    }
                    if (mode == 2)
                    {
                        opacity = value2 / 100;
                        img->data[location].r = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].r) + (opacity * (myColor.r - 50)));
                        img->data[location].g = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].g) + (opacity * (myColor.g - 50)));
                        img->data[location].b = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].b) + (opacity * (myColor.b - 50)));
                    }
                }
                else if ((x-lowArea.x) < value1)
                {
                    if (mode == 1)
                    {
                        position = 1 - (x-lowArea.x)/value1;
                        opacity =  (value2/100 * position);
                        img->data[location].r = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].r) + (opacity * myColor.r));
                        img->data[location].g = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].g) + (opacity * myColor.g));
                        img->data[location].b = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].b) + (opacity * myColor.b));
                    }
                    if (mode == 2)
                    {
                        opacity = value2 / 100;
                        img->data[location].r = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].r) + (opacity * (myColor.r + 20)));
                        img->data[location].g = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].g) + (opacity * (myColor.g + 20)));
                        img->data[location].b = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].b) + (opacity * (myColor.b + 20)));
                    }
                }
                else if (x >= (highArea.x - value1))
                {
                    if (mode == 1)
                    {
                        position = (x-(highArea.x - value1))/value1;
                        opacity =  (value2/100 * position);
                        img->data[location].r = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].r) + (opacity * myColor.r));
                        img->data[location].g = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].g) + (opacity * myColor.g));
                        img->data[location].b = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].b) + (opacity * myColor.b));
                    }
                    if (mode == 2)
                    {
                        opacity = value2 / 100;
                        img->data[location].r = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].r) + (opacity * (myColor.r - 20)));
                        img->data[location].g = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].g) + (opacity * (myColor.g - 20)));
                        img->data[location].b = limitRGBA.intForceLimit(((1 - opacity) * temp->data[location].b) + (opacity * (myColor.b - 20)));
                    }
                }
                else
                    img->data[location] = temp->data[location];
            }
        }
        refresh = false;
    }
}

void buttonize::keyRIGHT()
{
    value1 += 1;
    if (value1 > limitValue1.high)
        value1 = limitValue1.high;
}

void buttonize::keyLEFT()
{
    value1 -= 1;
    if (value1 < limitValue1.low)
        value1 = limitValue1.low;    
}

void buttonize::keyUP()
{
    value2 += 5;
    if (value2 > limitValue2.high)
        value2 = limitValue2.high;
}

void buttonize::keyDOWN()
{
    value2 -= 5;
    if (value2 < limitValue2.low)
        value2 = limitValue2.low;
}

void buttonize::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Buttonize | Mode 1: Floating");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Buttonize | Mode 2: Fixed");
        
    if (!LBpressed)
    {
        LBpressed = true;
        this->LBAction();
        LBpressed = false;
    }
    else
        this->LBAction();
}   
     
// Glass                                                                     //
glass::glass(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    glutSetWindowTitle("Paint Application | Glass");

    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);

    value1 = 40;
    if ((highArea.x - lowArea.x + 1) > (highArea.y - lowArea.y + 1))
        limitValue1.set(5, (highArea.x - lowArea.x + 1));
    else
        limitValue1.set(5, (highArea.y - lowArea.y + 1));
    value2 = 10;
    limitValue2.set(0, 50);
    numModes = 8;
    mode = 1;
    imageRgbaCopy(img, temp);
    bColorMenu = true;
    myColor = (Rgba){255, 255, 255, 255};
    myAngleXY = 1.0/4.0*M_PI;
    myAngleZ = 1.0/8.0*M_PI;
    myStrength = 0.0;
   
    this->changeMode(1);
}

void glass::colorChangeAction()
{
    if (!LBpressed)
    {
        LBpressed = true;
        this->LBAction();
        LBpressed = false;
    }
    else
        this->LBAction();
}

void glass::drawLightningMenu()
{
    int newX, newY, drawX, drawY;
    for (int y = 0; y < 150; y++)
    {
        for (int x = 0; x < 150; x++)
        {
            if (x < img->width && y < img->height)
                img->data[x + img->width * y] = (Rgba){0, 0, 0, 255};
        }
    }
    imageRgbaDrawEllipse(img, 75, 75, 50, 50, (Rgba){255, 255, 255, 255});
    newX = int(75 + sin(myAngleXY + M_PI) * cos(myAngleZ)*50);
    newY = int(75 + cos(myAngleXY + M_PI) * cos(myAngleZ)*50);
    imageRgbaDrawLine(img, newX, newY, int(75 + sin(myAngleXY + M_PI) * 50), int(75 + cos(myAngleXY + M_PI) * 50), (Rgba){255, 255, 255, 255});

    for (int y = int(-7); y < int(7); y++)
    {
        float xValue = sqrt((7*7) - (y*y)) + 1;
        for (int x = int(-xValue); x < int(xValue); x++)
        {
            drawX = newX + x;
            drawY = newY + y;
            int location = drawX + img->width * drawY;
            if ((drawY >= 0) && (drawY < img->width) && (drawX >= 0) && (drawX <= img->height))
                img->data[location] = (Rgba){limitRGBA.intForceLimit(255 / 2 * myStrength), limitRGBA.intForceLimit(255 / 2 * myStrength), limitRGBA.intForceLimit(255 / 2 * myStrength), 255};
        }
    }

    imageRgbaDrawEllipse(img, newX, newY, 7, 7, (Rgba){255, 255, 255, 255});
}

void glass::LBAction()
{
    if (LBpressed)
    {
        int w = highArea.x - lowArea.x + 1;
        int h = highArea.y - lowArea.y + 1;
        
        for (int by = 0; by < int(1.0 * h / value1 + 1); by++)
        {
            for (int bx = 0; bx < int(1.0 * w / value1 + 1); bx++)
            {
                for (int y = 0; y < value1; y++)
                {
                    for (int x = 0; x < value1; x++)
                    {
                        float newX, newY, oldX, oldY;
                        int dO, dU, dL, dR, M;
                        float dVertical, dHorizontal;
                        newX = (1.0 * x / value1 * 20.0);
                        newY = (1.0 * y / value1 * 20.0);
                        
                        M = imageRgbaInterpolateSubImage(menu, newX, newY, 20, 20, (100 - mode + 1) * 400);

                        dO = imageRgbaInterpolateSubImage(menu, newX, newY - 1, 20, 20, (100 - mode + 1) * 400) - M;
                        dU = M - imageRgbaInterpolateSubImage(menu, newX, newY + 1, 20, 20, (100 - mode + 1) * 400);
                        dL = imageRgbaInterpolateSubImage(menu, newX - 1, newY, 20, 20, (100 - mode + 1) * 400) - M;
                        dR = M - imageRgbaInterpolateSubImage(menu, newX + 1, newY, 20, 20, (100 - mode + 1) * 400);
                        
                        dHorizontal = (1.0 * (dL + dR) / 2.0);
                        dVertical = (1.0 * (dO + dU) / 2.0);
                        
                        dHorizontal = (dHorizontal) / 255.0 * value2 * 20;
                        dVertical = (dVertical) / 255.0 * value2 * 20;
/*                        
                        if (dHorizontal > 255) { dHorizontal = 255; }
                        if (dHorizontal < -255) { dHorizontal = -255; }
                        if (dVertical > 255) { dVertical = 255; }
                        if (dVertical < -255) { dVertical = -255; }
*/
                        oldX = (lowArea.x + bx*value1 + x);
                        oldY = (lowArea.y + by*value1 + y);
                        newX = (oldX + dHorizontal);
                        newY = (oldY + dVertical);

                        if (newX < lowArea.x) { newX = lowArea.x; }
                        if (newY < lowArea.y) { newY = lowArea.y; }
                        if (newX > highArea.x) { newX = highArea.x; }
                        if (newY > highArea.y) { newY = highArea.y; }

                        if (oldX < lowArea.x) { oldX = lowArea.x; }
                        if (oldY < lowArea.y) { oldY = lowArea.y; }
                        if (oldX > highArea.x) { oldX = highArea.x; }
                        if (oldY > highArea.y) { oldY = highArea.y; }

                        if (myStrength > 0)
                        {
                            float angleXY;
    
                            // XY-Angle
                            // calculating the XY-Angle of each pixel (XY-Angle means something like north/south/west/east)
                            // the XY-Angle depends on dVertical and dHorizontal, which are the pitch in y and x direction
                            if (dVertical == 0 && dHorizontal > 0)
                                angleXY = M_PI / 2.0;
                            else
                                angleXY = atan(dHorizontal / dVertical);
                            if (dHorizontal == 0 && dVertical == 0)
                                angleXY = 0;
                            if (dVertical >= 0)
                                angleXY -= M_PI;
                            if (angleXY < 0) { angleXY += 2 * M_PI; }
                            if (angleXY > (2 * M_PI)) { angleXY -= 2 * M_PI; }

//                            dAXY = fabs(myAngleXY - angleXY);
//                            if (dAXY > M_PI)
//                                dAXY = ((2*M_PI) - dAXY);

                            // Z-Angle
                            // now the same with the Z-Angle - a flat pixel got Z-Angle = 0, a pixle in a upright 'wall' got Z-Angle = 90°
                            float angleZ;
                            float pitch = (fabs(dHorizontal) + fabs(dVertical)) / 2;
                            if (pitch < 2)
                                pitch = 0; // avoiding some noise
                            pitch /= (3*value2);   // pitch is something between 0 and 255, and I randomly define a value as a degree of ~35° (because pitch = 1 gives us (below) a Z-angle of ~35°)
                            // angle between 2 vectors: [1, 1, steigung] and [0, 0, 1] (normalvector of the image)
                            angleZ = asin(((pitch)/(sqrt(2 + pitch*pitch))));

                            if (angleZ == 0) // if the pixel is flat, we dont need a XY-angle
                                angleXY = myAngleXY;

                            angleZ = (M_PI / 2) - angleZ; // we need the angle inverted
                            
                            float dFinal = 0;
                            // angle between 2 vectors: 1) pixel direction with angleXY and angleZ, 2) light-direction with myAngleXY and myAngleZ
                            dFinal = asin(fabs((cos(angleXY)*cos(myAngleXY)+sin(angleXY)*sin(myAngleXY)+tan(angleZ)*tan(myAngleZ))/(sqrt(cos(angleXY)*cos(angleXY) + sin(angleXY)*sin(angleXY) + tan(angleZ)*tan(angleZ)) * sqrt(cos(myAngleXY)*cos(myAngleXY) + sin(myAngleXY)*sin(myAngleXY) + tan(myAngleZ)*tan(myAngleZ)))));
                            dFinal = (dFinal / (M_PI / 2));

//                          dAXY = (dAXY / (1*M_PI));
//                          dAZ = (dAZ / (0.5*M_PI));
                            
                            
//                            img->data[int(oldX) + img->width*int(oldY)].r = limitRGBA.intForceLimit(127 + steigung / 512 * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].g = limitRGBA.intForceLimit(127 + steigung / 512 * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].b = limitRGBA.intForceLimit(127 + steigung / 512 * 255);

//                            img->data[int(oldX) + img->width*int(oldY)].r = limitRGBA.intForceLimit(angleXY / (2*M_PI) * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].g = limitRGBA.intForceLimit(angleXY / (2*M_PI) * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].b = limitRGBA.intForceLimit(angleXY / (2*M_PI) * 255);
    
//                            img->data[int(oldX) + img->width*int(oldY)].r = limitRGBA.intForceLimit((1 - dAXY / (1*M_PI)) * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].g = limitRGBA.intForceLimit((1 - dAXY / (1*M_PI)) * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].b = limitRGBA.intForceLimit((1 - dAXY / (1*M_PI)) * 255);
    
//                            img->data[int(oldX) + img->width*int(oldY)].r = limitRGBA.intForceLimit(angleZ / (0.5*M_PI) * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].g = limitRGBA.intForceLimit(angleZ / (0.5*M_PI) * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].b = limitRGBA.intForceLimit(angleZ / (0.5*M_PI) * 255);
    
//                            img->data[int(oldX) + img->width*int(oldY)].r = limitRGBA.intForceLimit((dAZ / (0.5*M_PI)) * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].g = limitRGBA.intForceLimit((dAZ / (0.5*M_PI)) * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].b = limitRGBA.intForceLimit((dAZ / (0.5*M_PI)) * 255);
                            
//                            img->data[int(oldX) + img->width*int(oldY)].r = limitRGBA.intForceLimit(dAXY * (dAZ/2) * 255 * 2);
//                            img->data[int(oldX) + img->width*int(oldY)].g = limitRGBA.intForceLimit(dAXY * (dAZ/2) * 255 * 2);
//                            img->data[int(oldX) + img->width*int(oldY)].b = limitRGBA.intForceLimit(dAXY * (dAZ/2) * 255 * 2);
    
//                            img->data[int(oldX) + img->width*int(oldY)].r = limitRGBA.intForceLimit(dFinal * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].g = limitRGBA.intForceLimit(dFinal * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].b = limitRGBA.intForceLimit(dFinal * 255);

//                            img->data[int(oldX) + img->width*int(oldY)].r = limitRGBA.intForceLimit(255 - (1-dAZ) * 255 - dAXY * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].g = limitRGBA.intForceLimit(255 - (1-dAZ) * 255 - dAXY * 255);
//                            img->data[int(oldX) + img->width*int(oldY)].b = limitRGBA.intForceLimit(255 - (1-dAZ) * 255 - dAXY * 255);
/*    
                            int locationNEW = int(newX) + img->width*int(newY);
                            int locationOLD = int(oldX) + img->width*int(oldY);
                            img->data[locationOLD].r = limitRGBA.intForceLimit(temp->data[locationNEW].r + myStrength * dAXY * (dAZ/2) * myColor.r * 2);
                            img->data[locationOLD].g = limitRGBA.intForceLimit(temp->data[locationNEW].g + myStrength * dAXY * (dAZ/2) * myColor.g * 2);
                            img->data[locationOLD].b = limitRGBA.intForceLimit(temp->data[locationNEW].b + myStrength * dAXY * (dAZ/2) * myColor.b * 2);
*/
    
                            int locationNEW = int(newX) + img->width*int(newY);
                            int locationOLD = int(oldX) + img->width*int(oldY);
                            img->data[locationOLD].r = limitRGBA.intForceLimit(temp->data[locationNEW].r + myStrength * dFinal * myColor.r);
                            img->data[locationOLD].g = limitRGBA.intForceLimit(temp->data[locationNEW].g + myStrength * dFinal * myColor.g);
                            img->data[locationOLD].b = limitRGBA.intForceLimit(temp->data[locationNEW].b + myStrength * dFinal * myColor.b);

                        }
                        else
                        {

//                            if (interpolate)
//                                img->data[int(oldX) + img->width*int(oldY)] = imageRgbaInterpolate(temp, newX, newY);
//                            else
                                img->data[int(oldX) + img->width*int(oldY)] = temp->data[int(newX) + img->width*int(newY)];

                        }
                    }
                }
            }
        }
    }
}

void glass::key(unsigned char _key)
{
    inAction = inActionState;

    if (_key == ' ')
        bMenu = !bMenu;

    if (_key == 127)
    {
        myStrength -= 0.25;
        if (myStrength < 0)
            myStrength = 0;

        this->drawLightningMenu();
    }
}

void glass::specialKey(int _key)
{
    inAction = inActionState;

    if (_key <= numModes)
        this->changeMode(_key);
        
    if (_key == GLUT_KEY_LEFT || _key == GLUT_KEY_RIGHT || _key == GLUT_KEY_UP || _key == GLUT_KEY_DOWN)
        this->changeValue(_key);
        
    if (_key == GLUT_KEY_PAGE_DOWN)
    {
        myStrength += 0.25;
        if (myStrength > 2)
            myStrength = 2;

        this->drawLightningMenu();
    }

    if (_key == GLUT_KEY_INSERT)
    {
        myAngleXY += (M_PI / 16);
        if (myAngleXY > (2*M_PI))
            myAngleXY = 0;

        this->drawLightningMenu();
    }
    if (_key == GLUT_KEY_PAGE_UP)
    {
        myAngleXY -= (M_PI / 16);
        if (myAngleXY < 0)
            myAngleXY = (2*M_PI);

        this->drawLightningMenu();
    }

    if (_key == GLUT_KEY_HOME)
    {
        myAngleZ += (M_PI / 32);
        if (myAngleZ > (0.5*M_PI))
            myAngleZ = (0.5*M_PI);

        this->drawLightningMenu();
    }
    if (_key == GLUT_KEY_END)
    {
        myAngleZ -= (M_PI / 32);
        if (myAngleZ < (M_PI / 16))
            myAngleZ = (M_PI / 16);

        this->drawLightningMenu();
    }
}

void glass::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
    {
        value1 = 50;
        glutSetWindowTitle("Paint Application | Glass | Mode 1: Rough Glass");
    }
    else if (mode == 2)
    {
        value1 = 50;
        glutSetWindowTitle("Paint Application | Glass | Mode 2: Glass Plates");
    }
    else if (mode == 3)
    {
        value1 = 30;
        glutSetWindowTitle("Paint Application | Glass | Mode 3: Glass Blocks");
    }
    else if (mode == 4)
    {
        value1 = 20;
        glutSetWindowTitle("Paint Application | Glass | Mode 4: Curly Glass");
    }
    else if (mode == 5)
    {
        value1 = 40;
        glutSetWindowTitle("Paint Application | Glass | Mode 5: Glass Rings");
    }
    else if (mode == 6)
    {
        value1 = 20;
        glutSetWindowTitle("Paint Application | Glass | Mode 6: Dotted Glass");
    }
    else if (mode == 7)
    {
        value1 = 50;
        glutSetWindowTitle("Paint Application | Glass | Mode 7: Puzzle");
    }
    else if (mode == 8)
    {
        value1 = 60;
        glutSetWindowTitle("Paint Application | Glass | Mode 8: Custom");
    }

    if (!LBpressed)
    {
        LBpressed = true;
        this->LBAction();
        LBpressed = false;
    }
    else
        this->LBAction();
}

---