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

/*
 *  GlobeScene.h
 *  WhirlyGlobeLib
 *
 *  Created by Steve Gifford on 1/3/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 "WhirlyVector.h"
#import "Texture.h"
#import "Cullable.h"
#import "Drawable.h"
#import "Generator.h"
#import "GlobeView.h"

namespace WhirlyGlobe 
{
    
class SubTexture;

class AddTextureReq : public ChangeRequest
{
public:
        AddTextureReq(Texture *tex) : tex(tex) { }
        ~AddTextureReq() { if (tex) delete tex; tex = NULL; }

        void execute(GlobeScene *scene,WhirlyGlobeView *view);
        
protected:
        Texture *tex;
};

class RemTextureReq : public ChangeRequest
{
public:
        RemTextureReq(SimpleIdentity texId) : texture(texId) { }

        void execute(GlobeScene *scene,WhirlyGlobeView *view);
        
protected:
        SimpleIdentity texture;
};

class AddDrawableReq : public ChangeRequest
{
public:
        AddDrawableReq(Drawable *drawable) : drawable(drawable) { }
        ~AddDrawableReq() { if (drawable) delete drawable; drawable = NULL; }

        void execute(GlobeScene *scene,WhirlyGlobeView *view);  
        
protected:
        Drawable *drawable;
};

class RemDrawableReq : public ChangeRequest
{
public:
        RemDrawableReq(SimpleIdentity drawId) : drawable(drawId) { }

        void execute(GlobeScene *scene,WhirlyGlobeView *view);
        
protected:      
        SimpleIdentity drawable;
};      

class AddGeneratorReq : public ChangeRequest
{
public:
    AddGeneratorReq(Generator *generator) : generator(generator) { }

    void execute(GlobeScene *scene,WhirlyGlobeView *view);
    
protected:
    Generator *generator;
};
    
class RemGeneratorReq : public ChangeRequest
{
public:
    RemGeneratorReq(SimpleIdentity genId) : genId(genId) { }
    
    void execute(GlobeScene *scene,WhirlyGlobeView *view);
    
protected:
    SimpleIdentity genId;
};
    
typedef std::set<Generator *,IdentifiableSorter> GeneratorSet;
    
class GlobeScene
{
        friend class ChangeRequest;
public:
        GlobeScene(unsigned int numX,unsigned int numY);
        ~GlobeScene();

        void getCullableSize(unsigned int &numX,unsigned int &numY) { numX = this->numX;  numY = this->numY; }
        
        const Cullable * getCullable(unsigned int x,unsigned int y) { return &cullables[y*numX+x]; }
        
        const Cullable *getCullables() { return cullables; }
    
    const GeneratorSet *getGenerators() { return &generators; }

        void addChangeRequest(ChangeRequest *newChange);
        void addChangeRequests(const std::vector<ChangeRequest *> &newchanges);
        
        GLuint getGLTexture(SimpleIdentity texIdent);
        
        // Note: Should give this a time limit
        void processChanges(WhirlyGlobeView *view);
    
    void addSubTexture(const SubTexture &);
    void addSubTextures(const std::vector<SubTexture> &);
    
    SubTexture getSubTexture(SimpleIdentity subTexId);
        
public:
        void overlapping(GeoMbr geoMbr,std::vector<Cullable *> &cullables);
        
        // Note: This could be optimized
        void removeFromCullables(Drawable *drawable);
    
    Generator *getGenerator(SimpleIdentity genId);
        
        Drawable *getDrawable(SimpleIdentity drawId);
        
        Texture *getTexture(SimpleIdentity texId);
    
    GeneratorSet generators;

        unsigned int numX,numY;

        Cullable *cullables;
        
        typedef std::set<Drawable *,IdentifiableSorter> DrawableSet;
        DrawableSet drawables;
        
        typedef std::set<Texture *,IdentifiableSorter> TextureSet;
        TextureSet textures;
        
        pthread_mutex_t changeRequestLock;
        std::vector<ChangeRequest *> changeRequests;
    
    typedef std::set<SubTexture> SubTextureSet;
    SubTextureSet subTextureMap;
};
        
}