Home | History | Annotate | Download | only in gpu 
      1 /*
      2 * Copyright 2016 Google Inc.
      3 *
      4 * Use of this source code is governed by a BSD-style license that can be
      5 * found in the LICENSE file.
      6 */
      7 
      8 #ifndef GrGpuCommandBuffer_DEFINED
      9 #define GrGpuCommandBuffer_DEFINED
     10 
     11 #include "GrColor.h"
     12 #include "GrPipeline.h"
     13 #include "ops/GrDrawOp.h"
     14 
     15 class GrOpFlushState;
     16 class GrFixedClip;
     17 class GrGpu;
     18 class GrMesh;
     19 class GrPipeline;
     20 class GrPrimitiveProcessor;
     21 class GrRenderTarget;
     22 struct SkIRect;
     23 struct SkRect;
     24 
     25 /**
     26  * The GrGpuCommandBuffer is a series of commands (draws, clears, and discards), which all target
     27  * the same render target. It is possible that these commands execute immediately (GL), or get
     28  * buffered up for later execution (Vulkan). GrOps will execute their draw commands into a
     29  * GrGpuCommandBuffer.
     30  *
     31  * Ideally we'd know the GrRenderTarget, or at least its properties when the GrGpuCommandBuffer, is
     32  * created. We also then wouldn't include it in the GrPipeline or as a parameter to the clear and
     33  * discard methods. The logical place for that will be in GrRenderTargetOpList post-MDB. For now
     34  * the render target is redundantly passed to each operation, though it will always be the same
     35  * render target for a given command buffer even pre-MDB.
     36  */
     37 class GrGpuCommandBuffer {
     38 public:
     39     enum class LoadOp {
     40         kLoad,
     41         kClear,
     42         kDiscard,
     43     };
     44 
     45     enum class StoreOp {
     46         kStore,
     47         kDiscard,
     48     };
     49 
     50     struct LoadAndStoreInfo {
     51         LoadOp  fLoadOp;
     52         StoreOp fStoreOp;
     53         GrColor fClearColor;
     54     };
     55 
     56     GrGpuCommandBuffer() {}
     57     virtual ~GrGpuCommandBuffer() {}
     58 
     59     // Signals the end of recording to the command buffer and that it can now be submitted.
     60     virtual void end() = 0;
     61 
     62     // Sends the command buffer off to the GPU object to execute the commands built up in the
     63     // buffer. The gpu object is allowed to defer execution of the commands until it is flushed.
     64     void submit();
     65 
     66     // We pass in an array of meshCount GrMesh to the draw. The backend should loop over each
     67     // GrMesh object and emit a draw for it. Each draw will use the same GrPipeline and
     68     // GrPrimitiveProcessor. This may fail if the draw would exceed any resource limits (e.g.
     69     // number of vertex attributes is too large).
     70     bool draw(const GrPipeline&,
     71               const GrPrimitiveProcessor&,
     72               const GrMesh[],
     73               const GrPipeline::DynamicState[],
     74               int meshCount,
     75               const SkRect& bounds);
     76 
     77     // Performs an upload of vertex data in the middle of a set of a set of draws
     78     virtual void inlineUpload(GrOpFlushState* state, GrDrawOp::DeferredUploadFn& upload,
     79                               GrRenderTarget* rt) = 0;
     80 
     81     /**
     82      * Clear the passed in render target. Ignores the draw state and clip.
     83      */
     84     void clear(GrRenderTarget*, const GrFixedClip&, GrColor);
     85 
     86     void clearStencilClip(GrRenderTarget*, const GrFixedClip&, bool insideStencilMask);
     87 
     88     /**
     89      * Discards the contents render target. nullptr indicates that the current render target should
     90      * be discarded.
     91      */
     92     // TODO: This should be removed in the future to favor using the load and store ops for discard
     93     virtual void discard(GrRenderTarget*) = 0;
     94 
     95 private:
     96     virtual GrGpu* gpu() = 0;
     97     virtual GrRenderTarget* renderTarget() = 0;
     98 
     99     virtual void onSubmit() = 0;
    100 
    101     // overridden by backend-specific derived class to perform the draw call.
    102     virtual void onDraw(const GrPipeline&,
    103                         const GrPrimitiveProcessor&,
    104                         const GrMesh[],
    105                         const GrPipeline::DynamicState[],
    106                         int meshCount,
    107                         const SkRect& bounds) = 0;
    108 
    109     // overridden by backend-specific derived class to perform the clear.
    110     virtual void onClear(GrRenderTarget*, const GrFixedClip&, GrColor) = 0;
    111 
    112     virtual void onClearStencilClip(GrRenderTarget*, const GrFixedClip&,
    113                                     bool insideStencilMask) = 0;
    114 
    115 };
    116 
    117 #endif
    118