Texture.hh

/**********************************************************************
 * blaRAY -- photon mapper/raytracer
 * (C) 2008 by Tomasz bla Fortuna <bla@thera.be>, <bla@af.gliwice.pl>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * See Docs/LICENSE
 *********************/

#ifndef _TEXTURE_H_
#define _TEXTURE_H_

#include <iostream>
#include <string>

#include <cmath>

#include "Math/Point.hh"
#include "World/Color.hh"

namespace World {

        class Texture {
        protected:
                const Double SizeU, SizeV;
                const Bool Tiled; 
                Texture(const Double SizeU=1.0,
                        const Double SizeV=1.0,
                        const Bool Tiled=true)
                        : SizeU(SizeU), SizeV(SizeV), Tiled(Tiled) {}

                void Tile(Math::Point &UV) const
                {
                        Double u = UV.GetU();
                        Double v = UV.GetV();
                        UV.SetU(u - std::floor(u / SizeU) * SizeU);
                        UV.SetV(v - std::floor(v / SizeV) * SizeV);
                }

                virtual std::string Dump() const;

        public:
                virtual ~Texture() 
                {
                }

                virtual Color Get(Math::Point UV) const = 0;

                friend std::ostream &operator<<(std::ostream &os, const Texture &T);
        };

        namespace TexLib {
                class Plain : public Texture {
                protected:
                        const Color C;

                        virtual std::string Dump() const;
                public:
                        Plain(const Color &C) : C(C) {}

                        virtual Color Get(Math::Point UV) const {
                                return C;
                        }
                };

                class Checked : public Texture {
                protected:
                        const Color A, B;
                        virtual std::string Dump() const;
                public:
                        Checked(
                                const Color &A = ColLib::White(),
                                const Color &B = ColLib::Black(),
                                const Double SizeU = 1.0,
                                const Double SizeV = 1.0,
                                const Bool Tiled = true)
                                : Texture(SizeU, SizeV, Tiled),
                                  A(A), B(B) {}

                        virtual Color Get(Math::Point UV) const {
                                const Double HalfU = SizeU / 2;
                                const Double HalfV = SizeV / 2;

                                if (Tiled) Tile(UV);
                                else {
                                        if (UV.GetU() > SizeU ||
                                            UV.GetV() > SizeV)
                                                return ColLib::Black();
                                }
                                if ((UV.GetU() < HalfU && UV.GetV() < HalfV) ||
                                    (UV.GetU() > HalfU && UV.GetV() > HalfV))
                                        return A;
                                return B;
                        }
                };

                const Texture &Red();
                const Texture &Green();
                const Texture &Blue();
                const Texture &White();
                const Texture &Black();
                const Texture &Gray();
        };
}
#endif

---