/Users/sjg/iPhone/WhirlyGlobe/WhirlyGlobeSrc/WhirlyGlobeLib/include/Drawable.h

/*
 *  Drawable.h
 *  WhirlyGlobeLib
 *
 *  Created by Steve Gifford on 2/1/11.
 *  Copyright 2011 mousebird consulting
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

#import <OpenGLES/ES1/gl.h>
#import <OpenGLES/ES1/glext.h>
#import <OpenGLES/ES2/gl.h>
#import <OpenGLES/ES2/glext.h>

#import <vector>
#import <set>
#import <map>
#import "Identifiable.h"
#import "WhirlyVector.h"
#import "GlobeView.h"

using namespace Eigen;

@class RendererFrameInfo;

namespace WhirlyGlobe
{
        
class GlobeScene;

typedef std::map<SimpleIdentity,SimpleIdentity> TextureIDMap;
        
class ChangeRequest
{
public:
        ChangeRequest() { }
        virtual ~ChangeRequest() { }
                
        virtual void execute(GlobeScene *scene,WhirlyGlobeView *view) = 0;
};      

class Drawable : public Identifiable
{
public:
        Drawable();
        virtual ~Drawable();
        
        virtual GeoMbr getGeoMbr() const = 0;
        
        virtual unsigned int getDrawPriority() const = 0;
        
        virtual bool isOn(RendererFrameInfo *frameInfo) const = 0;
        
        virtual void setupGL(float minZres) { };
        
        virtual void teardownGL() { };

        virtual void draw(RendererFrameInfo *frameInfo,GlobeScene *scene) const = 0;    
    
    virtual bool hasAlpha(RendererFrameInfo *frameInfo) const = 0;
    
    virtual bool canCache() const = 0;

    virtual bool readFromFile(FILE *fp,const TextureIDMap &texIdMap, bool doTextures=true) { return false; }
    
    virtual bool writeToFile(FILE *fp,const TextureIDMap &texIdMap, bool doTextures=true) const { return false; }
};

class DrawableChangeRequest : public ChangeRequest
{
public:
        DrawableChangeRequest(SimpleIdentity drawId) : drawId(drawId) { }
        ~DrawableChangeRequest() { }
        
        void execute(GlobeScene *scene,WhirlyGlobeView *view);
        
        virtual void execute2(GlobeScene *scene,Drawable *draw) = 0;
        
protected:
        SimpleIdentity drawId;
};

static const float DrawVisibleInvalid = 1e10;
    
static const unsigned int MaxDrawablePoints = ((1<<16)-1);
    
class BasicDrawable : public Drawable
{
public:
        BasicDrawable();
        BasicDrawable(unsigned int numVert,unsigned int numTri);
        virtual ~BasicDrawable();

        virtual void setupGL(float minZres);
        
        virtual void teardownGL();      
        
        virtual void draw(RendererFrameInfo *frameInfo,GlobeScene *scene) const;
        
        virtual unsigned int getDrawPriority() const { return drawPriority; }
        
        virtual bool isOn(RendererFrameInfo *frameInfo) const;
        void setOnOff(bool onOff) { on = onOff; }
    
    virtual bool hasAlpha(RendererFrameInfo *frameInfo) const;
    void setAlpha(bool onOff) { isAlpha = onOff; }
        
        virtual GeoMbr getGeoMbr() const { return geoMbr; }
        
        void setGeoMbr(GeoMbr mbr) { geoMbr = mbr; }
        
        class Triangle
        {
        public:
                Triangle() { }
                Triangle(unsigned short v0,unsigned short v1,unsigned short v2) { verts[0] = v0;  verts[1] = v1;  verts[2] = v2; }
                unsigned short verts[3];
        };

        void setDrawPriority(unsigned int newPriority) { drawPriority = newPriority; }
        unsigned int getDrawPriority() { return drawPriority; }

        void setDrawOffset(unsigned int newOffset) { drawOffset = newOffset; }
        unsigned int getDrawOffset() { return drawOffset; }

        void setType(GLenum inType) { type = inType; }
        GLenum getType() const { return type; }

        void setTexId(SimpleIdentity inId) { texId = inId; }

        void setColor(RGBAColor inColor) { color = inColor; }

        void setColor(unsigned char inColor[]) { color.r = inColor[0];  color.g = inColor[1];  color.b = inColor[2];  color.a = inColor[3]; }
    RGBAColor getColor() const { return color; }

    void setVisibleRange(float minVis,float maxVis) { minVisible = minVis;  maxVisible = maxVis; }
    
    void getVisibleRange(float &minVis,float &maxVis) { minVis = minVisible;  maxVis = maxVisible; }
    
    void setFade(NSTimeInterval inFadeDown,NSTimeInterval inFadeUp) { fadeUp = inFadeUp;  fadeDown = inFadeDown; }

        unsigned int addPoint(Point3f pt) { points.push_back(pt); return points.size()-1; }

        void addTexCoord(TexCoord coord) { texCoords.push_back(coord); }
    
    void addColor(RGBAColor color) { colors.push_back(color); }

        void addNormal(Point3f norm) { norms.push_back(norm); }

        void addTriangle(Triangle tri) { tris.push_back(tri); }
    
    unsigned int getNumPoints() const { return points.size(); }
    
    unsigned int getNumTris() const { return tris.size(); }
    
    unsigned int getNumNorms() const { return norms.size(); }
    
    unsigned int getNumTexCoords() const { return texCoords.size(); }
        
        // Widen a line and turn it into a rectangle of the given width
        void addRect(const Point3f &l0, const Vector3f &ln0, const Point3f &l1, const Vector3f &ln1,float width);

    virtual bool canCache() const { return true; }
    
    virtual bool readFromFile(FILE *fp, const TextureIDMap &texIdMap,bool doTextures=true);
    
    virtual bool writeToFile(FILE *fp, const TextureIDMap &texIdMap,bool doTextures=true) const;

protected:
        void drawReg(RendererFrameInfo *frameInfo,GlobeScene *scene) const;
        void drawVBO(RendererFrameInfo *frameInfo,GlobeScene *scene) const;
        
        bool on;  // If set, draw.  If not, not
    bool usingBuffers;  // If set, we've downloaded the buffers already
    NSTimeInterval fadeUp,fadeDown;  // Controls fade in and fade out
        unsigned int drawPriority;  // Used to sort drawables
        unsigned int drawOffset;    // Number of units of Z buffer resolution to offset upward (by the normal)
    bool isAlpha;  // Set if we want to be drawn last
        GeoMbr geoMbr;  // Extents on the globe
        GLenum type;  // Primitive(s) type
        SimpleIdentity texId;  // ID for Texture (in scene)
        RGBAColor color;
    float minVisible,maxVisible;
    // We'll nuke the data arrays when we hand over the data to GL
    unsigned int numPoints, numTris;
        std::vector<Vector3f> points;
    std::vector<RGBAColor> colors;
        std::vector<Vector2f> texCoords;
        std::vector<Vector3f> norms;
        std::vector<Triangle> tris;
        
        GLuint pointBuffer,colorBuffer,texCoordBuffer,normBuffer,triBuffer;
};

class ColorChangeRequest : public DrawableChangeRequest
{
public:
        ColorChangeRequest(SimpleIdentity drawId,RGBAColor color);
        
        void execute2(GlobeScene *scene,Drawable *draw);
        
protected:
        unsigned char color[4];
};
        
class OnOffChangeRequest : public DrawableChangeRequest
{
public:
        OnOffChangeRequest(SimpleIdentity drawId,bool OnOff);
        
        void execute2(GlobeScene *scene,Drawable *draw);
        
protected:
        bool newOnOff;
};      

class VisibilityChangeRequest : public DrawableChangeRequest
{
public:
    VisibilityChangeRequest(SimpleIdentity drawId,float minVis,float maxVis);
    
    void execute2(GlobeScene *scene,Drawable *draw);
    
protected:
    float minVis,maxVis;
};
    
class FadeChangeRequest : public DrawableChangeRequest
{
public:
    FadeChangeRequest(SimpleIdentity drawId,NSTimeInterval fadeUp,NSTimeInterval fadeDown);
    
    void execute2(GlobeScene *scene,Drawable *draw);
    
protected:
    NSTimeInterval fadeUp,fadeDown;
};
    
}