IRenderTarget.hpp

// Copyright (C) 2015 Patryk Nadrowski
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in nirtcpp/nirtcpp.hpp
 
#ifndef NIRT_I_RENDER_TARGET_HPP_INCLUDED
#define NIRT_I_RENDER_TARGET_HPP_INCLUDED
 
#include <nirtcpp/core/engine/IReferenceCounted.hpp>
#include <nirtcpp/core/engine/EDriverTypes.hpp>
#include <nirtcpp/core/engine/irrArray.hpp>
 
namespace nirt
{
namespace video
{
    class ITexture;
 
    enum E_CUBE_SURFACE
    {
        ECS_POSX  = 0,
        ECS_NEGX,
        ECS_POSY,
        ECS_NEGY,
        ECS_POSZ, 
        ECS_NEGZ
    };
 
    class IRenderTarget : public virtual IReferenceCounted
    {
    public:
 
        IRenderTarget() : DepthStencil(0), DriverType(EDT_NULL)
        {
        }
 
        const core::array<ITexture*>& getTexture() const
        {
            return Textures;
        }
 
        ITexture* getDepthStencil() const
        {
            return DepthStencil;
        }
 
        const core::array<E_CUBE_SURFACE>& getCubeSurfaces() const
        {
            return CubeSurfaces;
        }
 
 
        void setTexture(const core::array<ITexture*>& texture, ITexture* depthStencil, const core::array<E_CUBE_SURFACE>& cubeSurfaces = core::array<E_CUBE_SURFACE>())
        {
            setTextures(texture.const_pointer(), texture.size(), depthStencil, cubeSurfaces.const_pointer(), cubeSurfaces.size());
        }
 
        void setTexture(ITexture* texture, ITexture* depthStencil)
        {
            if ( texture )
            {
                setTextures(&texture, 1, depthStencil);
            }
            else
            {
                setTextures(0, 0, depthStencil);
            }
        }
 
        void setTexture(ITexture* texture, ITexture* depthStencil, E_CUBE_SURFACE cubeSurface)
        {
            if ( texture )
            {
                setTextures(&texture, 1, depthStencil, &cubeSurface, 1);
            }
            else
            {
                setTextures(0, 0, depthStencil, &cubeSurface, 1);
            }
        }
 
        E_DRIVER_TYPE getDriverType() const
        {
            return DriverType;
        }
 
    protected:
 
        // NOTE: working with pointers instead of arrays to avoid unnecessary memory allocations for the single textures case
        virtual void setTextures(ITexture* const * textures, u32 numTextures, ITexture* depthStencil, const E_CUBE_SURFACE* cubeSurfaces=0, u32 numCubeSurfaces=0) = 0;
 
        core::array<ITexture*> Textures;
 
        ITexture* DepthStencil;
 
        core::array<E_CUBE_SURFACE> CubeSurfaces;
 
        E_DRIVER_TYPE DriverType;
 
    private:
        // no copying (IReferenceCounted still allows that for reasons which take some time to work around)
        IRenderTarget(const IRenderTarget&);
        IRenderTarget& operator=(const IRenderTarget&);
    };
 
}
}
 
#endif