irrlicht1.7.0(2):基础接口

IEventReceiver.h

定义了irrlicht引擎中的事件类型（struct SEvent）和事件接口（class IEventReceiver）

struct SEvent
{
    EEVENT_TYPE EventType;
    union
    {
        struct SGUIEvent GUIEvent;　　　　　　　　　　//UI响应事件
        struct SMouseInput MouseInput;　　　　　　　 //鼠标输入事件
        struct SKeyInput KeyInput;　　　　　　　　　　//键盘输入事件
        struct SJoystickEvent JoystickEvent;　　　　//控制杆输入事件
        struct SLogEvent LogEvent;　　　　　　　　　 //日志事件
        struct SUserEvent UserEvent;　　　　　　　　　//用户自定义事件
    };
//! irrlicht用户自定义事件使用的是两个整型
//! 通过转型可以用作指针和其他类型
struct SUserEvent
{
    //! Some user specified data as int
    s32 UserData1;

    //! Another user specified data as int
    s32 UserData2;
};
};

ILogger.h

提供了简单的日志输出接口，并定义了日志消息的级别。

IOSOperator.h

提供了简单获取操作系统信息的接口。

class IOSOperator : public virtual IReferenceCounted
{
public:

    //! Destructor
    virtual ~IOSOperator() {}

    //! 去的操作系统版本（含操作系统名）
    virtual const wchar_t* getOperationSystemVersion() const = 0;

    //! 把text信息复制到剪贴板
    virtual void copyToClipboard(const c8* text) const = 0;

    //! 从剪贴板获取信息
    virtual const c8* getTextFromClipboard() const = 0;

    //! 获取处理器处理速度
    virtual bool getProcessorSpeedMHz(u32* MHz) const = 0;

    //! 获取机器内存总数和可用内存数
    virtual bool getSystemMemory(u32* Total, u32* Avail) const = 0;

};

//因为本人没有这方面的知识所以先看一下如何实现（COSOperator.h和COSOperator.cpp）

COSOperator.h

COSOperator.cpp

IReferenceCounted.h

普通的引用计数类

    class IReferenceCounted
    {
    public:

        //! Constructor.
        IReferenceCounted()
            : DebugName(0), ReferenceCounter(1)
        {
        }

        //! Destructor.
        virtual ~IReferenceCounted()
        {
        }

        void grab() const { ++ReferenceCounter; }

        
        bool drop() const
        {
            // someone is doing bad reference counting.
            _IRR_DEBUG_BREAK_IF(ReferenceCounter <= 0)

            --ReferenceCounter;
            if (!ReferenceCounter)
            {
                delete this;
                return true;
            }

            return false;
        }

        s32 getReferenceCount() const
        {
            return ReferenceCounter;
        }

        const c8* getDebugName() const
        {
            return DebugName;
        }

    protected:

        //! Sets the debug name of the object.
        /** The Debugname may only be set and changed by the object
        itself. This method should only be used in Debug mode.
        \param newName: New debug name to set. */
        void setDebugName(const c8* newName)
        {
            DebugName = newName;
        }

    private:

        const c8* DebugName;

        mutable s32 ReferenceCounter;
    };

ps：引用计数应设为mutable（const状态下仍可变），ReferenceCounter应为整型指针或把复制函数和复制构造函数设为私有防止复制以避免类复制后引用计数不同步（即使irrlicht仅提供接口，但难以避免用户继承并实现接口导致引用计数问题）

irrlicht.h

包含所有接口和常量定义

IrrlichtDevice.h

//控制游戏运行和窗口的接口

class IrrlichtDevice : public virtual IReferenceCounted
    {
    public:
　　　　　//控制游戏主线程
        virtual bool run() = 0;
        virtual void yield() = 0;
        virtual void sleep(u32 timeMs, bool pauseTimer=false) = 0;

　　　　　//取得各种组件
        virtual video::IVideoDriver* getVideoDriver() = 0;
        virtual io::IFileSystem* getFileSystem() = 0;
        virtual gui::IGUIEnvironment* getGUIEnvironment() = 0;
        virtual scene::ISceneManager* getSceneManager() = 0;
        virtual gui::ICursorControl* getCursorControl() = 0;
        virtual ILogger* getLogger() = 0;
        virtual video::IVideoModeList* getVideoModeList() = 0;
        virtual IOSOperator* getOSOperator() = 0;
        virtual ITimer* getTimer() = 0;

　　　　　//控制游戏窗口
        virtual void setWindowCaption(const wchar_t* text) = 0;
        virtual bool isWindowActive() const = 0;
        virtual bool isWindowFocused() const = 0;
        virtual bool isWindowMinimized() const = 0;
        virtual bool isFullscreen() const = 0;
 　　　　virtual void setResizable(bool resize=false) = 0;
　　　　 virtual void minimizeWindow() =0;
　　　　 virtual void maximizeWindow() =0;
　　　　 virtual void restoreWindow() =0;
　　　 //控制消息循环
　　　 virtualvoid setEventReceiver(IEventReceiver* receiver) = 0;
　　　 virtual IEventReceiver* getEventReceiver() = 0;
　　　 virtual bool postEventFromUser(const SEvent& event) = 0;
　　　 virtual void setInputReceivingSceneManager(scene::ISceneManager* sceneManager) = 0;
　　　 virtual void clearSystemMessages() = 0;
　　　　 //控制常规信息
　　　　 virtual video::ECOLOR_FORMAT getColorFormat() const = 0;
　　　　 virtualvoid closeDevice() = 0;
　　　　 virtual const c8* getVersion() const = 0;
　　　　 virtual bool activateJoysticks(core::array<SJoystickInfo>& joystickInfo) =0;
        //控制屏幕gamma值
　　　　 virtual bool setGammaRamp(f32 red, f32 green, f32 blue,
                    f32 relativebrightness, f32 relativecontrast) =0;
        virtual bool getGammaRamp(f32 &red, f32 &green, f32 &blue,
                    f32 &brightness, f32 &contrast) =0;
        virtual E_DEVICE_TYPE getType() const = 0;
        static bool isDriverSupported(video::E_DRIVER_TYPE driver)
        {
            switch (driver)
            {
                case video::EDT_NULL:
                    return true;
                case video::EDT_SOFTWARE:
#ifdef _IRR_COMPILE_WITH_SOFTWARE_
                    return true;
#else
                    return false;
#endif
                case video::EDT_BURNINGSVIDEO:
#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
                    return true;
#else
                    return false;
#endif
                case video::EDT_DIRECT3D8:
#ifdef _IRR_COMPILE_WITH_DIRECT3D_8_
                    return true;
#else
                    return false;
#endif
                case video::EDT_DIRECT3D9:
#ifdef _IRR_COMPILE_WITH_DIRECT3D_9_
                    return true;
#else
                    return false;
#endif
                case video::EDT_OPENGL:
#ifdef _IRR_COMPILE_WITH_OPENGL_
                    return true;
#else
                    return false;
#endif
                default:
                    return false;
            }
        }
    };

ITimer.h

//控制游戏的时间类（irrlicht缺少一个时钟事件）

//构想：以一个真实时钟作为游戏运行的主时钟，在主时钟上可以套接多个自定义时钟（拥有一个主时钟指针，来共享主时钟循环）

class ITimer : public virtual IReferenceCounted
{
public:

    //! destructor
    virtual ~ITimer() {}

    virtual u32 getRealTime() const = 0;

    virtual u32 getTime() const = 0;

    virtual void setTime(u32 time) = 0;

    virtual void stop() = 0;

    virtual void start() = 0;

    virtual void setSpeed(f32 speed = 1.0f) = 0;

    virtual f32 getSpeed() const = 0;

    virtual bool isStopped() const = 0;

    virtual void tick() = 0;
};

Keycodes.h

//定义了irrlicht的虚拟键

SIrrCreationParameters.h

//定义了创建irrDevice所需要的属性和默认值

struct SIrrlichtCreationParameters
    {
        //! Constructs a SIrrlichtCreationParameters structure with default values.
        SIrrlichtCreationParameters() :
            DeviceType(EIDT_BEST),
            DriverType(video::EDT_BURNINGSVIDEO),
            WindowSize(core::dimension2d<u32>(800, 600)),
            Bits(16),
            ZBufferBits(16),
            Fullscreen(false),
            Stencilbuffer(false),
            Vsync(false),
            AntiAlias(0),
            WithAlphaChannel(false),
            Doublebuffer(true),
            IgnoreInput(false),
            Stereobuffer(false),
            HighPrecisionFPU(false),
            EventReceiver(0),
            WindowId(0),
            LoggingLevel(ELL_INFORMATION),
            SDK_version_do_not_use(IRRLICHT_SDK_VERSION)
        {
        }

        SIrrlichtCreationParameters(const SIrrlichtCreationParameters& other) :
            SDK_version_do_not_use(IRRLICHT_SDK_VERSION)
        {*this = other;}

        SIrrlichtCreationParameters& operator=(const SIrrlichtCreationParameters& other)
        {
            DeviceType = other.DeviceType;
            DriverType = other.DriverType;
            WindowSize = other.WindowSize;
            Bits = other.Bits;
            ZBufferBits = other.ZBufferBits;
            Fullscreen = other.Fullscreen;
            Stencilbuffer = other.Stencilbuffer;
            Vsync = other.Vsync;
            AntiAlias = other.AntiAlias;
            WithAlphaChannel = other.WithAlphaChannel;
            Doublebuffer = other.Doublebuffer;
            IgnoreInput = other.IgnoreInput;
            Stereobuffer = other.Stereobuffer;
            HighPrecisionFPU = other.HighPrecisionFPU;
            EventReceiver = other.EventReceiver;
            WindowId = other.WindowId;
            LoggingLevel = other.LoggingLevel;
            return *this;
        }

        //! Type of the device.
        /** This setting decides the windowing system used by the device, most device types are native
        to a specific operating system and so may not be available.
        EIDT_WIN32 is only available on Windows desktops,
        EIDT_WINCE is only available on Windows mobile devices,
        EIDT_COCOA is only available on Mac OSX,
        EIDT_X11 is available on Linux, Solaris, BSD and other operating systems which use X11,
        EIDT_SDL is available on most systems if compiled in,
        EIDT_CONSOLE is usually available but can only render to text,
        EIDT_BEST will select the best available device for your operating system.
        Default: EIDT_BEST. */
        E_DEVICE_TYPE DeviceType;

        //! Type of video driver used to render graphics.
        /** This can currently be video::EDT_NULL, video::EDT_SOFTWARE,
        video::EDT_BURNINGSVIDEO, video::EDT_DIRECT3D8,
        video::EDT_DIRECT3D9, and video::EDT_OPENGL.
        Default: Software. */
        video::E_DRIVER_TYPE DriverType;

        //! Size of the window or the video mode in fullscreen mode. Default: 800x600
        core::dimension2d<u32> WindowSize;

        //! Minimum Bits per pixel of the color buffer in fullscreen mode. Ignored if windowed mode. Default: 16.
        u8 Bits;

        //! Minimum Bits per pixel of the depth buffer. Default: 16.
        u8 ZBufferBits;

        //! Should be set to true if the device should run in fullscreen.
        /** Otherwise the device runs in windowed mode. Default: false. */
        bool Fullscreen;

        //! Specifies if the stencil buffer should be enabled.
        /** Set this to true, if you want the engine be able to draw
        stencil buffer shadows. Note that not all drivers are able to
        use the stencil buffer, hence it can be ignored during device
        creation. Without the stencil buffer no shadows will be drawn.
        Default: false. */
        bool Stencilbuffer;

        //! Specifies vertical syncronisation.
        /** If set to true, the driver will wait for the vertical
        retrace period, otherwise not. May be silently ignored.
        Default: false */
        bool Vsync;

        //! Specifies if the device should use fullscreen anti aliasing
        /** Makes sharp/pixelated edges softer, but requires more
        performance. Also, 2D elements might look blurred with this
        switched on. The resulting rendering quality also depends on
        the hardware and driver you are using, your program might look
        different on different hardware with this. So if you are
        writing a game/application with AntiAlias switched on, it would
        be a good idea to make it possible to switch this option off
        again by the user.
        The value is the maximal antialiasing factor requested for
        the device. The cretion method will automatically try smaller
        values if no window can be created with the given value.
        Value one is usually the same as 0 (disabled), but might be a
        special value on some platforms. On D3D devices it maps to
        NONMASKABLE.
        Default value: 0 - disabled */
        u8 AntiAlias;

        //! Whether the main framebuffer uses an alpha channel.
        /** In some situations it might be desireable to get a color
        buffer with an alpha channel, e.g. when rendering into a
        transparent window or overlay. If this flag is set the device
        tries to create a framebuffer with alpha channel.
        If this flag is set, only color buffers with alpha channel
        are considered. Otherwise, it depends on the actual hardware
        if the colorbuffer has an alpha channel or not.
        Default value: false */
        bool WithAlphaChannel;

        //! Whether the main framebuffer uses doublebuffering.
        /** This should be usually enabled, in order to avoid render
        artifacts on the visible framebuffer. However, it might be
        useful to use only one buffer on very small devices. If no
        doublebuffering is available, the drivers will fall back to
        single buffers. Default value: true */
        bool Doublebuffer;

        //! Specifies if the device should ignore input events
        /** This is only relevant when using external I/O handlers.
        External windows need to take care of this themselves.
        Currently only supported by X11.
        Default value: false */
        bool IgnoreInput;

        //! Specifies if the device should use stereo buffers
        /** Some high-end gfx cards support two framebuffers for direct
        support of stereoscopic output devices. If this flag is set the
        device tries to create a stereo context.
        Currently only supported by OpenGL.
        Default value: false */
        bool Stereobuffer;

        //! Specifies if the device should use high precision FPU setting
        /** This is only relevant for DirectX Devices, which switch to
        low FPU precision by default for performance reasons. However,
        this may lead to problems with the other computations of the
        application. In this case setting this flag to true should help
        - on the expense of performance loss, though.
        Default value: false */
        bool HighPrecisionFPU;

        //! A user created event receiver.
        IEventReceiver* EventReceiver;

        //! Window Id.
        /** If this is set to a value other than 0, the Irrlicht Engine
        will be created in an already existing window. For windows, set
        this to the HWND of the window you want. The windowSize and
        FullScreen options will be ignored when using the WindowId
        parameter. Default this is set to 0.
        To make Irrlicht run inside the custom window, you still will
        have to draw Irrlicht on your own. You can use this loop, as
        usual:
        \code
        while (device->run())
        {
            driver->beginScene(true, true, 0);
            smgr->drawAll();
            driver->endScene();
        }
        \endcode
        Instead of this, you can also simply use your own message loop
        using GetMessage, DispatchMessage and whatever. Calling
        IrrlichtDevice::run() will cause Irrlicht to dispatch messages
        internally too.  You need not call Device->run() if you want to
        do your own message dispatching loop, but Irrlicht will not be
        able to fetch user input then and you have to do it on your own
        using the window messages, DirectInput, or whatever. Also,
        you'll have to increment the Irrlicht timer.
        An alternative, own message dispatching loop without
        device->run() would look like this:
        \code
        MSG msg;
        while (true)
        {
            if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);

                if (msg.message == WM_QUIT)
                    break;
            }

            // increase virtual timer time
            device->getTimer()->tick();

            // draw engine picture
            driver->beginScene(true, true, 0);
            smgr->drawAll();
            driver->endScene();
        }
        \endcode
        However, there is no need to draw the picture this often. Just
        do it how you like. */
        void* WindowId;

        //! Specifies the logging level used in the logging interface.
        /** The default value is ELL_INFORMATION. You can access the ILogger interface
        later on from the IrrlichtDevice with getLogger() and set another level.
        But if you need more or less logging information already from device creation,
        then you have to change it here.
        */
        ELOG_LEVEL LoggingLevel;

        //! Don't use or change this parameter.
        /** Always set it to IRRLICHT_SDK_VERSION, which is done by default.
        This is needed for sdk version checks. */
        const c8* const SDK_version_do_not_use;
    };