Layer.h

Go to the documentation of this file.

#pragma once
 
#include "../Layer.h"
#include "TextureTargets.h"
#include "../Utils/Assert.h"
#include "../Geometry/Point3D.h"
#include "../Geometry/Transform3D.h"
#include "../Geometry/Rectangle.h"
#include "../GL/Simple.h"
#include "../GL/FrameBuffer.h"
 
namespace Gorgon { namespace Graphics {
 
    namespace internal {
 
        class Surface {
        public:
            Surface(const Surface &) = delete;
 
            Surface(Surface &&s) {
                vertices = s.vertices;
                texture  = s.texture;
                source   = s.source;
                color    = s.color;
                drawmode = s.drawmode;
 
                s.texture = nullptr;
                s.source  = nullptr;
            }
 
            Surface &operator =(const Surface &) = delete;
 
            Surface &operator =(Surface &&s) {
                vertices = s.vertices;
                texture  = s.texture;
                source   = s.source;
                color    = s.color;
                drawmode = s.drawmode;
 
                s.texture = nullptr;
                s.source  = nullptr;
 
                return *this;
            }
 
            Surface(const TextureSource &source, const Geometry::Pointf &p1, const Geometry::Pointf &p2,
                    const Geometry::Pointf &p3, const Geometry::Pointf &p4, RGBAf color, TextureTarget::DrawMode drawmode) : 
                source(&source), color(color), drawmode(drawmode) {
 
                vertices[0]  = p1;
                vertices[1]  = p2;
                vertices[2]  = p3;
                vertices[3]  = p4;
            }
 
            Surface(const Geometry::Pointf &p1, const Geometry::Pointf &p2,
                    const Geometry::Pointf &p3, const Geometry::Pointf &p4, 
                    RGBAf color, TextureTarget::DrawMode drawmode) : color(color), drawmode(drawmode) {
                vertices[0]  = p1;
                vertices[1]  = p2;
                vertices[2]  = p3;
                vertices[3]  = p4;
            }
 
            Surface(const TextureSource &source, const Geometry::Pointf &p1, const Geometry::Pointf &p2,
                const Geometry::Pointf &p3, const Geometry::Pointf &p4,
                const Geometry::Pointf &t1, const Geometry::Pointf &t2,
                const Geometry::Pointf &t3, const Geometry::Pointf &t4, 
                RGBAf color, TextureTarget::DrawMode drawmode) : source(&source), color(color), drawmode(drawmode) {
 
                texture = new Geometry::Pointf[4];
 
                texture [0]  = t1;
                texture [1]  = t2;
                texture [2]  = t3;
                texture [3]  = t4;
                
                vertices[0]  = p1;
                vertices[1]  = p2;
                vertices[2]  = p3;
                vertices[3]  = p4;
            }
 
            bool IsSet() {
                return source != nullptr;
            }
 
            GL::Texture TextureID() const {
                return source->GetID();
            }
 
            GL::QuadVertices GetVertices(const Geometry::Transform3D &transform) {
                return transform*vertices;
            }
 
            GL::QuadTextureCoords GetTextureCoords() {
                if(texture)
                    return {texture[0], texture[1], texture[2], texture[3]};
                else {
                    auto texture=source->GetCoordinates();
                    return {texture[0], texture[1], texture[2], texture[3]};
                }
            }
 
            bool IsPartial() {
                return source->IsPartial();
            }
            
            ColorMode GetMode() const {
                return source->GetMode();
            }
            
            RGBAf GetColor() const {
                return color;
            }
 
            TextureTarget::DrawMode GetDrawMode() const {
                return drawmode;
            }
 
            void SetDrawMode(TextureTarget::DrawMode value) {
                drawmode = value;
            }
 
            ~Surface() {
                if(texture) delete[] texture;
                texture      = nullptr;
            }
 
        private:
            TextureTarget::DrawMode drawmode = TextureTarget::Normal;
 
            GL::QuadVertices vertices;
            Geometry::Pointf *texture = nullptr;
 
            const TextureSource *source = nullptr;
            RGBAf color;
        };
    }
 
    class Layer : public Gorgon::Layer, public Graphics::TextureTarget {
        struct Operation {
            enum {
                NewMask
            } type;
 
            std::size_t index;
        };
        friend void Initialize();
    public:
        
        Layer(const Geometry::Bounds &bounds) : Gorgon::Layer(bounds)
        { }
 
        Layer() : Gorgon::Layer() { }
 
        Layer(const Geometry::Point &location) :
        Gorgon::Layer(location)
        { }
        
        Layer(const Layer&) = delete;
        
        Layer(Layer &&other) {
            Swap(other);
        }
        
        void Swap(Layer &other) {
            using std::swap;
            
            swap(bounds, other.bounds);
            swap(isvisible, other.isvisible);
            swap(children, other.children);
            swap(color, other.color);
            swap(tint, other.tint);
            swap(mode, other.mode);
            swap(surfaces, other.surfaces);
            
            if(parent==other.parent) return;
            
            auto myparent = parent;
            auto otherparent = other.parent;
            
            int myind = -1;
            int otherind = -1;
            
            if(myparent) {
                myind = myparent->Children.FindLocation(this);
            }
            
            if(otherparent) {
                otherind = otherparent->Children.FindLocation(other);
            }
            
            if(myparent) {
                myparent->Remove(this);
                myparent->Insert(other, myind);
            }
            
            if(otherparent) {
                otherparent->Remove(other);
                otherparent->Insert(this, otherind);
            }
        }
 
        using TextureTarget::Draw;
 
        virtual void Draw(const TextureSource &image, const Geometry::Pointf &p1, const Geometry::Pointf &p2,
                        const Geometry::Pointf &p3, const Geometry::Pointf &p4, RGBAf color = RGBAf(1.f)) override {
 
            surfaces.emplace_back(image, p1, p2, p3, p4, color*this->color, mode);
        }
 
        virtual void Draw(const Geometry::Pointf &p1, const Geometry::Pointf &p2,
                        const Geometry::Pointf &p3, const Geometry::Pointf &p4, RGBAf color = RGBAf(1.f)) override {
 
            surfaces.emplace_back(p1, p2, p3, p4, color*this->color, mode);
        }
 
        virtual void Draw(
            const TextureSource &image, 
            const Geometry::Pointf &p1, const Geometry::Pointf &p2, 
            const Geometry::Pointf &p3, const Geometry::Pointf &p4, 
            const Geometry::Pointf &tex1, const Geometry::Pointf &tex2, 
            const Geometry::Pointf &tex3, const Geometry::Pointf &tex4, RGBAf color = RGBAf(1.f)) override {
 
            surfaces.emplace_back(image, p1, p2, p3, p4, tex1, tex2, tex3, tex4, color*this->color, mode);
        }
 
        virtual void Draw(const TextureSource &image, Tiling tiling, const Geometry::Rectanglef &location, RGBAf color = RGBAf(1.f)) override;
 
        virtual void Clear() override {
            surfaces.clear();
        }
 
        virtual void Render() override;
 
        virtual DrawMode GetDrawMode() const override { return mode; }
 
        virtual void SetDrawMode(DrawMode mode) override { this->mode=mode; }
 
        virtual void NewMask() override {
            Operation op = {Operation::NewMask, surfaces.size()+operations.size()};
            operations.push_back(op);
        }
 
        virtual void SetTintColor(RGBAf value) { tint = value; }
 
        virtual RGBAf GetTintColor() const { return tint; }
 
        virtual void SetColor(RGBAf value) { color = value; }
 
        virtual RGBAf GetColor() const { return color; }
 
        virtual Geometry::Size GetTargetSize() const override {
            if(bounds.Width() != 0 && bounds.Height() != 0)
                return bounds.GetSize();
            else
                return Gorgon::Layer::GetEffectiveBounds().GetSize(); 
        }
 
        void EnableClipping() {
            clippingenabled = true;
        }
 
        void DisableClipping() {
            clippingenabled = false;
        }
 
        bool IsClippingEnabled() const {
            return clippingenabled;
        }
 
        using Gorgon::Layer::GetSize;
 
    private:
        std::vector<internal::Surface> surfaces;
        std::vector<Operation> operations;
 
        bool clippingenabled = false;
        static Geometry::Rectangle cliprectangle;
 
        DrawMode mode = Graphics::TextureTarget::Normal;
        RGBAf tint = RGBAf(1.f);
        RGBAf color = RGBAf(1.f);
 
        static GL::FrameBuffer mask;
    };
    
 
} }