drawTarget.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_IMAGING_GLF_DRAW_TARGET_H
#define PXR_IMAGING_GLF_DRAW_TARGET_H


#include "pxr/pxr.h"
#include "pxr/imaging/glf/api.h"
#include "pxr/imaging/glf/texture.h"
#include "pxr/imaging/garch/glApi.h"

#include "pxr/base/gf/vec2i.h"
#include "pxr/base/gf/matrix4d.h"
#include "pxr/base/tf/declarePtrs.h"
#include "pxr/base/tf/refBase.h"
#include "pxr/base/tf/weakBase.h"

#include <map>
#include <memory>
#include <set>
#include <string>


PXR_NAMESPACE_OPEN_SCOPE


TF_DECLARE_WEAK_AND_REF_PTRS(GlfDrawTarget);
typedef std::shared_ptr<class GlfGLContext> GlfGLContextSharedPtr;

class GlfDrawTarget : public TfRefBase, public TfWeakBase {
public:
    typedef GlfDrawTarget This;

public:
    
    GLF_API
    static GlfDrawTargetRefPtr New( GfVec2i const & size, 
                                    bool requestMSAA = false );

    GLF_API
    static GlfDrawTargetRefPtr New( GlfDrawTargetPtr const & drawtarget );

    class Attachment : public GlfTexture {
    public:
        typedef TfDeclarePtrs<class Attachment>::RefPtr AttachmentRefPtr;

        GLF_API
        static AttachmentRefPtr New(int glIndex, GLenum format, GLenum type,
                                    GLenum internalFormat, GfVec2i size,
                                    unsigned int numSamples);

        GLF_API
        ~Attachment() override;

        GLuint GetGlTextureName() override;

        GLuint GetGlTextureMSName() const { return _textureNameMS; }

        GLenum GetFormat() const { return _format; }

        GLenum GetType() const { return _type; }

        GLenum GetInternalFormat() const { return _internalFormat; }

        int GetAttach() const { return _glIndex; }

        GLF_API
        void ResizeTexture(const GfVec2i &size);

        // GlfTexture overrides
        GLF_API
        BindingVector GetBindings(TfToken const & identifier,
                                          GLuint samplerName) override;
        GLF_API
        VtDictionary GetTextureInfo(bool forceLoad) override;

        GLF_API
        void TouchContents();

    private:
        Attachment(int glIndex, GLenum format, GLenum type,
                   GLenum internalFormat, GfVec2i size, 
                   unsigned int numSamples);

        void _GenTexture();
        void _DeleteTexture();

        GLuint       _textureName;
        GLuint       _textureNameMS;

        GLenum       _format,
                     _type,
                     _internalFormat;

        int          _glIndex;

        GfVec2i      _size;

        unsigned int _numSamples;
    };

    typedef TfDeclarePtrs<class Attachment>::RefPtr AttachmentRefPtr;

    typedef std::map<std::string, AttachmentRefPtr> AttachmentsMap;
    
    GLF_API
    void AddAttachment( std::string const & name, 
                        GLenum format, GLenum type, GLenum internalFormat );

    GLF_API
    void DeleteAttachment( std::string const & name );
    
    GLF_API
    void ClearAttachments();
    
    GLF_API
    void CloneAttachments( GlfDrawTargetPtr const & drawtarget );
    
    GLF_API
    AttachmentsMap const & GetAttachments() const;
    
    GLF_API
    AttachmentRefPtr GetAttachment(std::string const & name);
    
    GLF_API
    bool WriteToFile(std::string const & name,
                     std::string const & filename,
                     GfMatrix4d const & viewMatrix = GfMatrix4d(1),
                     GfMatrix4d const & projectionMatrix = GfMatrix4d(1));

    GLF_API
    void SetSize( GfVec2i );    

    GfVec2i const & GetSize() const { return _size; }

    bool HasMSAA() const { return (_numSamples > 1); }

    GLF_API
    GLuint GetFramebufferId() const;
    
    GLF_API
    GLuint GetFramebufferMSId() const;

    GLF_API
    void Bind();

    GLF_API
    void Unbind();

    GLF_API
    bool IsBound() const;

    GLF_API
    void Resolve();

    GLF_API
    static void Resolve(const std::vector<GlfDrawTarget*>& drawTargets);

    GLF_API
    void TouchContents();

    GLF_API
    bool IsValid(std::string * reason = NULL);

protected:

    class AttachmentsContainer : public TfRefBase, public TfWeakBase {
    public:
        AttachmentsMap attachments;
    };

    GLF_API
    GlfDrawTarget( GfVec2i const & size, bool requestMSAA );

    GLF_API
    GlfDrawTarget( GlfDrawTargetPtr const & drawtarget );

    GLF_API
    virtual ~GlfDrawTarget();

private:
    void _GenFrameBuffer();

    void _BindAttachment( GlfDrawTarget::AttachmentRefPtr const & a );
    
    GLuint _AllocAttachment( GLenum format, GLenum type );

    AttachmentsMap & _GetAttachments() const;

    void _DeleteAttachments( );
    
    void _AllocDepth( );

    bool _Validate(std::string * reason = NULL);

    void _SaveBindingState();

    void _RestoreBindingState();

    void _Resolve();

    GLuint _framebuffer;
    GLuint _framebufferMS;
    
    GLuint _unbindRestoreReadFB,
           _unbindRestoreDrawFB;

    int _bindDepth;

    GfVec2i _size;
    
    unsigned int _numSamples;

    TfRefPtr<AttachmentsContainer> _attachmentsPtr;
    GlfGLContextSharedPtr _owningContext;
};


PXR_NAMESPACE_CLOSE_SCOPE

#endif  // GLF_DRAW_TARGET_H