eeditapp.h

Go to the documentation of this file.

/*
 * Author: Andrew Robberts
 *
 * Copyright (C) 2004 Atomic Blue (info@planeshift.it, http://www.atomicblue.org)
 *
 *
 * 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 (version 2 of the License)
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

#ifndef EEDIT_APP_HEADER
#define EEDIT_APP_HEADER

#include <csutil/sysfunc.h>
#include <csutil/csstring.h>
#include <csutil/ref.h>
#include <csutil/bitarray.h>
#include <csgeom/vector2.h>
#include <csgeom/vector3.h>

#include "util/genericevent.h"

struct iEngine;
struct iLoader;
struct iVFS;
struct iEvent;
struct iEventQueue;
struct iConfigManager;
struct iTextureManager;
struct iGraphics3D;
struct iGraphics2D;
struct iView;
struct iVirtualClock;
struct iMeshWrapper;
class csRandomFloatGen;

class PawsManager;
class pawsMainWidget;
class pawsWidget;
class pawsEEdit;

class EEditReporter;
class EEditToolboxManager;
class EEditInputboxManager;

class psEffectManager;
class psCal3DCallbackLoader;

class eControlManager;

enum CAM_FLAG
{
    CAM_NONE = 0,
    
    CAM_UP,
    CAM_RIGHT,
    CAM_DOWN,
    CAM_LEFT,
    CAM_FORWARD,
    CAM_BACK,

    CAM_COUNT
};


class EEditApp
{
public:

    static const char * CONFIG_FILENAME;
    static const char * APP_NAME;
    static const char * WINDOW_CAPTION;
    static const char * KEY_DEFS_FILENAME;
    static const char * TEMP_EFFECTS_LIST;

    EEditApp(iObjectRegistry * obj_reg, EEditReporter * _reporter);

    ~EEditApp();

    void SevereError(const char* msg);

    bool Init();

    bool LoadWidget(const char * file);
    
    bool LoadWidgets();

    PawsManager* GetPaws() { return paws; }


    bool HandleEvent (iEvent &event);

    void RefreshEffectList();

    bool UpdateEffect();
    
    bool RenderEffect(const csString &effectName);

    bool RenderCurrentEffect();
    
    bool ReloadCurrentEffect();
    
    bool TogglePauseEffect();
    
    bool CancelEffect();

    void CreateParticleSystem(const csString & name);

    bool ToggleToolbox(size_t toolbox);

    void ShowToolbox(size_t toolbox);

    void HideToolbox(size_t toolbox);

    bool IsToolboxVisible(size_t toolbox);
    
    EEditToolboxManager * GetToolboxManager();
  
    psEffectManager * GetEffectManager();
    
    EEditInputboxManager * GetInputboxManager();
    
    csPtr<iMeshWrapper> LoadCustomMesh(const csString & meshFile, const csString & name, csVector3 pos);
    
    bool LoadPositionMesh(const csString & meshFile);

    bool LoadTargetMesh(const csString & meshFile);

    void SetPositionAnim(size_t index);
    
    void SetTargetAnim(size_t index);
    
    void SetPositionData(const csVector3 & pos, float rot);

    void SetTargetData(const csVector3 & pos, float rot);
    
    void SetCamFlag(int flag, bool val);

    bool GetCamFlag(int flag);

    bool SetCurrEffect(const csString & name);
    
    csString GetCurrEffectName();

    csString GetCurrParticleSystemName();

    unsigned int GetCurrEffectID() { return currEffectID; }

    bool SetDefaultActorPositions();

    bool LoadMap(const char * mapFile);

    csVector2 GetMousePointer();

    void Exit();

    iObjectRegistry *       GetObjectRegistry() const;
    csRef<iEngine>          GetEngine() const;
    csRef<iVFS>             GetVFS() const;
    csRef<iEventQueue>      GetEventQueue() const;
    csRef<iConfigManager>   GetConfigManager() const;
    csRef<iTextureManager>  GetTextureManager() const;
    csRef<iGraphics3D>      GetGraphics3D() const;
    csRef<iGraphics2D>      GetGraphics2D() const;
    csRef<iVirtualClock>    GetVirtualClock() const;
    csRef<iLoader>          GetLoader() const;
    EEditReporter *         GetReporter() const;

    const char * GetConfigString(const char * key, const char * defaultValue) const;
    void         SetConfigString(const char * key, const char * value);

    float GetConfigFloat(const char * key, float defaultValue) const;
    void  SetConfigFloat(const char * key, float value);

    bool GetConfigBool(const char * key, bool defaultValue) const;
    void SetConfigBool(const char * key, bool value);

    void ExecuteCommand(const char * cmd);

private:

    bool CreateEffectPathList(const csString & path, bool clear=true);

    bool AppendEffectPathList(const csString & effectFile, const csString & sourcePath);
    
    void CreateShortcuts();

    void RegisterFactories();

    void Update();

    void TakeScreenshot(const csString & fileName);
    
    DeclareGenericEventHandler(EventHandler,EEditApp,"planeshift.eedit");
    csRef<EventHandler> event_handler;

    EEditReporter *         reporter;

    iObjectRegistry*        object_reg;
    csRef<iEngine>          engine;
    csRef<iVFS>             vfs;
    csRef<iEventQueue>      queue;
    csRef<iConfigManager>   cfgmgr;
    csRef<iTextureManager>  txtmgr;
    csRef<iGraphics3D>      g3d;
    csRef<iGraphics2D>      g2d;
    csRef<iVirtualClock>    vc;
    csRef<iLoader>          loader;

    // PAWS
    PawsManager    * paws;
    pawsMainWidget * mainWidget;

    pawsEEdit            * editWindow;

    csString currEffectName;
    csString currEffectLoc;
    
    bool drawScreen;
   
    EEditToolboxManager * toolboxManager;
    EEditInputboxManager * inputboxManager;
    
    // effect stuff
    csRef<psEffectManager> effectManager;
    unsigned int currEffectID;
    bool effectLoaded;

    csRef<iMeshWrapper> particleSystem;

    csRef<iMeshWrapper> pos_anchor;
    
    csRef<iMeshWrapper> tar_anchor;
    
    bool effectPaused;

    // camera flags
    csBitArray camFlags;
    float camYaw;
    float camPitch;

    eControlManager * controlManager;

    struct EffectPath
    {
        EffectPath(const char * newName, const char * newPath) : name(newName), path(newPath) {}
        
        csString name;
        csString path;
    };
    csArray<EffectPath> effectPaths;

    csVector2 mousePointer;

    csRef<psCal3DCallbackLoader> cal3DCallbackLoader;
    
    csRandomFloatGen * rand;

};

#endif