1 /* 2 * Copyright 2021 Google LLC 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 skgpu_graphite_GraphiteTypes_DEFINED 9 #define skgpu_graphite_GraphiteTypes_DEFINED 10 11 #include "include/core/SkPoint.h" 12 #include "include/core/SkRect.h" 13 #include "include/core/SkTypes.h" 14 #include "include/gpu/GpuTypes.h" 15 16 #include <memory> 17 18 class SkSurface; 19 20 namespace skgpu { 21 class MutableTextureState; 22 } 23 24 namespace skgpu::graphite { 25 26 class BackendSemaphore; 27 class Recording; 28 class Task; 29 30 using GpuFinishedContext = void*; 31 using GpuFinishedProc = void (*)(GpuFinishedContext finishedContext, CallbackResult); 32 33 using GpuFinishedWithStatsProc = void (*)(GpuFinishedContext finishedContext, 34 CallbackResult, 35 const GpuStats&); 36 37 /** 38 * The fFinishedProc is called when the Recording has been submitted and finished on the GPU, or 39 * when there is a failure that caused it not to be submitted. The callback will always be called 40 * and the caller can use the callback to know it is safe to free any resources associated with 41 * the Recording that they may be holding onto. If the Recording is successfully submitted to the 42 * GPU the callback will be called with CallbackResult::kSuccess once the GPU has finished. All 43 * other cases where some failure occurred it will be called with CallbackResult::kFailed. 44 * 45 * Alternatively, the client can provide fFinishedProcWithStats. This provides additional 46 * information about execution of the recording on the GPU. Only the stats requested using 47 * fStatsFlags will be valid and only if CallbackResult is kSuccess. If both fFinishedProc 48 * and fFinishedProcWithStats are provided the latter is preferred and the former won't be 49 * called. 50 * 51 * The fTargetSurface, if provided, is used as a target for any draws recorded onto a deferred 52 * canvas returned from Recorder::makeDeferredCanvas. This target surface must be provided iff 53 * the Recording contains any such draws. It must be Graphite-backed and its backing texture's 54 * TextureInfo must match the info provided to the Recorder when making the deferred canvas. 55 * 56 * fTargetTranslation is an additional translation applied to draws targeting fTargetSurface. 57 * 58 * fTargetClip is an additional clip applied to draws targeting fTargetSurface. It is defined in the 59 * local replay space, that is, with fTargetTranslation applied. An empty clip will not be applied. 60 * 61 * The client may pass in two arrays of initialized BackendSemaphores to be included in the 62 * command stream. At some time before issuing commands in the Recording, the fWaitSemaphores will 63 * be waited on by the gpu. We only guarantee these wait semaphores block transfer and fragment 64 * shader work. Similarly, at some time after issuing the Recording's commands, the 65 * fSignalSemaphores will be signaled by the gpu. Depending on the platform, the timing of the wait 66 * and signal operations will either be immediately before or after the given Recording's command 67 * stream, respectively, or before and after the entire CommandBuffer's command stream. The 68 * semaphores are not sent to the GPU until the next Context::submit call is made. 69 * 70 * The client will own and be responsible for deleting the underlying semaphore objects after the 71 * submission completes, however the BackendSemaphore objects themselves can be deleted as soon 72 * as this function returns. 73 */ 74 struct InsertRecordingInfo { 75 Recording* fRecording = nullptr; 76 77 SkSurface* fTargetSurface = nullptr; 78 SkIVector fTargetTranslation = {0, 0}; 79 SkIRect fTargetClip = {0, 0, 0, 0}; 80 MutableTextureState* fTargetTextureState = nullptr; 81 82 size_t fNumWaitSemaphores = 0; 83 BackendSemaphore* fWaitSemaphores = nullptr; 84 size_t fNumSignalSemaphores = 0; 85 BackendSemaphore* fSignalSemaphores = nullptr; 86 87 GpuStatsFlags fGpuStatsFlags = GpuStatsFlags::kNone; 88 GpuFinishedContext fFinishedContext = nullptr; 89 GpuFinishedProc fFinishedProc = nullptr; 90 GpuFinishedWithStatsProc fFinishedWithStatsProc = nullptr; 91 }; 92 93 /** 94 * The fFinishedProc is called when the Recording has been submitted and finished on the GPU, or 95 * when there is a failure that caused it not to be submitted. The callback will always be called 96 * and the caller can use the callback to know it is safe to free any resources associated with 97 * the Recording that they may be holding onto. If the Recording is successfully submitted to the 98 * GPU the callback will be called with CallbackResult::kSuccess once the GPU has finished. All 99 * other cases where some failure occured it will be called with CallbackResult::kFailed. 100 */ 101 struct InsertFinishInfo { 102 InsertFinishInfo() = default; InsertFinishInfoInsertFinishInfo103 InsertFinishInfo(GpuFinishedContext context, GpuFinishedProc proc) 104 : fFinishedContext{context}, fFinishedProc{proc} {} InsertFinishInfoInsertFinishInfo105 InsertFinishInfo(GpuFinishedContext context, GpuFinishedWithStatsProc proc) 106 : fFinishedContext{context}, fFinishedWithStatsProc{proc} {} 107 GpuFinishedContext fFinishedContext = nullptr; 108 GpuFinishedProc fFinishedProc = nullptr; 109 GpuFinishedWithStatsProc fFinishedWithStatsProc = nullptr; 110 GpuStatsFlags fGpuStatsFlags = GpuStatsFlags::kNone; 111 }; 112 113 /** 114 * Actually submit work to the GPU and track its completion 115 */ 116 enum class SyncToCpu : bool { 117 kYes = true, 118 kNo = false 119 }; 120 121 /* 122 * For Promise Images - should the Promise Image be fulfilled every time a Recording that references 123 * it is inserted into the Context. 124 */ 125 enum class Volatile : bool { 126 kNo = false, // only fulfilled once 127 kYes = true // fulfilled on every insertion call 128 }; 129 130 enum class DepthStencilFlags : int { 131 kNone = 0b000, 132 kDepth = 0b001, 133 kStencil = 0b010, 134 kDepthStencil = kDepth | kStencil, 135 }; 136 137 /* 138 * This enum allows mapping from a set of observed RenderSteps (e.g., from a GraphicsPipeline 139 * printout) to the correct 'drawTypes' parameter needed by the Precompilation API. 140 */ 141 enum DrawTypeFlags : uint16_t { 142 143 kNone = 0, 144 145 // kBitmapText_Mask should be used for the BitmapTextRenderStep[mask] RenderStep 146 kBitmapText_Mask = 1 << 0, 147 // kBitmapText_LCD should be used for the BitmapTextRenderStep[LCD] RenderStep 148 kBitmapText_LCD = 1 << 1, 149 // kBitmapText_Color should be used for the BitmapTextRenderStep[color] RenderStep 150 kBitmapText_Color = 1 << 2, 151 // kSDFText should be used for the SDFTextRenderStep RenderStep 152 kSDFText = 1 << 3, 153 // kSDFText_LCD should be used for the SDFTextLCDRenderStep RenderStep 154 kSDFText_LCD = 1 << 4, 155 156 // kDrawVertices should be used to generate Pipelines that use the following RenderSteps: 157 // VerticesRenderStep[*] for: 158 // [Tris], [TrisTexCoords], [TrisColor], [TrisColorTexCoords], 159 // [Tristrips], [TristripsTexCoords], [TristripsColor], [TristripsColorTexCoords] 160 kDrawVertices = 1 << 5, 161 162 // kCircularArc renders filled circular arcs, with or without the center included, and 163 // stroked circular arcs with butt or round caps that don't include the center point. 164 // It corresponds to the CircularArcRenderStep. 165 kCircularArc = 1 << 6, 166 167 // kSimpleShape should be used to generate Pipelines that use the following RenderSteps: 168 // AnalyticRRectRenderStep 169 // PerEdgeAAQuadRenderStep 170 // CoverBoundsRenderStep[NonAAFill] 171 kSimpleShape = 1 << 7, 172 173 // kNonSimpleShape should be used to generate Pipelines that use the following RenderSteps: 174 // CoverageMaskRenderStep 175 // CoverBoundsRenderStep[*] for [InverseCover], [RegularCover] 176 // TessellateStrokeRenderStep 177 // TessellateWedgesRenderStep[*] for [Convex], [EvenOdd], [Winding] 178 // TessellateCurvesRenderStep[*] for [EvenOdd], [Winding] 179 // MiddleOutFanRenderStep[*] for [EvenOdd], [Winding] 180 kNonSimpleShape = 1 << 8, 181 182 kLast = kNonSimpleShape, 183 }; 184 185 } // namespace skgpu::graphite 186 187 #endif // skgpu_graphite_GraphiteTypes_DEFINED 188