canvas/inc/rendering/irendermodule.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #pragma once
  21
  22 #include <memory>
  23 #include <utility>
  24
  25 namespace basegfx
  26 {
  27     class B2IVector;
  28 }
  29
  30 namespace canvas
  31 {
  32     struct ISurface;
  33
  34     struct Vertex
  35     {
  36         float r,g,b,a;
  37         float u,v;
  38         float x,y,z;
  39     };
  40
  41     /** Output module interface for backend render implementations.
  42
  43         Implement this interface for each operating system- or
  44         library-specific rendering backend, which needs coupling with
  45         the canvas rendering framework (which can be shared between
  46         all backend implementations).
  47      */
  48     struct IRenderModule
  49     {
  50         /** Type of primitive passed to the render module via
  51             pushVertex()
  52          */
  53         enum class PrimitiveType
  54         {
  55             Unknown,
  56             Triangle,
  57             Quad
  58         };
  59
  60         virtual ~IRenderModule() {}
  61
  62         /// Lock rendermodule against concurrent access
  63         virtual void lock() const = 0;
  64
  65         /// Unlock rendermodule for concurrent access
  66         virtual void unlock() const = 0;
  67
  68         /** Maximal size of VRAM pages available
  69
  70             This is typically the maximum texture size of the
  71             hardware, or some arbitrary limit if the backend is
  72             software.
  73          */
  74         virtual ::basegfx::B2IVector getPageSize() = 0;
  75
  76         /** Create a (possibly hardware-accelerated) surface
  77
  78             @return a pointer to a surface, which is an abstraction of
  79             a piece of (possibly hardware-accelerated) texture memory.
  80          */
  81         virtual std::shared_ptr<ISurface> createSurface( const ::basegfx::B2IVector& surfaceSize ) = 0;
  82
  83         /** Begin rendering the given primitive.
  84
  85             Each beginPrimitive() call must be matched with an
  86             endPrimitive() call.
  87          */
  88         virtual void      beginPrimitive( PrimitiveType eType ) = 0;
  89
  90         /** Finish rendering a primitive.
  91
  92             Each beginPrimitive() call must be matched with an
  93             endPrimitive() call.
  94          */
  95         virtual void      endPrimitive() = 0;
  96
  97         /** Add given vertex to current primitive
  98
  99             After issuing a beginPrimitive(), each pushVertex() adds a
 100             vertex to the active primitive.
 101          */
 102         virtual void      pushVertex( const Vertex& vertex ) = 0;
 103
 104         /** Query error status
 105
 106             @returns true, if an error occurred during primitive
 107             construction.
 108          */
 109         virtual bool      isError() = 0;
 110     };
 111
 112     /// Little RAII wrapper for guarding access to IRenderModule interface
 113     class RenderModuleGuard
 114     {
 115     public:
 116         explicit RenderModuleGuard( std::shared_ptr<IRenderModule> xRenderModule ) :
 117             mpRenderModule(std::move( xRenderModule ))
 118         {
 119             mpRenderModule->lock();
 120         }
 121
 122         ~RenderModuleGuard()
 123         {
 124             mpRenderModule->unlock();
 125         }
 126
 127         RenderModuleGuard(const RenderModuleGuard&) = delete;
 128         RenderModuleGuard& operator=( const RenderModuleGuard& ) = delete;
 129     private:
 130         const std::shared_ptr<IRenderModule> mpRenderModule;
 131     };
 132 }
 133
 134 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */