Texture2D.h

Go to the documentation of this file.

#ifndef TEXTURE2D_H
#define TEXTURE2D_H TEXTURE2D_H

#include "Texture.h"

class Texture2D : public Texture
{
private:
    
    Image* mImage;

    ColorRGBA _GetTexel(int px, int py)
    {
        if (mImage == NULL) return ColorRGBA();

        // compute correct texture coordiantes based on the wrap mode 
        switch (mMode)
        {
            case CLAMP:
                // clamp coordinates
                px = MAX(0, MIN(px, resX - 1));
                py = MAX(0, MIN(py, resY - 1));
                break;

            case REPEAT:
                // repeat coordinates
                px = (resX + px % resX) % resX;
                py = (resY + py % resY) % resY;
                break;

            default:
                break;
        };

        return mImage->getPixel(px, py);
    }

    ColorRGBA _GetSmoothTexel(float u, float v)
    {
        // compute texel coordinates
        // we add 0.5, since the texel is sampled in the middle of the pixel (see OpenGL linear interpolation)
        float px = resX * u + 0.5;
        float py = resY * v + 0.5;

        // find sampling positions of neighbour texels
        PAIR uv[2][2];
        uv[0][0] = PAIR(floor(px - 1), floor(py - 1));
        uv[0][1] = PAIR(floor(px - 1), floor(py));
        uv[1][0] = PAIR(floor(px), floor(py - 1));
        uv[1][1] = PAIR(floor(px), floor(py));

        // get the four neighbours
        // make use of _GetTexel method to ensure also handling of proper wrap modes
        ColorRGBA tex[2][2];
        tex[0][0] = _GetTexel((int)uv[0][0].first, (int)uv[0][0].second);
        tex[0][1] = _GetTexel((int)uv[0][1].first, (int)uv[0][1].second);
        tex[1][0] = _GetTexel((int)uv[1][0].first, (int)uv[1][0].second);
        tex[1][1] = _GetTexel((int)uv[1][1].first, (int)uv[1][1].second);

        // get fractional parts of the texel coordinates
        // based on the fractional part we interpolate the values
        double ix, iy;
        float fx = fabs(px - (int)px);
        float fy = fabs(py - (int)py);

        // interpolate texels bilinearly
        ColorRGBA result = tex[0][0]*(1-fx)*(1-fy) + tex[1][0]*fx*(1-fy) + tex[0][1]*(1-fx)*fy + tex[1][1]*fx*fy;

        // return new value
        return result;
    }

    int resX;

    int resY;

public:

    Texture2D(int resX, int resY) : Texture(), resX(resX), resY(resY)
    {
        mImage = new Image(resX, resY);
    };
    
    Texture2D(char* filename) : Texture(), mImage(NULL), resX(1), resY(1)
    {
        Image* img = new Image(1,1);
        if (img->LoadImage(filename))
        {
            mImage = img;
            resX = img->getWidth();
            resY = img->getHeight();
        }else
            delete img;
    }
    
    ~Texture2D()
    {
        if (mImage) delete mImage;
    }

    ColorRGBA GetTexel(float u, float v)
    {
        // check which interpolation mode is used
        switch (getInterpolationMode())
        {
            // nearest interpolation
            case NEAREST:
                return _GetTexel(int(resX * u), int(resY * v));
                break;

            // linear interpolation
            case LINEAR:
                return _GetSmoothTexel(u,v);
                break;

            default:
                break;
        };
        return ColorRGBA();
    }

};

#endif

---