D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Platform/spSoftPixelDevice.hpp

Go to the documentation of this file.

/*
 * SoftPixelDevice header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_SOFTPIXELDEVICE_H__
#define __SP_SOFTPIXELDEVICE_H__


#include "Base/spStandard.hpp"
#include "Base/spDimension.hpp"
#include "Base/spInputOutput.hpp"
#include "RenderSystem/spRenderSystem.hpp"
#include "RenderSystem/spRenderContext.hpp"
#include "SceneGraph/spSceneManager.hpp"
#include "SceneGraph/spSceneGraph.hpp"
#include "SceneGraph/spSceneGraphSimple.hpp"
#include "SceneGraph/spSceneGraphSimpleStream.hpp"
#include "SceneGraph/spSceneGraphFamilyTree.hpp"
#include "SoundSystem/spSoundDevice.hpp"
#include "Platform/spSoftPixelDeviceFlags.hpp"
#include "Framework/Physics/spPhysicsSimulator.hpp"
#include "Framework/Network/spNetworkStructures.hpp"

#if defined(SP_PLATFORM_ANDROID)
#   include "Platform/Android/android_native_app_glue.h"
#endif


namespace sp
{


/*
 * Declarations
 */

namespace gui
{
    class GUIManager;
}

namespace scene
{
    class CollisionGraph;
};

#ifdef SP_COMPILE_WITH_NETWORKSYSTEM
namespace network
{
    class NetworkSystem;
}
#endif

#ifdef SP_COMPILE_WITH_CG
namespace video
{
    class CgShaderContext;
}
#endif


class SP_EXPORT SoftPixelDevice
{
    
    public:
        
        virtual ~SoftPixelDevice();
        
        /* === Functions === */
        
        video::RenderSystem* getRenderSystem() const;
        video::RenderContext* getRenderContext() const;
        
        scene::SceneManager* getSceneManager() const;
        
        io::InputControl* getInputControl() const;
        io::OSInformator* getOSInformator() const;
        
        gui::GUIManager* getGUIManager() const;
        
        audio::SoundDevice* createSoundDevice(const audio::ESoundDevices Type = audio::SOUNDDEVICE_AUTODETECT);
        void deleteSoundDevice(audio::SoundDevice* SoundDevice);
        
        #ifdef SP_COMPILE_WITH_PHYSICS

        physics::PhysicsSimulator* createPhysicsSimulator(const physics::EPhysicsSimulators Type);
        void deletePhysicsSimulator(physics::PhysicsSimulator* Simulator);
        #endif
        
        #ifdef SP_COMPILE_WITH_NETWORKSYSTEM

        network::NetworkSystem* createNetworkSystem(const network::ENetworkSystems Type);
        void deleteNetworkSystem(network::NetworkSystem* NetSys);
        #endif
        
        #ifdef SP_COMPILE_WITH_CG

        video::CgShaderContext* createCgShaderContext();
        void deleteCgShaderContext();
        #endif
        
        scene::SceneGraph* createSceneGraph(const scene::ESceneGraphs Type = scene::SCENEGRAPH_SIMPLE);
        void deleteSceneGraph(scene::SceneGraph* SceneGraph);
        
        template <class T> T* createSceneGraph()
        {
            T* NewSceneGraph = new T();
            
            SceneGraphList_.push_back(NewSceneGraph);
            setActiveSceneGraph(NewSceneGraph);
            
            return NewSceneGraph;
        }
        
        scene::CollisionGraph* createCollisionGraph();
        void deleteCollisionGraph(scene::CollisionGraph* CollGraph);
        
        video::RenderContext* createRenderContext(
            void* ParentWindow, const dim::size2di &Resolution, const io::stringc &Title = ""
        );
        
        void deleteRenderContext(video::RenderContext* Context);
        
        virtual bool updateDeviceSettings(
            const dim::size2di &Resolution, s32 ColorDepth = DEF_COLORDEPTH, bool isFullscreen = false,
            const SDeviceFlags &Flags = SDeviceFlags(), void* ParentWindow = 0
        );
        
        virtual bool updateEvents() = 0;
        
        void updateBaseEvents();
        
        void setActiveSceneGraph(scene::SceneGraph* ActiveSceneGraph);
        scene::SceneGraph* getActiveSceneGraph() const;
        
        virtual void setFrameRate(u32 FrameRate = DEF_FRAMERATE);
        
        virtual io::stringc getVersion() const;
        
        virtual void beep(u32 Milliseconds = 100, u32 Frequency = 1000);
        
        virtual void manipulateScreenSize(const dim::size2di &ScreenSize);
        
        virtual s32 registerFontResource(const io::stringc &Filename);
        virtual void unregisterFontResource(const io::stringc &Filename);
        
        /* === Inline functions === */
        
        inline dim::size2di getResolution() const
        {
            return Resolution_;
        }
        
        inline SDeviceFlags getFlags() const
        {
            return Flags_;
        }
        
        #ifdef SP_COMPILE_WITH_NETWORKSYSTEM
        
        inline const std::list<network::NetworkSystem*>& getNetworkSystemList() const
        {
            return NetworkSystemList_;
        }
        
        #endif
        
    protected:
        
        /* === Functions === */
        
        SoftPixelDevice(
            const video::ERenderSystems RendererType, const dim::size2di &Resolution,
            s32 ColorDepth, bool isFullscreen, const SDeviceFlags &Flags
        );
        
        virtual void autoDetectRenderSystem();
        virtual bool checkRenderSystem(const video::ERenderSystems Type) const;
        
        virtual bool createRenderSystemAndContext();
        virtual video::RenderSystem* allocRenderSystem();
        virtual video::RenderContext* allocRenderContext();
        
        virtual void deleteResourceDevices();
        virtual void releaseGraphicsContext();
        
        virtual void printConsoleHeader();
        
        #ifdef SP_COMPILE_WITH_SOUNDSYSTEM
        audio::SoundDevice* allocSoundDevice(audio::ESoundDevices DeviceType) const;
        #endif
        
        /* === Members === */
        
        video::ERenderSystems RendererType_;
        dim::size2di Resolution_;
        s32 ColorDepth_;
        bool isFullscreen_;
        SDeviceFlags Flags_;
        
        u32 FrameRate_;
        
        scene::SceneGraph* DefaultSceneManager_;
        
        std::list<video::RenderContext*> RenderContextList_;
        std::list<audio::SoundDevice*> SoundDeviceList_;
        std::list<scene::SceneGraph*> SceneGraphList_;
        std::list<scene::CollisionGraph*> CollGraphList_;
        
        #ifdef SP_COMPILE_WITH_PHYSICS
        std::list<physics::PhysicsSimulator*> PhysicsSimulatorList_;
        #endif
        #ifdef SP_COMPILE_WITH_NETWORKSYSTEM
        std::list<network::NetworkSystem*> NetworkSystemList_;
        #endif
        
};


/*
 * Global functions
 */

#if defined(SP_PLATFORM_ANDROID)
SP_EXPORT SoftPixelDevice* createGraphicsDevice(
    android_app* App, const video::ERenderSystems RendererType, const io::stringc &Title = "",
    const bool isFullscreen = false, const u32 SDKVersion = SP_SDK_VERSION
);
#elif defined(SP_PLATFORM_IOS)
SP_EXPORT SoftPixelDevice* createGraphicsDevice(
    const video::ERenderSystems RendererType, const io::stringc &Title = "",
    const bool isFullscreen = false, const u32 SDKVersion = SP_SDK_VERSION
);
#else
SP_EXPORT SoftPixelDevice* createGraphicsDevice(
    const video::ERenderSystems RendererType, const dim::size2di &Resolution,
    const s32 ColorDepth = DEF_COLORDEPTH, const io::stringc &Title = "", const bool isFullscreen = false,
    const SDeviceFlags &Flags = SDeviceFlags(), void* ParentWindow = 0, const u32 SDKVersion = SP_SDK_VERSION
);
#endif

SP_EXPORT void deleteDevice();


} // /namespace sp


#endif



// ================================================================================