encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Finish conversion to RenderPipelineDescriptor2 

Converts each of the native API backends to use RPD2 natively, started
converting the old format to the new one in the deprecated entry point,
removed all other handling and validation of the old format, and turned
on the deprecation warning.

BUG: dawn:642
Change-Id: I20b671960a83f65ecb4ce6ce1165a563025983cd
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/46726
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
Commit-Queue: Brandon Jones <bajones@chromium.org>
This commit is contained in:
Brandon Jones 2021-04-02 19:42:28 +00:00 committed by Commit Bot service account
parent 1fdd0593d8
commit f759264387
27 changed files with 157 additions and 515 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

215
src/dawn_native/Device.cpp
View File

@ -531,27 +531,6 @@ namespace dawn_native {
ASSERT(removedCount == 1); ASSERT(removedCount == 1);
} }
ResultOrError<Ref<RenderPipelineBase>> DeviceBase::GetOrCreateRenderPipeline(
const RenderPipelineDescriptor* descriptor) {
RenderPipelineBase blueprint(this, descriptor);
const size_t blueprintHash = blueprint.ComputeContentHash();
blueprint.SetContentHash(blueprintHash);
Ref<RenderPipelineBase> result;
auto iter = mCaches->renderPipelines.find(&blueprint);
if (iter != mCaches->renderPipelines.end()) {
result = *iter;
} else {
DAWN_TRY_ASSIGN(result, CreateRenderPipelineImpl(descriptor));
result->SetIsCachedReference();
result->SetContentHash(blueprintHash);
mCaches->renderPipelines.insert(result.Get());
}
return std::move(result);
}
ResultOrError<Ref<RenderPipelineBase>> DeviceBase::GetOrCreateRenderPipeline( ResultOrError<Ref<RenderPipelineBase>> DeviceBase::GetOrCreateRenderPipeline(
const RenderPipelineDescriptor2* descriptor) { const RenderPipelineDescriptor2* descriptor) {
RenderPipelineBase blueprint(this, descriptor); RenderPipelineBase blueprint(this, descriptor);
@ -564,83 +543,7 @@ namespace dawn_native {
if (iter != mCaches->renderPipelines.end()) { if (iter != mCaches->renderPipelines.end()) {
result = *iter; result = *iter;
} else { } else {
// Convert descriptor to the older format it before proceeding. DAWN_TRY_ASSIGN(result, CreateRenderPipelineImpl(descriptor));
// TODO: Convert the rest of the code to operate on the newer format.
RenderPipelineDescriptor normalizedDescriptor;
VertexStateDescriptor vertexState;
normalizedDescriptor.vertexState = &vertexState;
RasterizationStateDescriptor rasterizationState;
normalizedDescriptor.rasterizationState = &rasterizationState;
normalizedDescriptor.label = descriptor->label;
normalizedDescriptor.layout = descriptor->layout;
normalizedDescriptor.vertexStage.module = descriptor->vertex.module;
normalizedDescriptor.vertexStage.entryPoint = descriptor->vertex.entryPoint;
normalizedDescriptor.primitiveTopology = descriptor->primitive.topology;
normalizedDescriptor.sampleCount = descriptor->multisample.count;
normalizedDescriptor.sampleMask = descriptor->multisample.mask;
normalizedDescriptor.alphaToCoverageEnabled =
descriptor->multisample.alphaToCoverageEnabled;
vertexState.vertexBufferCount = descriptor->vertex.bufferCount;
vertexState.vertexBuffers = descriptor->vertex.buffers;
vertexState.indexFormat = descriptor->primitive.stripIndexFormat;
rasterizationState.frontFace = descriptor->primitive.frontFace;
rasterizationState.cullMode = descriptor->primitive.cullMode;
DepthStencilStateDescriptor depthStencilState;
if (descriptor->depthStencil) {
const DepthStencilState* depthStencil = descriptor->depthStencil;
normalizedDescriptor.depthStencilState = &depthStencilState;
depthStencilState.format = depthStencil->format;
depthStencilState.depthWriteEnabled = depthStencil->depthWriteEnabled;
depthStencilState.depthCompare = depthStencil->depthCompare;
depthStencilState.stencilFront = depthStencil->stencilFront;
depthStencilState.stencilBack = depthStencil->stencilBack;
depthStencilState.stencilReadMask = depthStencil->stencilReadMask;
depthStencilState.stencilWriteMask = depthStencil->stencilWriteMask;
rasterizationState.depthBias = depthStencil->depthBias;
rasterizationState.depthBiasSlopeScale = depthStencil->depthBiasSlopeScale;
rasterizationState.depthBiasClamp = depthStencil->depthBiasClamp;
}
ProgrammableStageDescriptor fragmentStage;
std::vector<ColorStateDescriptor> colorStates;
if (descriptor->fragment) {
const FragmentState* fragment = descriptor->fragment;
normalizedDescriptor.fragmentStage = &fragmentStage;
fragmentStage.module = fragment->module;
fragmentStage.entryPoint = fragment->entryPoint;
for (uint32_t i = 0; i < fragment->targetCount; ++i) {
const ColorTargetState& target = fragment->targets[i];
ColorStateDescriptor colorState;
colorState.format = target.format;
colorState.writeMask = target.writeMask;
if (target.blend) {
const BlendState* blend = target.blend;
colorState.colorBlend.srcFactor = blend->color.srcFactor;
colorState.colorBlend.dstFactor = blend->color.dstFactor;
colorState.colorBlend.operation = blend->color.operation;
colorState.alphaBlend.srcFactor = blend->alpha.srcFactor;
colorState.alphaBlend.dstFactor = blend->alpha.dstFactor;
colorState.alphaBlend.operation = blend->alpha.operation;
}
colorStates.push_back(colorState);
}
normalizedDescriptor.colorStateCount = fragment->targetCount;
normalizedDescriptor.colorStates = colorStates.data();
}
DAWN_TRY_ASSIGN(result, CreateRenderPipelineImpl(&normalizedDescriptor));
result->SetIsCachedReference(); result->SetIsCachedReference();
result->SetContentHash(blueprintHash); result->SetContentHash(blueprintHash);
mCaches->renderPipelines.insert(result.Get()); mCaches->renderPipelines.insert(result.Get());
@ -870,12 +773,98 @@ namespace dawn_native {
const RenderPipelineDescriptor* descriptor) { const RenderPipelineDescriptor* descriptor) {
// TODO: Enable this warning once the tests have been converted to either use the new // TODO: Enable this warning once the tests have been converted to either use the new
// format or expect the deprecation warning. // format or expect the deprecation warning.
/*EmitDeprecationWarning( EmitDeprecationWarning(
"The format of RenderPipelineDescriptor has changed, and will soon require the " "The format of RenderPipelineDescriptor has changed, and will soon require the "
"new structure. Please begin using CreateRenderPipeline2() instead.");*/ "new structure. Please begin using CreateRenderPipeline2() instead.");
// Convert descriptor to the new format it before proceeding.
RenderPipelineDescriptor2 normalizedDescriptor;
normalizedDescriptor.label = descriptor->label;
normalizedDescriptor.layout = descriptor->layout;
normalizedDescriptor.vertex.module = descriptor->vertexStage.module;
normalizedDescriptor.vertex.entryPoint = descriptor->vertexStage.entryPoint;
normalizedDescriptor.primitive.topology = descriptor->primitiveTopology;
normalizedDescriptor.multisample.count = descriptor->sampleCount;
normalizedDescriptor.multisample.mask = descriptor->sampleMask;
normalizedDescriptor.multisample.alphaToCoverageEnabled =
descriptor->alphaToCoverageEnabled;
if (descriptor->vertexState) {
const VertexStateDescriptor* vertexState = descriptor->vertexState;
normalizedDescriptor.primitive.stripIndexFormat = vertexState->indexFormat;
normalizedDescriptor.vertex.bufferCount = vertexState->vertexBufferCount;
normalizedDescriptor.vertex.buffers = vertexState->vertexBuffers;
} else {
normalizedDescriptor.vertex.bufferCount = 0;
normalizedDescriptor.vertex.buffers = nullptr;
}
DepthStencilState depthStencil;
if (descriptor->depthStencilState) {
const DepthStencilStateDescriptor* depthStencilState = descriptor->depthStencilState;
normalizedDescriptor.depthStencil = &depthStencil;
depthStencil.format = depthStencilState->format;
depthStencil.depthWriteEnabled = depthStencilState->depthWriteEnabled;
depthStencil.depthCompare = depthStencilState->depthCompare;
depthStencil.stencilFront = depthStencilState->stencilFront;
depthStencil.stencilBack = depthStencilState->stencilBack;
depthStencil.stencilReadMask = depthStencilState->stencilReadMask;
depthStencil.stencilWriteMask = depthStencilState->stencilWriteMask;
}
if (descriptor->rasterizationState) {
const RasterizationStateDescriptor* rasterizationState = descriptor->rasterizationState;
normalizedDescriptor.primitive.frontFace = rasterizationState->frontFace;
normalizedDescriptor.primitive.cullMode = rasterizationState->cullMode;
depthStencil.depthBias = rasterizationState->depthBias;
depthStencil.depthBiasSlopeScale = rasterizationState->depthBiasSlopeScale;
depthStencil.depthBiasClamp = rasterizationState->depthBiasClamp;
}
FragmentState fragment;
std::vector<ColorTargetState> targets;
std::vector<BlendState> blendStates;
if (descriptor->fragmentStage) {
const ProgrammableStageDescriptor* fragmentStage = descriptor->fragmentStage;
normalizedDescriptor.fragment = &fragment;
fragment.module = fragmentStage->module;
fragment.entryPoint = fragmentStage->entryPoint;
targets.resize(descriptor->colorStateCount);
blendStates.resize(descriptor->colorStateCount);
for (uint32_t i = 0; i < descriptor->colorStateCount; ++i) {
const ColorStateDescriptor& colorState = descriptor->colorStates[i];
ColorTargetState& target = targets[i];
target.format = colorState.format;
target.writeMask = colorState.writeMask;
if (BlendEnabled(&colorState)) {
BlendState* blend = &blendStates[i];
target.blend = blend;
blend->color.srcFactor = colorState.colorBlend.srcFactor;
blend->color.dstFactor = colorState.colorBlend.dstFactor;
blend->color.operation = colorState.colorBlend.operation;
blend->alpha.srcFactor = colorState.alphaBlend.srcFactor;
blend->alpha.dstFactor = colorState.alphaBlend.dstFactor;
blend->alpha.operation = colorState.alphaBlend.operation;
}
}
fragment.targetCount = descriptor->colorStateCount;
fragment.targets = targets.data();
}
Ref<RenderPipelineBase> result; Ref<RenderPipelineBase> result;
if (ConsumedError(CreateRenderPipelineInternal(descriptor), &result)) { if (ConsumedError(CreateRenderPipelineInternal(&normalizedDescriptor), &result)) {
return RenderPipelineBase::MakeError(this); return RenderPipelineBase::MakeError(this);
} }
return result.Detach(); return result.Detach();
@ -1161,30 +1150,6 @@ namespace dawn_native {
} }
} }
ResultOrError<Ref<RenderPipelineBase>> DeviceBase::CreateRenderPipelineInternal(
const RenderPipelineDescriptor* descriptor) {
DAWN_TRY(ValidateIsAlive());
if (IsValidationEnabled()) {
DAWN_TRY(ValidateRenderPipelineDescriptor(this, descriptor));
}
if (descriptor->layout == nullptr) {
RenderPipelineDescriptor descriptorWithDefaultLayout = *descriptor;
// Ref will keep the pipeline layout alive until the end of the function where
// the pipeline will take another reference.
Ref<PipelineLayoutBase> layoutRef;
DAWN_TRY_ASSIGN(layoutRef,
PipelineLayoutBase::CreateDefault(this, GetStages(descriptor)));
descriptorWithDefaultLayout.layout = layoutRef.Get();
return GetOrCreateRenderPipeline(&descriptorWithDefaultLayout);
} else {
return GetOrCreateRenderPipeline(descriptor);
}
}
ResultOrError<Ref<SamplerBase>> DeviceBase::CreateSamplerInternal( ResultOrError<Ref<SamplerBase>> DeviceBase::CreateSamplerInternal(
const SamplerDescriptor* descriptor) { const SamplerDescriptor* descriptor) {
const SamplerDescriptor defaultDescriptor = {}; const SamplerDescriptor defaultDescriptor = {};

6
src/dawn_native/Device.h
View File

@ -119,8 +119,6 @@ namespace dawn_native {
const PipelineLayoutDescriptor* descriptor); const PipelineLayoutDescriptor* descriptor);
void UncachePipelineLayout(PipelineLayoutBase* obj); void UncachePipelineLayout(PipelineLayoutBase* obj);
ResultOrError<Ref<RenderPipelineBase>> GetOrCreateRenderPipeline(
const RenderPipelineDescriptor* descriptor);
ResultOrError<Ref<RenderPipelineBase>> GetOrCreateRenderPipeline( ResultOrError<Ref<RenderPipelineBase>> GetOrCreateRenderPipeline(
const RenderPipelineDescriptor2* descriptor); const RenderPipelineDescriptor2* descriptor);
void UncacheRenderPipeline(RenderPipelineBase* obj); void UncacheRenderPipeline(RenderPipelineBase* obj);
@ -278,7 +276,7 @@ namespace dawn_native {
virtual ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl( virtual ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl(
const QuerySetDescriptor* descriptor) = 0; const QuerySetDescriptor* descriptor) = 0;
virtual ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl( virtual ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl(
const RenderPipelineDescriptor* descriptor) = 0; const RenderPipelineDescriptor2* descriptor) = 0;
virtual ResultOrError<Ref<SamplerBase>> CreateSamplerImpl( virtual ResultOrError<Ref<SamplerBase>> CreateSamplerImpl(
const SamplerDescriptor* descriptor) = 0; const SamplerDescriptor* descriptor) = 0;
virtual ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl( virtual ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl(
@ -318,8 +316,6 @@ namespace dawn_native {
const RenderBundleEncoderDescriptor* descriptor); const RenderBundleEncoderDescriptor* descriptor);
ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineInternal( ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineInternal(
const RenderPipelineDescriptor2* descriptor); const RenderPipelineDescriptor2* descriptor);
ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineInternal(
const RenderPipelineDescriptor* descriptor);
ResultOrError<Ref<SamplerBase>> CreateSamplerInternal(const SamplerDescriptor* descriptor); ResultOrError<Ref<SamplerBase>> CreateSamplerInternal(const SamplerDescriptor* descriptor);
ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleInternal( ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleInternal(
const ShaderModuleDescriptor* descriptor); const ShaderModuleDescriptor* descriptor);

317
src/dawn_native/RenderPipeline.cpp
View File

@ -270,124 +270,6 @@ namespace dawn_native {
return {}; return {};
} }
// TODO(dawn:642): Validation methods below here are for the deprecated
// RenderPipelineDescriptor format and should be removed once it is no longer necessary to
// validate that format.
MaybeError ValidateVertexStateDescriptor(
DeviceBase* device,
const VertexStateDescriptor* descriptor,
wgpu::PrimitiveTopology primitiveTopology,
std::bitset<kMaxVertexAttributes>* attributesSetMask) {
if (descriptor->nextInChain != nullptr) {
return DAWN_VALIDATION_ERROR("nextInChain must be nullptr");
}
DAWN_TRY(ValidateIndexFormat(descriptor->indexFormat));
// Pipeline descriptors must have indexFormat != undefined IFF they are using strip
// topologies.
if (IsStripPrimitiveTopology(primitiveTopology)) {
if (descriptor->indexFormat == wgpu::IndexFormat::Undefined) {
return DAWN_VALIDATION_ERROR(
"indexFormat must not be undefined when using strip primitive topologies");
}
} else if (descriptor->indexFormat != wgpu::IndexFormat::Undefined) {
return DAWN_VALIDATION_ERROR(
"indexFormat must be undefined when using non-strip primitive topologies");
}
if (descriptor->vertexBufferCount > kMaxVertexBuffers) {
return DAWN_VALIDATION_ERROR("Vertex buffer count exceeds maximum");
}
uint32_t totalAttributesNum = 0;
for (uint32_t i = 0; i < descriptor->vertexBufferCount; ++i) {
DAWN_TRY(ValidateVertexBufferLayout(device, &descriptor->vertexBuffers[i],
attributesSetMask));
totalAttributesNum += descriptor->vertexBuffers[i].attributeCount;
}
// Every vertex attribute has a member called shaderLocation, and there are some
// requirements for shaderLocation: 1) >=0, 2) values are different across different
// attributes, 3) can't exceed kMaxVertexAttributes. So it can ensure that total
// attribute number never exceed kMaxVertexAttributes.
ASSERT(totalAttributesNum <= kMaxVertexAttributes);
return {};
}
MaybeError ValidateRasterizationStateDescriptor(
const RasterizationStateDescriptor* descriptor) {
if (descriptor->nextInChain != nullptr) {
return DAWN_VALIDATION_ERROR("nextInChain must be nullptr");
}
DAWN_TRY(ValidateFrontFace(descriptor->frontFace));
DAWN_TRY(ValidateCullMode(descriptor->cullMode));
if (std::isnan(descriptor->depthBiasSlopeScale) ||
std::isnan(descriptor->depthBiasClamp)) {
return DAWN_VALIDATION_ERROR("Depth bias parameters must not be NaN.");
}
return {};
}
MaybeError ValidateColorStateDescriptor(const DeviceBase* device,
const ColorStateDescriptor& descriptor,
bool fragmentWritten,
wgpu::TextureComponentType fragmentOutputBaseType) {
if (descriptor.nextInChain != nullptr) {
return DAWN_VALIDATION_ERROR("nextInChain must be nullptr");
}
DAWN_TRY(ValidateBlendOperation(descriptor.alphaBlend.operation));
DAWN_TRY(ValidateBlendFactor(descriptor.alphaBlend.srcFactor));
DAWN_TRY(ValidateBlendFactor(descriptor.alphaBlend.dstFactor));
DAWN_TRY(ValidateBlendOperation(descriptor.colorBlend.operation));
DAWN_TRY(ValidateBlendFactor(descriptor.colorBlend.srcFactor));
DAWN_TRY(ValidateBlendFactor(descriptor.colorBlend.dstFactor));
DAWN_TRY(ValidateColorWriteMask(descriptor.writeMask));
const Format* format;
DAWN_TRY_ASSIGN(format, device->GetInternalFormat(descriptor.format));
if (!format->IsColor() || !format->isRenderable) {
return DAWN_VALIDATION_ERROR("Color format must be color renderable");
}
if (fragmentWritten &&
fragmentOutputBaseType != format->GetAspectInfo(Aspect::Color).baseType) {
return DAWN_VALIDATION_ERROR(
"Color format must match the fragment stage output type");
}
return {};
}
MaybeError ValidateDepthStencilStateDescriptor(
const DeviceBase* device,
const DepthStencilStateDescriptor* descriptor) {
if (descriptor->nextInChain != nullptr) {
return DAWN_VALIDATION_ERROR("nextInChain must be nullptr");
}
DAWN_TRY(ValidateCompareFunction(descriptor->depthCompare));
DAWN_TRY(ValidateCompareFunction(descriptor->stencilFront.compare));
DAWN_TRY(ValidateStencilOperation(descriptor->stencilFront.failOp));
DAWN_TRY(ValidateStencilOperation(descriptor->stencilFront.depthFailOp));
DAWN_TRY(ValidateStencilOperation(descriptor->stencilFront.passOp));
DAWN_TRY(ValidateCompareFunction(descriptor->stencilBack.compare));
DAWN_TRY(ValidateStencilOperation(descriptor->stencilBack.failOp));
DAWN_TRY(ValidateStencilOperation(descriptor->stencilBack.depthFailOp));
DAWN_TRY(ValidateStencilOperation(descriptor->stencilBack.passOp));
const Format* format;
DAWN_TRY_ASSIGN(format, device->GetInternalFormat(descriptor->format));
if (!format->HasDepthOrStencil() || !format->isRenderable) {
return DAWN_VALIDATION_ERROR(
"Depth stencil format must be depth-stencil renderable");
}
return {};
}
} // anonymous namespace } // anonymous namespace
// Helper functions // Helper functions
@ -407,82 +289,6 @@ namespace dawn_native {
primitiveTopology == wgpu::PrimitiveTopology::TriangleStrip; primitiveTopology == wgpu::PrimitiveTopology::TriangleStrip;
} }
MaybeError ValidateRenderPipelineDescriptor(DeviceBase* device,
const RenderPipelineDescriptor* descriptor) {
if (descriptor->nextInChain != nullptr) {
return DAWN_VALIDATION_ERROR("nextInChain must be nullptr");
}
if (descriptor->layout != nullptr) {
DAWN_TRY(device->ValidateObject(descriptor->layout));
}
// TODO(crbug.com/dawn/136): Support vertex-only pipelines.
if (descriptor->fragmentStage == nullptr) {
return DAWN_VALIDATION_ERROR("Null fragment stage is not supported (yet)");
}
DAWN_TRY(ValidatePrimitiveTopology(descriptor->primitiveTopology));
std::bitset<kMaxVertexAttributes> attributesSetMask;
if (descriptor->vertexState) {
DAWN_TRY(ValidateVertexStateDescriptor(device,
descriptor->vertexState, descriptor->primitiveTopology, &attributesSetMask));
}
DAWN_TRY(ValidateProgrammableStage(device, descriptor->vertexStage.module,
descriptor->vertexStage.entryPoint, descriptor->layout,
SingleShaderStage::Vertex));
DAWN_TRY(ValidateProgrammableStage(device, descriptor->fragmentStage->module,
descriptor->fragmentStage->entryPoint,
descriptor->layout, SingleShaderStage::Fragment));
if (descriptor->rasterizationState) {
DAWN_TRY(ValidateRasterizationStateDescriptor(descriptor->rasterizationState));
}
const EntryPointMetadata& vertexMetadata =
descriptor->vertexStage.module->GetEntryPoint(descriptor->vertexStage.entryPoint);
if (!IsSubset(vertexMetadata.usedVertexAttributes, attributesSetMask)) {
return DAWN_VALIDATION_ERROR(
"Pipeline vertex stage uses vertex buffers not in the vertex state");
}
if (!IsValidSampleCount(descriptor->sampleCount)) {
return DAWN_VALIDATION_ERROR("Sample count is not supported");
}
if (descriptor->colorStateCount > kMaxColorAttachments) {
return DAWN_VALIDATION_ERROR("Color States number exceeds maximum");
}
if (descriptor->colorStateCount == 0 && !descriptor->depthStencilState) {
return DAWN_VALIDATION_ERROR(
"Should have at least one colorState or a depthStencilState");
}
ASSERT(descriptor->fragmentStage != nullptr);
const EntryPointMetadata& fragmentMetadata =
descriptor->fragmentStage->module->GetEntryPoint(descriptor->fragmentStage->entryPoint);
for (ColorAttachmentIndex i(uint8_t(0));
i < ColorAttachmentIndex(static_cast<uint8_t>(descriptor->colorStateCount)); ++i) {
DAWN_TRY(ValidateColorStateDescriptor(
device, descriptor->colorStates[static_cast<uint8_t>(i)],
fragmentMetadata.fragmentOutputsWritten[i],
fragmentMetadata.fragmentOutputFormatBaseTypes[i]));
}
if (descriptor->depthStencilState) {
DAWN_TRY(ValidateDepthStencilStateDescriptor(device, descriptor->depthStencilState));
}
if (descriptor->alphaToCoverageEnabled && descriptor->sampleCount <= 1) {
return DAWN_VALIDATION_ERROR("Enabling alphaToCoverage requires sampleCount > 1");
}
return {};
}
MaybeError ValidateRenderPipelineDescriptor(DeviceBase* device, MaybeError ValidateRenderPipelineDescriptor(DeviceBase* device,
const RenderPipelineDescriptor2* descriptor) { const RenderPipelineDescriptor2* descriptor) {
if (descriptor->nextInChain != nullptr) { if (descriptor->nextInChain != nullptr) {
@ -518,17 +324,6 @@ namespace dawn_native {
return {}; return {};
} }
std::vector<StageAndDescriptor> GetStages(const RenderPipelineDescriptor* descriptor) {
std::vector<StageAndDescriptor> stages;
stages.push_back({SingleShaderStage::Vertex, descriptor->vertexStage.module,
descriptor->vertexStage.entryPoint});
if (descriptor->fragmentStage != nullptr) {
stages.push_back({SingleShaderStage::Fragment, descriptor->fragmentStage->module,
descriptor->fragmentStage->entryPoint});
}
return stages;
}
std::vector<StageAndDescriptor> GetStages(const RenderPipelineDescriptor2* descriptor) { std::vector<StageAndDescriptor> GetStages(const RenderPipelineDescriptor2* descriptor) {
std::vector<StageAndDescriptor> stages; std::vector<StageAndDescriptor> stages;
stages.push_back( stages.push_back(
@ -562,118 +357,6 @@ namespace dawn_native {
// RenderPipelineBase // RenderPipelineBase
RenderPipelineBase::RenderPipelineBase(DeviceBase* device,
const RenderPipelineDescriptor* descriptor)
: PipelineBase(device,
descriptor->layout,
{{SingleShaderStage::Vertex, descriptor->vertexStage.module,
descriptor->vertexStage.entryPoint},
{SingleShaderStage::Fragment, descriptor->fragmentStage->module,
descriptor->fragmentStage->entryPoint}}),
mAttachmentState(device->GetOrCreateAttachmentState(descriptor)) {
mPrimitive.topology = descriptor->primitiveTopology;
mMultisample.count = descriptor->sampleCount;
mMultisample.mask = descriptor->sampleMask;
mMultisample.alphaToCoverageEnabled = descriptor->alphaToCoverageEnabled;
if (descriptor->vertexState != nullptr) {
const VertexStateDescriptor& vertexState = *descriptor->vertexState;
mVertexBufferCount = vertexState.vertexBufferCount;
mPrimitive.stripIndexFormat = vertexState.indexFormat;
for (uint8_t slot = 0; slot < mVertexBufferCount; ++slot) {
if (vertexState.vertexBuffers[slot].attributeCount == 0) {
continue;
}
VertexBufferSlot typedSlot(slot);
mVertexBufferSlotsUsed.set(typedSlot);
mVertexBufferInfos[typedSlot].arrayStride =
vertexState.vertexBuffers[slot].arrayStride;
mVertexBufferInfos[typedSlot].stepMode = vertexState.vertexBuffers[slot].stepMode;
for (uint32_t i = 0; i < vertexState.vertexBuffers[slot].attributeCount; ++i) {
VertexAttributeLocation location = VertexAttributeLocation(static_cast<uint8_t>(
vertexState.vertexBuffers[slot].attributes[i].shaderLocation));
mAttributeLocationsUsed.set(location);
mAttributeInfos[location].shaderLocation = location;
mAttributeInfos[location].vertexBufferSlot = typedSlot;
mAttributeInfos[location].offset =
vertexState.vertexBuffers[slot].attributes[i].offset;
mAttributeInfos[location].format = dawn::NormalizeVertexFormat(
vertexState.vertexBuffers[slot].attributes[i].format);
}
}
} else {
mVertexBufferCount = 0;
mPrimitive.stripIndexFormat = wgpu::IndexFormat::Undefined;
}
if (mAttachmentState->HasDepthStencilAttachment()) {
const DepthStencilStateDescriptor& depthStencil = *descriptor->depthStencilState;
mDepthStencil.format = depthStencil.format;
mDepthStencil.depthWriteEnabled = depthStencil.depthWriteEnabled;
mDepthStencil.depthCompare = depthStencil.depthCompare;
mDepthStencil.stencilBack = depthStencil.stencilBack;
mDepthStencil.stencilFront = depthStencil.stencilFront;
mDepthStencil.stencilReadMask = depthStencil.stencilReadMask;
mDepthStencil.stencilWriteMask = depthStencil.stencilWriteMask;
} else {
// These default values below are useful for backends to fill information.
// The values indicate that depth and stencil test are disabled when backends
// set their own depth stencil states/descriptors according to the values in
// mDepthStencil.
mDepthStencil.format = wgpu::TextureFormat::Undefined;
mDepthStencil.depthWriteEnabled = false;
mDepthStencil.depthCompare = wgpu::CompareFunction::Always;
mDepthStencil.stencilBack.compare = wgpu::CompareFunction::Always;
mDepthStencil.stencilBack.failOp = wgpu::StencilOperation::Keep;
mDepthStencil.stencilBack.depthFailOp = wgpu::StencilOperation::Keep;
mDepthStencil.stencilBack.passOp = wgpu::StencilOperation::Keep;
mDepthStencil.stencilFront.compare = wgpu::CompareFunction::Always;
mDepthStencil.stencilFront.failOp = wgpu::StencilOperation::Keep;
mDepthStencil.stencilFront.depthFailOp = wgpu::StencilOperation::Keep;
mDepthStencil.stencilFront.passOp = wgpu::StencilOperation::Keep;
mDepthStencil.stencilReadMask = 0xff;
mDepthStencil.stencilWriteMask = 0xff;
}
if (descriptor->rasterizationState != nullptr) {
mPrimitive.frontFace = descriptor->rasterizationState->frontFace;
mPrimitive.cullMode = descriptor->rasterizationState->cullMode;
mDepthStencil.depthBias = descriptor->rasterizationState->depthBias;
mDepthStencil.depthBiasSlopeScale = descriptor->rasterizationState->depthBiasSlopeScale;
mDepthStencil.depthBiasClamp = descriptor->rasterizationState->depthBiasClamp;
} else {
mPrimitive.frontFace = wgpu::FrontFace::CCW;
mPrimitive.cullMode = wgpu::CullMode::None;
mDepthStencil.depthBias = 0;
mDepthStencil.depthBiasSlopeScale = 0.0f;
mDepthStencil.depthBiasClamp = 0.0f;
}
for (ColorAttachmentIndex i : IterateBitSet(mAttachmentState->GetColorAttachmentsMask())) {
const ColorStateDescriptor* colorState =
&descriptor->colorStates[static_cast<uint8_t>(i)];
mTargets[i].format = colorState->format;
mTargets[i].writeMask = colorState->writeMask;
if (BlendEnabled(colorState)) {
mTargetBlend[i].color = colorState->colorBlend;
mTargetBlend[i].alpha = colorState->alphaBlend;
mTargets[i].blend = &mTargetBlend[i];
} else {
mTargets[i].blend = nullptr;
}
}
// TODO(cwallez@chromium.org): Check against the shader module that the correct color
// attachment are set?
}
RenderPipelineBase::RenderPipelineBase(DeviceBase* device, RenderPipelineBase::RenderPipelineBase(DeviceBase* device,
const RenderPipelineDescriptor2* descriptor) const RenderPipelineDescriptor2* descriptor)
: PipelineBase(device, : PipelineBase(device,

6
src/dawn_native/RenderPipeline.h
View File

@ -29,12 +29,9 @@ namespace dawn_native {
class DeviceBase; class DeviceBase;
MaybeError ValidateRenderPipelineDescriptor(DeviceBase* device,
const RenderPipelineDescriptor* descriptor);
MaybeError ValidateRenderPipelineDescriptor(DeviceBase* device, MaybeError ValidateRenderPipelineDescriptor(DeviceBase* device,
const RenderPipelineDescriptor2* descriptor); const RenderPipelineDescriptor2* descriptor);
std::vector<StageAndDescriptor> GetStages(const RenderPipelineDescriptor* descriptor);
std::vector<StageAndDescriptor> GetStages(const RenderPipelineDescriptor2* descriptor); std::vector<StageAndDescriptor> GetStages(const RenderPipelineDescriptor2* descriptor);
size_t IndexFormatSize(wgpu::IndexFormat format); size_t IndexFormatSize(wgpu::IndexFormat format);
@ -43,6 +40,8 @@ namespace dawn_native {
bool StencilTestEnabled(const DepthStencilState* mDepthStencil); bool StencilTestEnabled(const DepthStencilState* mDepthStencil);
bool BlendEnabled(const ColorStateDescriptor* mColorState);
struct VertexAttributeInfo { struct VertexAttributeInfo {
wgpu::VertexFormat format; wgpu::VertexFormat format;
uint64_t offset; uint64_t offset;
@ -57,7 +56,6 @@ namespace dawn_native {
class RenderPipelineBase : public PipelineBase { class RenderPipelineBase : public PipelineBase {
public: public:
RenderPipelineBase(DeviceBase* device, const RenderPipelineDescriptor* descriptor);
RenderPipelineBase(DeviceBase* device, const RenderPipelineDescriptor2* descriptor); RenderPipelineBase(DeviceBase* device, const RenderPipelineDescriptor2* descriptor);
~RenderPipelineBase() override; ~RenderPipelineBase() override;

10
src/dawn_native/ShaderModule.cpp
View File

@ -1145,14 +1145,14 @@ namespace dawn_native {
} }
std::unique_ptr<tint::transform::VertexPulling> MakeVertexPullingTransform( std::unique_ptr<tint::transform::VertexPulling> MakeVertexPullingTransform(
const VertexStateDescriptor& vertexState, const VertexState& vertexState,
const std::string& entryPoint, const std::string& entryPoint,
BindGroupIndex pullingBufferBindingSet) { BindGroupIndex pullingBufferBindingSet) {
tint::transform::VertexPulling::Config cfg; tint::transform::VertexPulling::Config cfg;
cfg.entry_point_name = entryPoint; cfg.entry_point_name = entryPoint;
cfg.pulling_group = static_cast<uint32_t>(pullingBufferBindingSet); cfg.pulling_group = static_cast<uint32_t>(pullingBufferBindingSet);
for (uint32_t i = 0; i < vertexState.vertexBufferCount; ++i) { for (uint32_t i = 0; i < vertexState.bufferCount; ++i) {
const auto& vertexBuffer = vertexState.vertexBuffers[i]; const auto& vertexBuffer = vertexState.buffers[i];
tint::transform::VertexBufferLayoutDescriptor layout; tint::transform::VertexBufferLayoutDescriptor layout;
layout.array_stride = vertexBuffer.arrayStride; layout.array_stride = vertexBuffer.arrayStride;
layout.step_mode = ToTintInputStepMode(vertexBuffer.stepMode); layout.step_mode = ToTintInputStepMode(vertexBuffer.stepMode);
@ -1267,7 +1267,7 @@ namespace dawn_native {
ResultOrError<std::vector<uint32_t>> ShaderModuleBase::GeneratePullingSpirv( ResultOrError<std::vector<uint32_t>> ShaderModuleBase::GeneratePullingSpirv(
const std::vector<uint32_t>& spirv, const std::vector<uint32_t>& spirv,
const VertexStateDescriptor& vertexState, const VertexState& vertexState,
const std::string& entryPoint, const std::string& entryPoint,
BindGroupIndex pullingBufferBindingSet) const { BindGroupIndex pullingBufferBindingSet) const {
tint::Program program; tint::Program program;
@ -1278,7 +1278,7 @@ namespace dawn_native {
ResultOrError<std::vector<uint32_t>> ShaderModuleBase::GeneratePullingSpirv( ResultOrError<std::vector<uint32_t>> ShaderModuleBase::GeneratePullingSpirv(
const tint::Program* programIn, const tint::Program* programIn,
const VertexStateDescriptor& vertexState, const VertexState& vertexState,
const std::string& entryPoint, const std::string& entryPoint,
BindGroupIndex pullingBufferBindingSet) const { BindGroupIndex pullingBufferBindingSet) const {
std::ostringstream errorStream; std::ostringstream errorStream;

6
src/dawn_native/ShaderModule.h
View File

@ -77,7 +77,7 @@ namespace dawn_native {
const tint::Program* program); const tint::Program* program);
std::unique_ptr<tint::transform::VertexPulling> MakeVertexPullingTransform( std::unique_ptr<tint::transform::VertexPulling> MakeVertexPullingTransform(
const VertexStateDescriptor& vertexState, const VertexState& vertexState,
const std::string& entryPoint, const std::string& entryPoint,
BindGroupIndex pullingBufferBindingSet); BindGroupIndex pullingBufferBindingSet);
@ -145,13 +145,13 @@ namespace dawn_native {
ResultOrError<std::vector<uint32_t>> GeneratePullingSpirv( ResultOrError<std::vector<uint32_t>> GeneratePullingSpirv(
const std::vector<uint32_t>& spirv, const std::vector<uint32_t>& spirv,
const VertexStateDescriptor& vertexState, const VertexState& vertexState,
const std::string& entryPoint, const std::string& entryPoint,
BindGroupIndex pullingBufferBindingSet) const; BindGroupIndex pullingBufferBindingSet) const;
ResultOrError<std::vector<uint32_t>> GeneratePullingSpirv( ResultOrError<std::vector<uint32_t>> GeneratePullingSpirv(
const tint::Program* program, const tint::Program* program,
const VertexStateDescriptor& vertexState, const VertexState& vertexState,
const std::string& entryPoint, const std::string& entryPoint,
BindGroupIndex pullingBufferBindingSet) const; BindGroupIndex pullingBufferBindingSet) const;

2
src/dawn_native/d3d12/DeviceD3D12.cpp
View File

@ -326,7 +326,7 @@ namespace dawn_native { namespace d3d12 {
return QuerySet::Create(this, descriptor); return QuerySet::Create(this, descriptor);
} }
ResultOrError<Ref<RenderPipelineBase>> Device::CreateRenderPipelineImpl( ResultOrError<Ref<RenderPipelineBase>> Device::CreateRenderPipelineImpl(
const RenderPipelineDescriptor* descriptor) { const RenderPipelineDescriptor2* descriptor) {
return RenderPipeline::Create(this, descriptor); return RenderPipeline::Create(this, descriptor);
} }
ResultOrError<Ref<SamplerBase>> Device::CreateSamplerImpl(const SamplerDescriptor* descriptor) { ResultOrError<Ref<SamplerBase>> Device::CreateSamplerImpl(const SamplerDescriptor* descriptor) {

2
src/dawn_native/d3d12/DeviceD3D12.h
View File

@ -154,7 +154,7 @@ namespace dawn_native { namespace d3d12 {
ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl( ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl(
const QuerySetDescriptor* descriptor) override; const QuerySetDescriptor* descriptor) override;
ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl( ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl(
const RenderPipelineDescriptor* descriptor) override; const RenderPipelineDescriptor2* descriptor) override;
ResultOrError<Ref<SamplerBase>> CreateSamplerImpl( ResultOrError<Ref<SamplerBase>> CreateSamplerImpl(
const SamplerDescriptor* descriptor) override; const SamplerDescriptor* descriptor) override;
ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl( ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl(

14
src/dawn_native/d3d12/RenderPipelineD3D12.cpp
View File

@ -297,13 +297,13 @@ namespace dawn_native { namespace d3d12 {
ResultOrError<Ref<RenderPipeline>> RenderPipeline::Create( ResultOrError<Ref<RenderPipeline>> RenderPipeline::Create(
Device* device, Device* device,
const RenderPipelineDescriptor* descriptor) { const RenderPipelineDescriptor2* descriptor) {
Ref<RenderPipeline> pipeline = AcquireRef(new RenderPipeline(device, descriptor)); Ref<RenderPipeline> pipeline = AcquireRef(new RenderPipeline(device, descriptor));
DAWN_TRY(pipeline->Initialize(descriptor)); DAWN_TRY(pipeline->Initialize(descriptor));
return pipeline; return pipeline;
} }
MaybeError RenderPipeline::Initialize(const RenderPipelineDescriptor* descriptor) { MaybeError RenderPipeline::Initialize(const RenderPipelineDescriptor2* descriptor) {
Device* device = ToBackend(GetDevice()); Device* device = ToBackend(GetDevice());
uint32_t compileFlags = 0; uint32_t compileFlags = 0;
#if defined(_DEBUG) #if defined(_DEBUG)
@ -316,12 +316,12 @@ namespace dawn_native { namespace d3d12 {
D3D12_GRAPHICS_PIPELINE_STATE_DESC descriptorD3D12 = {}; D3D12_GRAPHICS_PIPELINE_STATE_DESC descriptorD3D12 = {};
PerStage<const char*> entryPoints; PerStage<const char*> entryPoints;
entryPoints[SingleShaderStage::Vertex] = descriptor->vertexStage.entryPoint; entryPoints[SingleShaderStage::Vertex] = descriptor->vertex.entryPoint;
entryPoints[SingleShaderStage::Fragment] = descriptor->fragmentStage->entryPoint; entryPoints[SingleShaderStage::Fragment] = descriptor->fragment->entryPoint;
PerStage<ShaderModule*> modules; PerStage<ShaderModule*> modules;
modules[SingleShaderStage::Vertex] = ToBackend(descriptor->vertexStage.module); modules[SingleShaderStage::Vertex] = ToBackend(descriptor->vertex.module);
modules[SingleShaderStage::Fragment] = ToBackend(descriptor->fragmentStage->module); modules[SingleShaderStage::Fragment] = ToBackend(descriptor->fragment->module);
PerStage<D3D12_SHADER_BYTECODE*> shaders; PerStage<D3D12_SHADER_BYTECODE*> shaders;
shaders[SingleShaderStage::Vertex] = &descriptorD3D12.VS; shaders[SingleShaderStage::Vertex] = &descriptorD3D12.VS;
@ -377,7 +377,7 @@ namespace dawn_native { namespace d3d12 {
} }
descriptorD3D12.NumRenderTargets = static_cast<uint32_t>(GetColorAttachmentsMask().count()); descriptorD3D12.NumRenderTargets = static_cast<uint32_t>(GetColorAttachmentsMask().count());
descriptorD3D12.BlendState.AlphaToCoverageEnable = descriptor->alphaToCoverageEnabled; descriptorD3D12.BlendState.AlphaToCoverageEnable = IsAlphaToCoverageEnabled();
descriptorD3D12.BlendState.IndependentBlendEnable = TRUE; descriptorD3D12.BlendState.IndependentBlendEnable = TRUE;
descriptorD3D12.DepthStencilState = ComputeDepthStencilDesc(GetDepthStencilState()); descriptorD3D12.DepthStencilState = ComputeDepthStencilDesc(GetDepthStencilState());

4
src/dawn_native/d3d12/RenderPipelineD3D12.h
View File

@ -28,7 +28,7 @@ namespace dawn_native { namespace d3d12 {
public: public:
static ResultOrError<Ref<RenderPipeline>> Create( static ResultOrError<Ref<RenderPipeline>> Create(
Device* device, Device* device,
const RenderPipelineDescriptor* descriptor); const RenderPipelineDescriptor2* descriptor);
RenderPipeline() = delete; RenderPipeline() = delete;
D3D12_PRIMITIVE_TOPOLOGY GetD3D12PrimitiveTopology() const; D3D12_PRIMITIVE_TOPOLOGY GetD3D12PrimitiveTopology() const;
@ -39,7 +39,7 @@ namespace dawn_native { namespace d3d12 {
private: private:
~RenderPipeline() override; ~RenderPipeline() override;
using RenderPipelineBase::RenderPipelineBase; using RenderPipelineBase::RenderPipelineBase;
MaybeError Initialize(const RenderPipelineDescriptor* descriptor); MaybeError Initialize(const RenderPipelineDescriptor2* descriptor);
D3D12_INPUT_LAYOUT_DESC ComputeInputLayout( D3D12_INPUT_LAYOUT_DESC ComputeInputLayout(
std::array<D3D12_INPUT_ELEMENT_DESC, kMaxVertexAttributes>* inputElementDescriptors); std::array<D3D12_INPUT_ELEMENT_DESC, kMaxVertexAttributes>* inputElementDescriptors);

2
src/dawn_native/metal/DeviceMTL.h
View File

@ -91,7 +91,7 @@ namespace dawn_native { namespace metal {
ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl( ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl(
const QuerySetDescriptor* descriptor) override; const QuerySetDescriptor* descriptor) override;
ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl( ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl(
const RenderPipelineDescriptor* descriptor) override; const RenderPipelineDescriptor2* descriptor) override;
ResultOrError<Ref<SamplerBase>> CreateSamplerImpl( ResultOrError<Ref<SamplerBase>> CreateSamplerImpl(
const SamplerDescriptor* descriptor) override; const SamplerDescriptor* descriptor) override;
ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl( ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl(

2
src/dawn_native/metal/DeviceMTL.mm
View File

@ -146,7 +146,7 @@ namespace dawn_native { namespace metal {
return QuerySet::Create(this, descriptor); return QuerySet::Create(this, descriptor);
} }
ResultOrError<Ref<RenderPipelineBase>> Device::CreateRenderPipelineImpl( ResultOrError<Ref<RenderPipelineBase>> Device::CreateRenderPipelineImpl(
const RenderPipelineDescriptor* descriptor) { const RenderPipelineDescriptor2* descriptor) {
return RenderPipeline::Create(this, descriptor); return RenderPipeline::Create(this, descriptor);
} }
ResultOrError<Ref<SamplerBase>> Device::CreateSamplerImpl(const SamplerDescriptor* descriptor) { ResultOrError<Ref<SamplerBase>> Device::CreateSamplerImpl(const SamplerDescriptor* descriptor) {

4
src/dawn_native/metal/RenderPipelineMTL.h
View File

@ -29,7 +29,7 @@ namespace dawn_native { namespace metal {
public: public:
static ResultOrError<Ref<RenderPipeline>> Create( static ResultOrError<Ref<RenderPipeline>> Create(
Device* device, Device* device,
const RenderPipelineDescriptor* descriptor); const RenderPipelineDescriptor2* descriptor);
MTLPrimitiveType GetMTLPrimitiveTopology() const; MTLPrimitiveType GetMTLPrimitiveTopology() const;
MTLWinding GetMTLFrontFace() const; MTLWinding GetMTLFrontFace() const;
@ -47,7 +47,7 @@ namespace dawn_native { namespace metal {
private: private:
using RenderPipelineBase::RenderPipelineBase; using RenderPipelineBase::RenderPipelineBase;
MaybeError Initialize(const RenderPipelineDescriptor* descriptor); MaybeError Initialize(const RenderPipelineDescriptor2* descriptor);
MTLVertexDescriptor* MakeVertexDesc(); MTLVertexDescriptor* MakeVertexDesc();

20
src/dawn_native/metal/RenderPipelineMTL.mm
View File

@ -312,13 +312,13 @@ namespace dawn_native { namespace metal {
// static // static
ResultOrError<Ref<RenderPipeline>> RenderPipeline::Create( ResultOrError<Ref<RenderPipeline>> RenderPipeline::Create(
Device* device, Device* device,
const RenderPipelineDescriptor* descriptor) { const RenderPipelineDescriptor2* descriptor) {
Ref<RenderPipeline> pipeline = AcquireRef(new RenderPipeline(device, descriptor)); Ref<RenderPipeline> pipeline = AcquireRef(new RenderPipeline(device, descriptor));
DAWN_TRY(pipeline->Initialize(descriptor)); DAWN_TRY(pipeline->Initialize(descriptor));
return pipeline; return pipeline;
} }
MaybeError RenderPipeline::Initialize(const RenderPipelineDescriptor* descriptor) { MaybeError RenderPipeline::Initialize(const RenderPipelineDescriptor2* descriptor) {
mMtlPrimitiveTopology = MTLPrimitiveTopology(GetPrimitiveTopology()); mMtlPrimitiveTopology = MTLPrimitiveTopology(GetPrimitiveTopology());
mMtlFrontFace = MTLFrontFace(GetFrontFace()); mMtlFrontFace = MTLFrontFace(GetFrontFace());
mMtlCullMode = ToMTLCullMode(GetCullMode()); mMtlCullMode = ToMTLCullMode(GetCullMode());
@ -338,12 +338,12 @@ namespace dawn_native { namespace metal {
} }
descriptorMTL.vertexDescriptor = vertexDesc.Get(); descriptorMTL.vertexDescriptor = vertexDesc.Get();
ShaderModule* vertexModule = ToBackend(descriptor->vertexStage.module); ShaderModule* vertexModule = ToBackend(descriptor->vertex.module);
const char* vertexEntryPoint = descriptor->vertexStage.entryPoint; const char* vertexEntryPoint = descriptor->vertex.entryPoint;
ShaderModule::MetalFunctionData vertexData; ShaderModule::MetalFunctionData vertexData;
const VertexStateDescriptor* vertexStatePtr = descriptor->vertexState; const VertexState* vertexStatePtr = &descriptor->vertex;
VertexStateDescriptor vertexState; VertexState vertexState;
if (vertexStatePtr == nullptr) { if (vertexStatePtr == nullptr) {
vertexState = {}; vertexState = {};
vertexStatePtr = &vertexState; vertexStatePtr = &vertexState;
@ -358,12 +358,12 @@ namespace dawn_native { namespace metal {
mStagesRequiringStorageBufferLength |= wgpu::ShaderStage::Vertex; mStagesRequiringStorageBufferLength |= wgpu::ShaderStage::Vertex;
} }
ShaderModule* fragmentModule = ToBackend(descriptor->fragmentStage->module); ShaderModule* fragmentModule = ToBackend(descriptor->fragment->module);
const char* fragmentEntryPoint = descriptor->fragmentStage->entryPoint; const char* fragmentEntryPoint = descriptor->fragment->entryPoint;
ShaderModule::MetalFunctionData fragmentData; ShaderModule::MetalFunctionData fragmentData;
DAWN_TRY(fragmentModule->CreateFunction(fragmentEntryPoint, SingleShaderStage::Fragment, DAWN_TRY(fragmentModule->CreateFunction(fragmentEntryPoint, SingleShaderStage::Fragment,
ToBackend(GetLayout()), &fragmentData, ToBackend(GetLayout()), &fragmentData,
descriptor->sampleMask)); GetSampleMask()));
descriptorMTL.fragmentFunction = fragmentData.function.Get(); descriptorMTL.fragmentFunction = fragmentData.function.Get();
if (fragmentData.needsStorageBufferLength) { if (fragmentData.needsStorageBufferLength) {
@ -395,7 +395,7 @@ namespace dawn_native { namespace metal {
descriptorMTL.inputPrimitiveTopology = MTLInputPrimitiveTopology(GetPrimitiveTopology()); descriptorMTL.inputPrimitiveTopology = MTLInputPrimitiveTopology(GetPrimitiveTopology());
descriptorMTL.sampleCount = GetSampleCount(); descriptorMTL.sampleCount = GetSampleCount();
descriptorMTL.alphaToCoverageEnabled = descriptor->alphaToCoverageEnabled; descriptorMTL.alphaToCoverageEnabled = IsAlphaToCoverageEnabled();
{ {
NSError* error = nullptr; NSError* error = nullptr;

6
src/dawn_native/metal/ShaderModuleMTL.h
View File

@ -48,7 +48,7 @@ namespace dawn_native { namespace metal {
MetalFunctionData* out, MetalFunctionData* out,
uint32_t sampleMask = 0xFFFFFFFF, uint32_t sampleMask = 0xFFFFFFFF,
const RenderPipeline* renderPipeline = nullptr, const RenderPipeline* renderPipeline = nullptr,
const VertexStateDescriptor* vertexState = nullptr); const VertexState* vertexState = nullptr);
private: private:
ResultOrError<std::string> TranslateToMSLWithTint(const char* entryPointName, ResultOrError<std::string> TranslateToMSLWithTint(const char* entryPointName,
@ -56,7 +56,7 @@ namespace dawn_native { namespace metal {
const PipelineLayout* layout, const PipelineLayout* layout,
uint32_t sampleMask, uint32_t sampleMask,
const RenderPipeline* renderPipeline, const RenderPipeline* renderPipeline,
const VertexStateDescriptor* vertexState, const VertexState* vertexState,
std::string* remappedEntryPointName, std::string* remappedEntryPointName,
bool* needsStorageBufferLength); bool* needsStorageBufferLength);
ResultOrError<std::string> TranslateToMSLWithSPIRVCross( ResultOrError<std::string> TranslateToMSLWithSPIRVCross(
@ -65,7 +65,7 @@ namespace dawn_native { namespace metal {
const PipelineLayout* layout, const PipelineLayout* layout,
uint32_t sampleMask, uint32_t sampleMask,
const RenderPipeline* renderPipeline, const RenderPipeline* renderPipeline,
const VertexStateDescriptor* vertexState, const VertexState* vertexState,
std::string* remappedEntryPointName, std::string* remappedEntryPointName,
bool* needsStorageBufferLength); bool* needsStorageBufferLength);

6
src/dawn_native/metal/ShaderModuleMTL.mm
View File

@ -58,7 +58,7 @@ namespace dawn_native { namespace metal {
// TODO(crbug.com/tint/387): AND in a fixed sample mask in the shader. // TODO(crbug.com/tint/387): AND in a fixed sample mask in the shader.
uint32_t sampleMask, uint32_t sampleMask,
const RenderPipeline* renderPipeline, const RenderPipeline* renderPipeline,
const VertexStateDescriptor* vertexState, const VertexState* vertexState,
std::string* remappedEntryPointName, std::string* remappedEntryPointName,
bool* needsStorageBufferLength) { bool* needsStorageBufferLength) {
// TODO(crbug.com/tint/256): Set this accordingly if arrayLength(..) is used. // TODO(crbug.com/tint/256): Set this accordingly if arrayLength(..) is used.
@ -122,7 +122,7 @@ namespace dawn_native { namespace metal {
const PipelineLayout* layout, const PipelineLayout* layout,
uint32_t sampleMask, uint32_t sampleMask,
const RenderPipeline* renderPipeline, const RenderPipeline* renderPipeline,
const VertexStateDescriptor* vertexState, const VertexState* vertexState,
std::string* remappedEntryPointName, std::string* remappedEntryPointName,
bool* needsStorageBufferLength) { bool* needsStorageBufferLength) {
const std::vector<uint32_t>* spirv = &GetSpirv(); const std::vector<uint32_t>* spirv = &GetSpirv();
@ -232,7 +232,7 @@ namespace dawn_native { namespace metal {
ShaderModule::MetalFunctionData* out, ShaderModule::MetalFunctionData* out,
uint32_t sampleMask, uint32_t sampleMask,
const RenderPipeline* renderPipeline, const RenderPipeline* renderPipeline,
const VertexStateDescriptor* vertexState) { const VertexState* vertexState) {
ASSERT(!IsError()); ASSERT(!IsError());
ASSERT(out); ASSERT(out);

2
src/dawn_native/null/DeviceNull.cpp
View File

@ -122,7 +122,7 @@ namespace dawn_native { namespace null {
return AcquireRef(new QuerySet(this, descriptor)); return AcquireRef(new QuerySet(this, descriptor));
} }
ResultOrError<Ref<RenderPipelineBase>> Device::CreateRenderPipelineImpl( ResultOrError<Ref<RenderPipelineBase>> Device::CreateRenderPipelineImpl(
const RenderPipelineDescriptor* descriptor) { const RenderPipelineDescriptor2* descriptor) {
return AcquireRef(new RenderPipeline(this, descriptor)); return AcquireRef(new RenderPipeline(this, descriptor));
} }
ResultOrError<Ref<SamplerBase>> Device::CreateSamplerImpl(const SamplerDescriptor* descriptor) { ResultOrError<Ref<SamplerBase>> Device::CreateSamplerImpl(const SamplerDescriptor* descriptor) {

2
src/dawn_native/null/DeviceNull.h
View File

@ -135,7 +135,7 @@ namespace dawn_native { namespace null {
ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl( ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl(
const QuerySetDescriptor* descriptor) override; const QuerySetDescriptor* descriptor) override;
ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl( ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl(
const RenderPipelineDescriptor* descriptor) override; const RenderPipelineDescriptor2* descriptor) override;
ResultOrError<Ref<SamplerBase>> CreateSamplerImpl( ResultOrError<Ref<SamplerBase>> CreateSamplerImpl(
const SamplerDescriptor* descriptor) override; const SamplerDescriptor* descriptor) override;
ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl( ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl(

2
src/dawn_native/opengl/DeviceGL.cpp
View File

@ -140,7 +140,7 @@ namespace dawn_native { namespace opengl {
return AcquireRef(new QuerySet(this, descriptor)); return AcquireRef(new QuerySet(this, descriptor));
} }
ResultOrError<Ref<RenderPipelineBase>> Device::CreateRenderPipelineImpl( ResultOrError<Ref<RenderPipelineBase>> Device::CreateRenderPipelineImpl(
const RenderPipelineDescriptor* descriptor) { const RenderPipelineDescriptor2* descriptor) {
return AcquireRef(new RenderPipeline(this, descriptor)); return AcquireRef(new RenderPipeline(this, descriptor));
} }
ResultOrError<Ref<SamplerBase>> Device::CreateSamplerImpl(const SamplerDescriptor* descriptor) { ResultOrError<Ref<SamplerBase>> Device::CreateSamplerImpl(const SamplerDescriptor* descriptor) {

2
src/dawn_native/opengl/DeviceGL.h
View File

@ -90,7 +90,7 @@ namespace dawn_native { namespace opengl {
ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl( ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl(
const QuerySetDescriptor* descriptor) override; const QuerySetDescriptor* descriptor) override;
ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl( ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl(
const RenderPipelineDescriptor* descriptor) override; const RenderPipelineDescriptor2* descriptor) override;
ResultOrError<Ref<SamplerBase>> CreateSamplerImpl( ResultOrError<Ref<SamplerBase>> CreateSamplerImpl(
const SamplerDescriptor* descriptor) override; const SamplerDescriptor* descriptor) override;
ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl( ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl(

10
src/dawn_native/opengl/RenderPipelineGL.cpp
View File

@ -210,16 +210,16 @@ namespace dawn_native { namespace opengl {
} // anonymous namespace } // anonymous namespace
RenderPipeline::RenderPipeline(Device* device, const RenderPipelineDescriptor* descriptor) RenderPipeline::RenderPipeline(Device* device, const RenderPipelineDescriptor2* descriptor)
: RenderPipelineBase(device, descriptor), : RenderPipelineBase(device, descriptor),
mVertexArrayObject(0), mVertexArrayObject(0),
mGlPrimitiveTopology(GLPrimitiveTopology(GetPrimitiveTopology())) { mGlPrimitiveTopology(GLPrimitiveTopology(GetPrimitiveTopology())) {
PerStage<const ShaderModule*> modules(nullptr); PerStage<const ShaderModule*> modules(nullptr);
modules[SingleShaderStage::Vertex] = ToBackend(descriptor->vertexStage.module); modules[SingleShaderStage::Vertex] = ToBackend(descriptor->vertex.module);
modules[SingleShaderStage::Fragment] = ToBackend(descriptor->fragmentStage->module); modules[SingleShaderStage::Fragment] = ToBackend(descriptor->fragment->module);
PipelineGL::Initialize(device->gl, ToBackend(GetLayout()), GetAllStages()); PipelineGL::Initialize(device->gl, ToBackend(GetLayout()), GetAllStages());
CreateVAOForVertexState(descriptor->vertexState); CreateVAOForVertexState();
} }
RenderPipeline::~RenderPipeline() { RenderPipeline::~RenderPipeline() {
@ -238,7 +238,7 @@ namespace dawn_native { namespace opengl {
return mAttributesUsingVertexBuffer[slot]; return mAttributesUsingVertexBuffer[slot];
} }
void RenderPipeline::CreateVAOForVertexState(const VertexStateDescriptor* vertexState) { void RenderPipeline::CreateVAOForVertexState() {
const OpenGLFunctions& gl = ToBackend(GetDevice())->gl; const OpenGLFunctions& gl = ToBackend(GetDevice())->gl;
gl.GenVertexArrays(1, &mVertexArrayObject); gl.GenVertexArrays(1, &mVertexArrayObject);

4
src/dawn_native/opengl/RenderPipelineGL.h
View File

@ -29,7 +29,7 @@ namespace dawn_native { namespace opengl {
class RenderPipeline final : public RenderPipelineBase, public PipelineGL { class RenderPipeline final : public RenderPipelineBase, public PipelineGL {
public: public:
RenderPipeline(Device* device, const RenderPipelineDescriptor* descriptor); RenderPipeline(Device* device, const RenderPipelineDescriptor2* descriptor);
GLenum GetGLPrimitiveTopology() const; GLenum GetGLPrimitiveTopology() const;
ityp::bitset<VertexAttributeLocation, kMaxVertexAttributes> GetAttributesUsingVertexBuffer( ityp::bitset<VertexAttributeLocation, kMaxVertexAttributes> GetAttributesUsingVertexBuffer(
@ -39,7 +39,7 @@ namespace dawn_native { namespace opengl {
private: private:
~RenderPipeline() override; ~RenderPipeline() override;
void CreateVAOForVertexState(const VertexStateDescriptor* vertexState); void CreateVAOForVertexState();
// TODO(yunchao.he@intel.com): vao need to be deduplicated between pipelines. // TODO(yunchao.he@intel.com): vao need to be deduplicated between pipelines.
GLuint mVertexArrayObject; GLuint mVertexArrayObject;

2
src/dawn_native/vulkan/DeviceVk.cpp
View File

@ -131,7 +131,7 @@ namespace dawn_native { namespace vulkan {
return QuerySet::Create(this, descriptor); return QuerySet::Create(this, descriptor);
} }
ResultOrError<Ref<RenderPipelineBase>> Device::CreateRenderPipelineImpl( ResultOrError<Ref<RenderPipelineBase>> Device::CreateRenderPipelineImpl(
const RenderPipelineDescriptor* descriptor) { const RenderPipelineDescriptor2* descriptor) {
return RenderPipeline::Create(this, descriptor); return RenderPipeline::Create(this, descriptor);
} }
ResultOrError<Ref<SamplerBase>> Device::CreateSamplerImpl(const SamplerDescriptor* descriptor) { ResultOrError<Ref<SamplerBase>> Device::CreateSamplerImpl(const SamplerDescriptor* descriptor) {

2
src/dawn_native/vulkan/DeviceVk.h
View File

@ -127,7 +127,7 @@ namespace dawn_native { namespace vulkan {
ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl( ResultOrError<Ref<QuerySetBase>> CreateQuerySetImpl(
const QuerySetDescriptor* descriptor) override; const QuerySetDescriptor* descriptor) override;
ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl( ResultOrError<Ref<RenderPipelineBase>> CreateRenderPipelineImpl(
const RenderPipelineDescriptor* descriptor) override; const RenderPipelineDescriptor2* descriptor) override;
ResultOrError<Ref<SamplerBase>> CreateSamplerImpl( ResultOrError<Ref<SamplerBase>> CreateSamplerImpl(
const SamplerDescriptor* descriptor) override; const SamplerDescriptor* descriptor) override;
ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl( ResultOrError<Ref<ShaderModuleBase>> CreateShaderModuleImpl(

14
src/dawn_native/vulkan/RenderPipelineVk.cpp
View File

@ -321,13 +321,13 @@ namespace dawn_native { namespace vulkan {
// static // static
ResultOrError<Ref<RenderPipeline>> RenderPipeline::Create( ResultOrError<Ref<RenderPipeline>> RenderPipeline::Create(
Device* device, Device* device,
const RenderPipelineDescriptor* descriptor) { const RenderPipelineDescriptor2* descriptor) {
Ref<RenderPipeline> pipeline = AcquireRef(new RenderPipeline(device, descriptor)); Ref<RenderPipeline> pipeline = AcquireRef(new RenderPipeline(device, descriptor));
DAWN_TRY(pipeline->Initialize(descriptor)); DAWN_TRY(pipeline->Initialize(descriptor));
return pipeline; return pipeline;
} }
MaybeError RenderPipeline::Initialize(const RenderPipelineDescriptor* descriptor) { MaybeError RenderPipeline::Initialize(const RenderPipelineDescriptor2* descriptor) {
Device* device = ToBackend(GetDevice()); Device* device = ToBackend(GetDevice());
VkPipelineShaderStageCreateInfo shaderStages[2]; VkPipelineShaderStageCreateInfo shaderStages[2];
@ -337,16 +337,16 @@ namespace dawn_native { namespace vulkan {
shaderStages[0].flags = 0; shaderStages[0].flags = 0;
shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
shaderStages[0].pSpecializationInfo = nullptr; shaderStages[0].pSpecializationInfo = nullptr;
shaderStages[0].module = ToBackend(descriptor->vertexStage.module)->GetHandle(); shaderStages[0].module = ToBackend(descriptor->vertex.module)->GetHandle();
shaderStages[0].pName = descriptor->vertexStage.entryPoint; shaderStages[0].pName = descriptor->vertex.entryPoint;
shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
shaderStages[1].pNext = nullptr; shaderStages[1].pNext = nullptr;
shaderStages[1].flags = 0; shaderStages[1].flags = 0;
shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
shaderStages[1].pSpecializationInfo = nullptr; shaderStages[1].pSpecializationInfo = nullptr;
shaderStages[1].module = ToBackend(descriptor->fragmentStage->module)->GetHandle(); shaderStages[1].module = ToBackend(descriptor->fragment->module)->GetHandle();
shaderStages[1].pName = descriptor->fragmentStage->entryPoint; shaderStages[1].pName = descriptor->fragment->entryPoint;
} }
PipelineVertexInputStateCreateInfoTemporaryAllocations tempAllocations; PipelineVertexInputStateCreateInfoTemporaryAllocations tempAllocations;
@ -411,7 +411,7 @@ namespace dawn_native { namespace vulkan {
ASSERT(multisample.rasterizationSamples <= 32); ASSERT(multisample.rasterizationSamples <= 32);
VkSampleMask sampleMask = GetSampleMask(); VkSampleMask sampleMask = GetSampleMask();
multisample.pSampleMask = &sampleMask; multisample.pSampleMask = &sampleMask;
multisample.alphaToCoverageEnable = descriptor->alphaToCoverageEnabled; multisample.alphaToCoverageEnable = IsAlphaToCoverageEnabled();
multisample.alphaToOneEnable = VK_FALSE; multisample.alphaToOneEnable = VK_FALSE;
VkPipelineDepthStencilStateCreateInfo depthStencilState = VkPipelineDepthStencilStateCreateInfo depthStencilState =

4
src/dawn_native/vulkan/RenderPipelineVk.h
View File

@ -28,14 +28,14 @@ namespace dawn_native { namespace vulkan {
public: public:
static ResultOrError<Ref<RenderPipeline>> Create( static ResultOrError<Ref<RenderPipeline>> Create(
Device* device, Device* device,
const RenderPipelineDescriptor* descriptor); const RenderPipelineDescriptor2* descriptor);
VkPipeline GetHandle() const; VkPipeline GetHandle() const;
private: private:
~RenderPipeline() override; ~RenderPipeline() override;
using RenderPipelineBase::RenderPipelineBase; using RenderPipelineBase::RenderPipelineBase;
MaybeError Initialize(const RenderPipelineDescriptor* descriptor); MaybeError Initialize(const RenderPipelineDescriptor2* descriptor);
struct PipelineVertexInputStateCreateInfoTemporaryAllocations { struct PipelineVertexInputStateCreateInfoTemporaryAllocations {
std::array<VkVertexInputBindingDescription, kMaxVertexBuffers> bindings; std::array<VkVertexInputBindingDescription, kMaxVertexBuffers> bindings;

6
src/tests/unittests/validation/RenderPipelineValidationTests.cpp
View File

@ -59,7 +59,7 @@ TEST_F(RenderPipelineValidationTest, CreationSuccess) {
descriptor.vertexStage.module = vsModule; descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule; descriptor.cFragmentStage.module = fsModule;
device.CreateRenderPipeline(&descriptor); EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline(&descriptor));
} }
{ {
// Vertex input should be optional // Vertex input should be optional
@ -68,7 +68,7 @@ TEST_F(RenderPipelineValidationTest, CreationSuccess) {
descriptor.cFragmentStage.module = fsModule; descriptor.cFragmentStage.module = fsModule;
descriptor.vertexState = nullptr; descriptor.vertexState = nullptr;
device.CreateRenderPipeline(&descriptor); EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline(&descriptor));
} }
{ {
// Rasterization state should be optional // Rasterization state should be optional
@ -76,7 +76,7 @@ TEST_F(RenderPipelineValidationTest, CreationSuccess) {
descriptor.vertexStage.module = vsModule; descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule; descriptor.cFragmentStage.module = fsModule;
descriptor.rasterizationState = nullptr; descriptor.rasterizationState = nullptr;
device.CreateRenderPipeline(&descriptor); EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline(&descriptor));
} }
} }