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