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 GrGpuCommandBuffer()56 GrGpuCommandBuffer() {} ~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