buffer-provider.hpp

Go to the documentation of this file.

/*
  BUFFER-PROVIDER.hpp  -  Abstraction for Buffer management during playback/render

  Copyright (C)         Lumiera.org
    2011,               Hermann Vosseler <Ichthyostega@web.de>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of
  the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef STEAM_ENGINE_BUFFR_PROVIDER_H
#define STEAM_ENGINE_BUFFR_PROVIDER_H


#include "lib/error.hpp"
#include "lib/symbol.hpp"
#include "lib/hash-value.h"
#include "steam/engine/buffhandle.hpp"
#include "steam/engine/type-handler.hpp"
#include "steam/engine/buffer-local-key.hpp"
#include "lib/nocopy.hpp"

#include <memory>


namespace steam {
namespace engine {
  
  using lib::Literal;
  using std::unique_ptr;
  
  
  class BufferMetadata;
  
  
  LUMIERA_ERROR_DECLARE (BUFFER_MANAGEMENT); 
  
  
  class BufferProvider
    : util::NonCopyable
    {
      unique_ptr<BufferMetadata> meta_;
      
      
    protected: /* === for Implementation by concrete providers === */
      
      BufferProvider (Literal implementationID);
      
      virtual uint prepareBuffers (uint count, HashVal typeID)    =0;
      
      virtual BuffHandle provideLockedBuffer  (HashVal typeID)    =0;
      virtual void mark_emitted (HashVal typeID, LocalKey const&) =0;
      virtual void detachBuffer (HashVal typeID, LocalKey const&) =0;
      
      
    public:
      virtual ~BufferProvider();  
      
      
      uint announce (uint count, BufferDescriptor const&);
      
      BuffHandle lockBuffer (BufferDescriptor const&);
      void       emitBuffer (BuffHandle const&);
      void    releaseBuffer (BuffHandle const&);
      
      template<typename BU>
      BuffHandle lockBufferFor ();
      
      void attachTypeHandler (BuffHandle const& target, BufferDescriptor const& reference);
      
      void emergencyCleanup (BuffHandle const& target, bool invokeDtor =false);
      
      
      BufferDescriptor getDescriptorFor(size_t storageSize=0);
      BufferDescriptor getDescriptorFor(size_t storageSize, TypeHandler specialTreatment);
      
      template<typename BU>
      BufferDescriptor getDescriptor();
      
      
      
      /* === API for BuffHandle internal access === */
      
      bool verifyValidity (BufferDescriptor const&)  const;
      size_t getBufferSize (HashVal typeID)          const;
      
    protected:
      BuffHandle buildHandle (HashVal typeID, void* storage, LocalKey const&);
      
      bool was_created_by_this_provider (BufferDescriptor const&)  const;
    };
  
  
  
  
  /* === Implementation === */
  
  template<typename BU>
  BuffHandle
  BufferProvider::lockBufferFor()
  {
    BufferDescriptor attach_object_automatically = getDescriptor<BU>();
    return lockBuffer (attach_object_automatically);
  }
  
  
  template<typename BU>
  BufferDescriptor
  BufferProvider::getDescriptor()
  {
    return getDescriptorFor (sizeof(BU), TypeHandler::create<BU>());
  }
  
  
}} // namespace steam::engine
#endif