Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Member Functions | List of all members
skgpu::graphite::DawnGraphicsPipeline Class Referencefinal

#include <DawnGraphicsPipeline.h>

Inheritance diagram for skgpu::graphite::DawnGraphicsPipeline:
skgpu::graphite::GraphicsPipeline skgpu::graphite::Resource

Public Types

using BindGroupLayouts = std::array< wgpu::BindGroupLayout, kBindGroupCount >
 

Public Member Functions

 ~DawnGraphicsPipeline () override
 
uint32_t stencilReferenceValue () const
 
PrimitiveType primitiveType () const
 
bool hasStepUniforms () const
 
bool hasPaintUniforms () const
 
int numTexturesAndSamplers () const
 
const wgpu::RenderPipeline & dawnRenderPipeline () const
 
const BindGroupLayouts & dawnGroupLayouts () const
 
- Public Member Functions inherited from skgpu::graphite::GraphicsPipeline
 ~GraphicsPipeline () override
 
const char * getResourceType () const override
 
- Public Member Functions inherited from skgpu::graphite::Resource
 Resource (const Resource &)=delete
 
 Resource (Resource &&)=delete
 
Resource & operator= (const Resource &)=delete
 
Resource & operator= (Resource &&)=delete
 
void ref () const
 
void unref () const
 
void refCommandBuffer () const
 
void unrefCommandBuffer () const
 
Ownership ownership () const
 
skgpu::Budgeted budgeted () const
 
size_t gpuMemorySize () const
 
UniqueID uniqueID () const
 
std::string getLabel () const
 
void setLabel (std::string_view label)
 
bool wasDestroyed () const
 
const GraphiteResourceKey & key () const
 
void setKey (const GraphiteResourceKey &key)
 
void dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const
 
virtual void prepareForReturnToCache (const std::function< void()> &takeRef)
 

Static Public Member Functions

static sk_sp< DawnGraphicsPipeline > Make (const DawnSharedContext *sharedContext, DawnResourceProvider *resourceProvider, const RuntimeEffectDictionary *runtimeDict, const GraphicsPipelineDesc &pipelineDesc, const RenderPassDesc &renderPassDesc)
 

Static Public Attributes

static constexpr unsigned int kUniformBufferBindGroupIndex = 0
 
static constexpr unsigned int kTextureBindGroupIndex = 1
 
static constexpr unsigned int kBindGroupCount = 2
 
static constexpr unsigned int kIntrinsicUniformBufferIndex = 0
 
static constexpr unsigned int kRenderStepUniformBufferIndex = 1
 
static constexpr unsigned int kPaintUniformBufferIndex = 2
 
static constexpr unsigned int kNumUniformBuffers = 3
 
static constexpr unsigned int kVertexBufferIndex = 0
 
static constexpr unsigned int kInstanceBufferIndex = 1
 
static constexpr unsigned int kNumVertexBuffers = 2
 

Private Member Functions

void freeGpuData () override
 

Additional Inherited Members

- Protected Member Functions inherited from skgpu::graphite::GraphicsPipeline
 GraphicsPipeline (const SharedContext *, PipelineInfo *)
 
- Protected Member Functions inherited from skgpu::graphite::Resource
 Resource (const SharedContext *, Ownership, skgpu::Budgeted, size_t gpuMemorySize, std::string_view label, bool commandBufferRefsAsUsageRefs=false)
 
virtual ~Resource ()
 
const SharedContext * sharedContext () const
 
virtual void invokeReleaseProc ()
 
virtual void onDumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump, const char *dumpName) const
 
void setDeleteASAP ()
 

Detailed Description

Definition at line 40 of file DawnGraphicsPipeline.h.

Member Typedef Documentation

◆ BindGroupLayouts

using skgpu::graphite::DawnGraphicsPipeline::BindGroupLayouts = std::array<wgpu::BindGroupLayout, kBindGroupCount>

Definition at line 70 of file DawnGraphicsPipeline.h.

Constructor & Destructor Documentation

◆ ~DawnGraphicsPipeline()

skgpu::graphite::DawnGraphicsPipeline::~DawnGraphicsPipeline ( )
inlineoverride

Definition at line 61 of file DawnGraphicsPipeline.h.

61{}

Member Function Documentation

◆ dawnGroupLayouts()

const BindGroupLayouts & skgpu::graphite::DawnGraphicsPipeline::dawnGroupLayouts ( ) const
inline

Definition at line 71 of file DawnGraphicsPipeline.h.

71{ return fGroupLayouts; }

◆ dawnRenderPipeline()

const wgpu::RenderPipeline & skgpu::graphite::DawnGraphicsPipeline::dawnRenderPipeline ( ) const

Definition at line 600 of file DawnGraphicsPipeline.cpp.

600 {
601 if (auto pipeline = fAsyncPipelineCreation->getIfReady()) {
602 return *pipeline;
603 }
604 return fAsyncPipelineCreation->waitAndGet();
605}

◆ freeGpuData()

void skgpu::graphite::DawnGraphicsPipeline::freeGpuData ( )
overrideprivatevirtual

Implements skgpu::graphite::Resource.

Definition at line 596 of file DawnGraphicsPipeline.cpp.

596 {
597 fAsyncPipelineCreation = nullptr;
598}

◆ hasPaintUniforms()

bool skgpu::graphite::DawnGraphicsPipeline::hasPaintUniforms ( ) const
inline

Definition at line 66 of file DawnGraphicsPipeline.h.

66{ return fHasPaintUniforms; }

◆ hasStepUniforms()

bool skgpu::graphite::DawnGraphicsPipeline::hasStepUniforms ( ) const
inline

Definition at line 65 of file DawnGraphicsPipeline.h.

65{ return fHasStepUniforms; }

◆ Make()

sk_sp< DawnGraphicsPipeline > skgpu::graphite::DawnGraphicsPipeline::Make ( const DawnSharedContext *  sharedContext,
DawnResourceProvider *  resourceProvider,
const RuntimeEffectDictionary *  runtimeDict,
const GraphicsPipelineDesc &  pipelineDesc,
const RenderPassDesc &  renderPassDesc 
)
static

Definition at line 250 of file DawnGraphicsPipeline.cpp.

254 {
255 const DawnCaps& caps = *static_cast<const DawnCaps*>(sharedContext->caps());
256 const auto& device = sharedContext->device();
257
258 SkSL::Program::Interface vsInterface, fsInterface;
259 SkSL::ProgramSettings settings;
260
261 settings.fForceNoRTFlip = true;
262
263 ShaderErrorHandler* errorHandler = caps.shaderErrorHandler();
264
265 const RenderStep* step = sharedContext->rendererProvider()->lookup(pipelineDesc.renderStepID());
266 const bool useStorageBuffers = caps.storageBufferPreferred();
267
268 std::string vsCode, fsCode;
269 wgpu::ShaderModule fsModule, vsModule;
270
271 // Some steps just render depth buffer but not color buffer, so the fragment
272 // shader is null.
273 UniquePaintParamsID paintID = pipelineDesc.paintParamsID();
274 FragSkSLInfo fsSkSLInfo = BuildFragmentSkSL(&caps,
275 sharedContext->shaderCodeDictionary(),
276 runtimeDict,
277 step,
278 paintID,
279 useStorageBuffers,
280 renderPassDesc.fWriteSwizzle);
281 std::string& fsSkSL = fsSkSLInfo.fSkSL;
282 const BlendInfo& blendInfo = fsSkSLInfo.fBlendInfo;
283 const bool localCoordsNeeded = fsSkSLInfo.fRequiresLocalCoords;
284 const int numTexturesAndSamplers = fsSkSLInfo.fNumTexturesAndSamplers;
285
286 bool hasFragmentSkSL = !fsSkSL.empty();
287 if (hasFragmentSkSL) {
288 if (!skgpu::SkSLToWGSL(caps.shaderCaps(),
289 fsSkSL,
290 SkSL::ProgramKind::kGraphiteFragment,
291 settings,
292 &fsCode,
293 &fsInterface,
294 errorHandler)) {
295 return {};
296 }
297 if (!DawnCompileWGSLShaderModule(sharedContext, fsSkSLInfo.fLabel.c_str(), fsCode,
298 &fsModule, errorHandler)) {
299 return {};
300 }
301 }
302
303 VertSkSLInfo vsSkSLInfo = BuildVertexSkSL(caps.resourceBindingRequirements(),
304 step,
305 useStorageBuffers,
306 localCoordsNeeded);
307 const std::string& vsSkSL = vsSkSLInfo.fSkSL;
308 if (!skgpu::SkSLToWGSL(caps.shaderCaps(),
309 vsSkSL,
310 SkSL::ProgramKind::kGraphiteVertex,
311 settings,
312 &vsCode,
313 &vsInterface,
314 errorHandler)) {
315 return {};
316 }
317 if (!DawnCompileWGSLShaderModule(sharedContext, vsSkSLInfo.fLabel.c_str(), vsCode,
318 &vsModule, errorHandler)) {
319 return {};
320 }
321
322 std::string pipelineLabel =
323 GetPipelineLabel(sharedContext->shaderCodeDictionary(), renderPassDesc, step, paintID);
324 wgpu::RenderPipelineDescriptor descriptor;
325 descriptor.label = pipelineLabel.c_str();
326
327 // Fragment state
328 skgpu::BlendEquation equation = blendInfo.fEquation;
329 skgpu::BlendCoeff srcCoeff = blendInfo.fSrcBlend;
330 skgpu::BlendCoeff dstCoeff = blendInfo.fDstBlend;
331 bool blendOn = !skgpu::BlendShouldDisable(equation, srcCoeff, dstCoeff);
332
333 wgpu::BlendState blend;
334 if (blendOn) {
335 blend.color.operation = blend_equation_to_dawn_blend_op(equation);
336 blend.color.srcFactor = blend_coeff_to_dawn_blend(caps, srcCoeff);
337 blend.color.dstFactor = blend_coeff_to_dawn_blend(caps, dstCoeff);
338 blend.alpha.operation = blend_equation_to_dawn_blend_op(equation);
339 blend.alpha.srcFactor = blend_coeff_to_dawn_blend_for_alpha(caps, srcCoeff);
340 blend.alpha.dstFactor = blend_coeff_to_dawn_blend_for_alpha(caps, dstCoeff);
341 }
342
343 wgpu::ColorTargetState colorTarget;
344 colorTarget.format =
345 renderPassDesc.fColorAttachment.fTextureInfo.dawnTextureSpec().getViewFormat();
346 colorTarget.blend = blendOn ? &blend : nullptr;
347 colorTarget.writeMask = blendInfo.fWritesColor && hasFragmentSkSL ? wgpu::ColorWriteMask::All
348 : wgpu::ColorWriteMask::None;
349
350 wgpu::FragmentState fragment;
351 // Dawn doesn't allow having a color attachment but without fragment shader, so have to use a
352 // noop fragment shader, if fragment shader is null.
353 fragment.module = hasFragmentSkSL ? std::move(fsModule) : sharedContext->noopFragment();
354 fragment.entryPoint = "main";
355 fragment.targetCount = 1;
356 fragment.targets = &colorTarget;
357 descriptor.fragment = &fragment;
358
359 // Depth stencil state
360 const auto& depthStencilSettings = step->depthStencilSettings();
361 SkASSERT(depthStencilSettings.fDepthTestEnabled ||
362 depthStencilSettings.fDepthCompareOp == CompareOp::kAlways);
363 wgpu::DepthStencilState depthStencil;
364 if (renderPassDesc.fDepthStencilAttachment.fTextureInfo.isValid()) {
365 wgpu::TextureFormat dsFormat =
366 renderPassDesc.fDepthStencilAttachment.fTextureInfo.dawnTextureSpec()
367 .getViewFormat();
368 depthStencil.format =
369 DawnFormatIsDepthOrStencil(dsFormat) ? dsFormat : wgpu::TextureFormat::Undefined;
370 if (depthStencilSettings.fDepthTestEnabled) {
371 depthStencil.depthWriteEnabled = depthStencilSettings.fDepthWriteEnabled;
372 }
373 depthStencil.depthCompare = compare_op_to_dawn(depthStencilSettings.fDepthCompareOp);
374
375 // Dawn validation fails if the stencil state is non-default and the
376 // format doesn't have the stencil aspect.
377 if (DawnFormatIsStencil(dsFormat) && depthStencilSettings.fStencilTestEnabled) {
378 depthStencil.stencilFront = stencil_face_to_dawn(depthStencilSettings.fFrontStencil);
379 depthStencil.stencilBack = stencil_face_to_dawn(depthStencilSettings.fBackStencil);
380 depthStencil.stencilReadMask = depthStencilSettings.fFrontStencil.fReadMask;
381 depthStencil.stencilWriteMask = depthStencilSettings.fFrontStencil.fWriteMask;
382 }
383
384 descriptor.depthStencil = &depthStencil;
385 }
386
387 // Pipeline layout
388 BindGroupLayouts groupLayouts;
389 {
390 groupLayouts[0] = resourceProvider->getOrCreateUniformBuffersBindGroupLayout();
391 if (!groupLayouts[0]) {
392 return {};
393 }
394
395 bool hasFragmentSamplers = hasFragmentSkSL && numTexturesAndSamplers > 0;
396 if (hasFragmentSamplers) {
397 if (numTexturesAndSamplers == 2) {
398 // Common case: single texture + sampler.
399 groupLayouts[1] =
400 resourceProvider->getOrCreateSingleTextureSamplerBindGroupLayout();
401 } else {
402 std::vector<wgpu::BindGroupLayoutEntry> entries(numTexturesAndSamplers);
403 for (int i = 0; i < numTexturesAndSamplers;) {
404 entries[i].binding = static_cast<uint32_t>(i);
405 entries[i].visibility = wgpu::ShaderStage::Fragment;
406 entries[i].sampler.type = wgpu::SamplerBindingType::Filtering;
407 ++i;
408 entries[i].binding = i;
409 entries[i].visibility = wgpu::ShaderStage::Fragment;
410 entries[i].texture.sampleType = wgpu::TextureSampleType::Float;
411 entries[i].texture.viewDimension = wgpu::TextureViewDimension::e2D;
412 entries[i].texture.multisampled = false;
413 ++i;
414 }
415
416 wgpu::BindGroupLayoutDescriptor groupLayoutDesc;
417#if defined(SK_DEBUG)
418 groupLayoutDesc.label = vsSkSLInfo.fLabel.c_str();
419#endif
420 groupLayoutDesc.entryCount = entries.size();
421 groupLayoutDesc.entries = entries.data();
422 groupLayouts[1] = device.CreateBindGroupLayout(&groupLayoutDesc);
423 }
424 if (!groupLayouts[1]) {
425 return {};
426 }
427 }
428
429 wgpu::PipelineLayoutDescriptor layoutDesc;
430#if defined(SK_DEBUG)
431 layoutDesc.label = fsSkSLInfo.fLabel.c_str();
432#endif
433 layoutDesc.bindGroupLayoutCount =
434 hasFragmentSamplers ? groupLayouts.size() : groupLayouts.size() - 1;
435 layoutDesc.bindGroupLayouts = groupLayouts.data();
436 auto layout = device.CreatePipelineLayout(&layoutDesc);
437 if (!layout) {
438 return {};
439 }
440 descriptor.layout = std::move(layout);
441 }
442
443 // Vertex state
444 std::array<wgpu::VertexBufferLayout, kNumVertexBuffers> vertexBufferLayouts;
445 // Vertex buffer layout
446 std::vector<wgpu::VertexAttribute> vertexAttributes;
447 {
448 auto arrayStride = create_vertex_attributes(step->vertexAttributes(),
449 0,
450 &vertexAttributes);
451 auto& layout = vertexBufferLayouts[kVertexBufferIndex];
452 if (arrayStride) {
453 layout.arrayStride = arrayStride;
454 layout.stepMode = wgpu::VertexStepMode::Vertex;
455 layout.attributeCount = vertexAttributes.size();
456 layout.attributes = vertexAttributes.data();
457 } else {
458 layout.arrayStride = 0;
459 layout.stepMode = wgpu::VertexStepMode::VertexBufferNotUsed;
460 layout.attributeCount = 0;
461 layout.attributes = nullptr;
462 }
463 }
464
465 // Instance buffer layout
466 std::vector<wgpu::VertexAttribute> instanceAttributes;
467 {
468 auto arrayStride = create_vertex_attributes(step->instanceAttributes(),
469 step->vertexAttributes().size(),
470 &instanceAttributes);
471 auto& layout = vertexBufferLayouts[kInstanceBufferIndex];
472 if (arrayStride) {
473 layout.arrayStride = arrayStride;
474 layout.stepMode = wgpu::VertexStepMode::Instance;
475 layout.attributeCount = instanceAttributes.size();
476 layout.attributes = instanceAttributes.data();
477 } else {
478 layout.arrayStride = 0;
479 layout.stepMode = wgpu::VertexStepMode::VertexBufferNotUsed;
480 layout.attributeCount = 0;
481 layout.attributes = nullptr;
482 }
483 }
484
485 auto& vertex = descriptor.vertex;
486 vertex.module = std::move(vsModule);
487 vertex.entryPoint = "main";
488 vertex.constantCount = 0;
489 vertex.constants = nullptr;
490 vertex.bufferCount = vertexBufferLayouts.size();
491 vertex.buffers = vertexBufferLayouts.data();
492
493 // Other state
494 descriptor.primitive.frontFace = wgpu::FrontFace::CCW;
495 descriptor.primitive.cullMode = wgpu::CullMode::None;
496 switch(step->primitiveType()) {
497 case PrimitiveType::kTriangles:
498 descriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
499 break;
500 case PrimitiveType::kTriangleStrip:
501 descriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleStrip;
502 descriptor.primitive.stripIndexFormat = wgpu::IndexFormat::Uint16;
503 break;
504 case PrimitiveType::kPoints:
505 descriptor.primitive.topology = wgpu::PrimitiveTopology::PointList;
506 break;
507 }
508
509 // Multisampled state
510 descriptor.multisample.count = renderPassDesc.fSampleCount;
511 [[maybe_unused]] bool isMSAARenderToSingleSampled =
512 renderPassDesc.fSampleCount > 1 &&
513 renderPassDesc.fColorAttachment.fTextureInfo.isValid() &&
514 renderPassDesc.fColorAttachment.fTextureInfo.numSamples() == 1;
515#if defined(__EMSCRIPTEN__)
516 SkASSERT(!isMSAARenderToSingleSampled);
517#else
518 wgpu::DawnMultisampleStateRenderToSingleSampled pipelineMSAARenderToSingleSampledDesc;
519 if (isMSAARenderToSingleSampled) {
520 // If render pass is multi sampled but the color attachment is single sampled, we need
521 // to activate multisampled render to single sampled feature for this graphics pipeline.
522 SkASSERT(device.HasFeature(wgpu::FeatureName::MSAARenderToSingleSampled));
523
524 descriptor.multisample.nextInChain = &pipelineMSAARenderToSingleSampledDesc;
525 pipelineMSAARenderToSingleSampledDesc.enabled = true;
526 }
527#endif
528
529 descriptor.multisample.mask = 0xFFFFFFFF;
530 descriptor.multisample.alphaToCoverageEnabled = false;
531
532 auto asyncCreation = std::make_unique<AsyncPipelineCreation>(sharedContext);
533
534 if (caps.useAsyncPipelineCreation()) {
535 device.CreateRenderPipelineAsync(
536 &descriptor,
537 [](WGPUCreatePipelineAsyncStatus status,
538 WGPURenderPipeline pipeline,
539 char const* message,
540 void* userdata) {
541 AsyncPipelineCreation* arg = static_cast<AsyncPipelineCreation*>(userdata);
542
543 if (status != WGPUCreatePipelineAsyncStatus_Success) {
544 SKGPU_LOG_E("Failed to create render pipeline (%d): %s", status, message);
545 arg->set(nullptr);
546 } else {
547 arg->set(wgpu::RenderPipeline::Acquire(pipeline));
548 }
549 },
550 asyncCreation.get());
551 } else {
552 asyncCreation->set(device.CreateRenderPipeline(&descriptor));
553 }
554#if defined(GRAPHITE_TEST_UTILS)
555 GraphicsPipeline::PipelineInfo pipelineInfo = {pipelineDesc.renderStepID(),
556 pipelineDesc.paintParamsID(),
557 std::move(vsSkSL),
558 std::move(fsSkSL),
559 std::move(vsCode),
560 std::move(fsCode)};
561 GraphicsPipeline::PipelineInfo* pipelineInfoPtr = &pipelineInfo;
562#else
563 GraphicsPipeline::PipelineInfo* pipelineInfoPtr = nullptr;
564#endif
565
566 return sk_sp<DawnGraphicsPipeline>(
567 new DawnGraphicsPipeline(sharedContext,
568 pipelineInfoPtr,
569 std::move(asyncCreation),
570 std::move(groupLayouts),
571 step->primitiveType(),
572 depthStencilSettings.fStencilReferenceValue,
573 /*hasStepUniforms=*/!step->uniforms().empty(),
574 /*hasPaintUniforms=*/fsSkSLInfo.fNumPaintUniforms > 0,
575 numTexturesAndSamplers));
576}
step
static int step(int x, SkScalar min, SkScalar max)
Definition BlurTest.cpp:215
SKGPU_LOG_E
#define SKGPU_LOG_E(fmt,...)
Definition Log.h:38
SkASSERT
#define SkASSERT(cond)
Definition SkAssert.h:116
sk_sp
Definition SkRefCnt.h:220
skgpu::graphite::DawnGraphicsPipeline::BindGroupLayouts
std::array< wgpu::BindGroupLayout, kBindGroupCount > BindGroupLayouts
Definition DawnGraphicsPipeline.h:70
skgpu::graphite::DawnGraphicsPipeline::kInstanceBufferIndex
static constexpr unsigned int kInstanceBufferIndex
Definition DawnGraphicsPipeline.h:52
skgpu::graphite::DawnGraphicsPipeline::kVertexBufferIndex
static constexpr unsigned int kVertexBufferIndex
Definition DawnGraphicsPipeline.h:51
skgpu::graphite::RendererProvider::lookup
const RenderStep * lookup(uint32_t uniqueID) const
Definition RendererProvider.cpp:157
skgpu::graphite::Resource::sharedContext
const SharedContext * sharedContext() const
Definition Resource.h:187
skgpu::graphite::SharedContext::caps
const Caps * caps() const
Definition SharedContext.h:39
skgpu::graphite::SharedContext::shaderCodeDictionary
ShaderCodeDictionary * shaderCodeDictionary()
Definition SharedContext.h:49
skgpu::graphite::SharedContext::rendererProvider
const RendererProvider * rendererProvider() const
Definition SharedContext.h:47
device
VkDevice device
Definition main.cc:53
blend
static SkColor blend(SkColor dst, SkColor src, void(*mode)(float, float, float, float *, float *, float *))
Definition hsl.cpp:142
message
Win32Message message
Definition keyboard_unittests.cc:139
gn.compile_sksl_tests.settings
settings
Definition compile_sksl_tests.py:18
skgpu::graphite::BuildVertexSkSL
VertSkSLInfo BuildVertexSkSL(const ResourceBindingRequirements &bindingReqs, const RenderStep *step, bool useStorageBuffers, bool defineLocalCoordsVarying)
Definition ContextUtils.cpp:457
skgpu::graphite::DawnFormatIsDepthOrStencil
bool DawnFormatIsDepthOrStencil(wgpu::TextureFormat format)
Definition DawnGraphiteUtils.cpp:42
skgpu::graphite::BuildFragmentSkSL
FragSkSLInfo BuildFragmentSkSL(const Caps *caps, const ShaderCodeDictionary *dict, const RuntimeEffectDictionary *rteDict, const RenderStep *step, UniquePaintParamsID paintID, bool useStorageBuffers, skgpu::Swizzle writeSwizzle)
Definition ContextUtils.cpp:543
skgpu::graphite::GetPipelineLabel
std::string GetPipelineLabel(const ShaderCodeDictionary *dict, const RenderPassDesc &renderPassDesc, const RenderStep *renderStep, UniquePaintParamsID paintID)
Definition ContextUtils.cpp:583
skgpu::graphite::DawnCompileWGSLShaderModule
bool DawnCompileWGSLShaderModule(const DawnSharedContext *sharedContext, const char *label, const std::string &wgsl, wgpu::ShaderModule *module, ShaderErrorHandler *errorHandler)
Definition DawnGraphiteUtils.cpp:146
skgpu::graphite::DawnFormatIsStencil
bool DawnFormatIsStencil(wgpu::TextureFormat format)
Definition DawnGraphiteUtils.cpp:65
skgpu::BlendShouldDisable
static constexpr bool BlendShouldDisable(BlendEquation equation, BlendCoeff srcCoeff, BlendCoeff dstCoeff)
Definition Blend.h:145
skgpu::BlendEquation
BlendEquation
Definition Blend.h:26
skgpu::BlendCoeff
BlendCoeff
Definition Blend.h:60
skgpu::SkSLToWGSL
bool SkSLToWGSL(const SkSL::ShaderCaps *caps, const std::string &sksl, SkSL::ProgramKind programKind, const SkSL::ProgramSettings &settings, std::string *wgsl, SkSL::ProgramInterface *outInterface, ShaderErrorHandler *errorHandler)
Definition DawnUtilsPriv.h:29

◆ numTexturesAndSamplers()

int skgpu::graphite::DawnGraphicsPipeline::numTexturesAndSamplers ( ) const
inline

Definition at line 67 of file DawnGraphicsPipeline.h.

67{ return fNumFragmentTexturesAndSamplers; }

◆ primitiveType()

PrimitiveType skgpu::graphite::DawnGraphicsPipeline::primitiveType ( ) const
inline

Definition at line 64 of file DawnGraphicsPipeline.h.

64{ return fPrimitiveType; }

◆ stencilReferenceValue()

uint32_t skgpu::graphite::DawnGraphicsPipeline::stencilReferenceValue ( ) const
inline

Definition at line 63 of file DawnGraphicsPipeline.h.

63{ return fStencilReferenceValue; }

Member Data Documentation

◆ kBindGroupCount

constexpr unsigned int skgpu::graphite::DawnGraphicsPipeline::kBindGroupCount = 2
inlinestaticconstexpr

Definition at line 44 of file DawnGraphicsPipeline.h.

◆ kInstanceBufferIndex

constexpr unsigned int skgpu::graphite::DawnGraphicsPipeline::kInstanceBufferIndex = 1
inlinestaticconstexpr

Definition at line 52 of file DawnGraphicsPipeline.h.

◆ kIntrinsicUniformBufferIndex

constexpr unsigned int skgpu::graphite::DawnGraphicsPipeline::kIntrinsicUniformBufferIndex = 0
inlinestaticconstexpr

Definition at line 46 of file DawnGraphicsPipeline.h.

◆ kNumUniformBuffers

constexpr unsigned int skgpu::graphite::DawnGraphicsPipeline::kNumUniformBuffers = 3
inlinestaticconstexpr

Definition at line 49 of file DawnGraphicsPipeline.h.

◆ kNumVertexBuffers

constexpr unsigned int skgpu::graphite::DawnGraphicsPipeline::kNumVertexBuffers = 2
inlinestaticconstexpr

Definition at line 53 of file DawnGraphicsPipeline.h.

◆ kPaintUniformBufferIndex

constexpr unsigned int skgpu::graphite::DawnGraphicsPipeline::kPaintUniformBufferIndex = 2
inlinestaticconstexpr

Definition at line 48 of file DawnGraphicsPipeline.h.

◆ kRenderStepUniformBufferIndex

constexpr unsigned int skgpu::graphite::DawnGraphicsPipeline::kRenderStepUniformBufferIndex = 1
inlinestaticconstexpr

Definition at line 47 of file DawnGraphicsPipeline.h.

◆ kTextureBindGroupIndex

constexpr unsigned int skgpu::graphite::DawnGraphicsPipeline::kTextureBindGroupIndex = 1
inlinestaticconstexpr

Definition at line 43 of file DawnGraphicsPipeline.h.

◆ kUniformBufferBindGroupIndex

constexpr unsigned int skgpu::graphite::DawnGraphicsPipeline::kUniformBufferBindGroupIndex = 0
inlinestaticconstexpr

Definition at line 42 of file DawnGraphicsPipeline.h.

◆ kVertexBufferIndex

constexpr unsigned int skgpu::graphite::DawnGraphicsPipeline::kVertexBufferIndex = 0
inlinestaticconstexpr

Definition at line 51 of file DawnGraphicsPipeline.h.

The documentation for this class was generated from the following files:
Generated on Fri Apr 26 2024 06:22:05 for Flutter Engine by doxygen 1.9.8