mirror of
https://github.com/bkaradzic/bgfx.git
synced 2026-08-29 06:28:22 +00:00
239 lines
8.8 KiB
C++
239 lines
8.8 KiB
C++
// Copyright (c) 2022 The Khronos Group Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// Validates ray query instructions from SPV_KHR_ray_query
|
|
|
|
#include <string>
|
|
|
|
#include "source/val/instruction.h"
|
|
#include "source/val/validate.h"
|
|
#include "source/val/validation_state.h"
|
|
|
|
namespace spvtools {
|
|
namespace val {
|
|
|
|
bool IsInterfaceVariable(ValidationState_t& _, const Instruction* inst,
|
|
spv::ExecutionModel model) {
|
|
bool foundInterface = false;
|
|
for (auto entry_point : _.entry_points()) {
|
|
const auto* models = _.GetExecutionModels(entry_point);
|
|
if (models->find(model) == models->end()) return false;
|
|
for (const auto& desc : _.entry_point_descriptions(entry_point)) {
|
|
for (auto interface : desc.interfaces) {
|
|
if (inst->id() == interface) {
|
|
foundInterface = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return foundInterface;
|
|
}
|
|
|
|
spv_result_t ValidateEmitMeshTasks(ValidationState_t& _,
|
|
const Instruction* inst) {
|
|
_.function(inst->function()->id())
|
|
->RegisterExecutionModelLimitation([](spv::ExecutionModel model,
|
|
std::string* message) {
|
|
if (model != spv::ExecutionModel::TaskEXT) {
|
|
if (message) {
|
|
*message = "OpEmitMeshTasksEXT requires TaskEXT execution model";
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
const uint32_t group_count_x = _.GetOperandTypeId(inst, 0);
|
|
if (!_.IsUnsignedIntScalarType(group_count_x) ||
|
|
_.GetBitWidth(group_count_x) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Group Count X must be a 32-bit unsigned int scalar";
|
|
}
|
|
|
|
const uint32_t group_count_y = _.GetOperandTypeId(inst, 1);
|
|
if (!_.IsUnsignedIntScalarType(group_count_y) ||
|
|
_.GetBitWidth(group_count_y) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Group Count Y must be a 32-bit unsigned int scalar";
|
|
}
|
|
|
|
const uint32_t group_count_z = _.GetOperandTypeId(inst, 2);
|
|
if (!_.IsUnsignedIntScalarType(group_count_z) ||
|
|
_.GetBitWidth(group_count_z) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Group Count Z must be a 32-bit unsigned int scalar";
|
|
}
|
|
|
|
if (inst->operands().size() == 4) {
|
|
const auto payload = _.FindDef(inst->GetOperandAs<uint32_t>(3));
|
|
if (payload->opcode() != spv::Op::OpVariable) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Payload must be the result of a OpVariable";
|
|
}
|
|
if (payload->GetOperandAs<spv::StorageClass>(2) !=
|
|
spv::StorageClass::TaskPayloadWorkgroupEXT) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Payload OpVariable must have a storage class of "
|
|
"TaskPayloadWorkgroupEXT";
|
|
}
|
|
}
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
spv_result_t ValidateSetMeshOutputs(ValidationState_t& _,
|
|
const Instruction* inst) {
|
|
_.function(inst->function()->id())
|
|
->RegisterExecutionModelLimitation([](spv::ExecutionModel model,
|
|
std::string* message) {
|
|
if (model != spv::ExecutionModel::MeshEXT) {
|
|
if (message) {
|
|
*message = "OpSetMeshOutputsEXT requires MeshEXT execution model";
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
const uint32_t vertex_count = _.GetOperandTypeId(inst, 0);
|
|
if (!_.IsUnsignedIntScalarType(vertex_count) ||
|
|
_.GetBitWidth(vertex_count) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Vertex Count must be a 32-bit unsigned int scalar";
|
|
}
|
|
|
|
const uint32_t primitive_count = _.GetOperandTypeId(inst, 1);
|
|
if (!_.IsUnsignedIntScalarType(primitive_count) ||
|
|
_.GetBitWidth(primitive_count) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Primitive Count must be a 32-bit unsigned int scalar";
|
|
}
|
|
|
|
// Will only validate if constants are used (or spec constant frozen)
|
|
uint64_t vertex_count_value = 0;
|
|
if (_.EvalConstantValUint64(inst->GetOperandAs<uint32_t>(0),
|
|
&vertex_count_value)) {
|
|
_.function(inst->function()->id())
|
|
->RegisterLimitation(
|
|
[vertex_count_value](const ValidationState_t& state,
|
|
const Function* entry_point,
|
|
std::string* message) {
|
|
const uint32_t output_vertices =
|
|
state.GetOutputVertices(entry_point->id());
|
|
if (vertex_count_value > output_vertices) {
|
|
*message =
|
|
"OpSetMeshOutputsEXT Vertex Count (" +
|
|
std::to_string(vertex_count_value) +
|
|
") is larger than the OutputVertices in OpExecutionMode (" +
|
|
std::to_string(output_vertices) + ").";
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
uint64_t primitive_count_value = 0;
|
|
if (_.EvalConstantValUint64(inst->GetOperandAs<uint32_t>(1),
|
|
&primitive_count_value)) {
|
|
_.function(inst->function()->id())
|
|
->RegisterLimitation(
|
|
[primitive_count_value](const ValidationState_t& state,
|
|
const Function* entry_point,
|
|
std::string* message) {
|
|
const uint32_t output_primitives =
|
|
state.GetOutputPrimitivesEXT(entry_point->id());
|
|
if (primitive_count_value > output_primitives) {
|
|
*message = "OpSetMeshOutputsEXT Primitive Count (" +
|
|
std::to_string(primitive_count_value) +
|
|
") is larger than the OutputPrimitivesEXT in "
|
|
"OpExecutionMode (" +
|
|
std::to_string(output_primitives) + ").";
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
spv_result_t ValidateMeshVariable(ValidationState_t& _,
|
|
const Instruction* inst) {
|
|
if (!_.HasCapability(spv::Capability::MeshShadingEXT)) {
|
|
return SPV_SUCCESS;
|
|
}
|
|
bool is_mesh_interface_var =
|
|
IsInterfaceVariable(_, inst, spv::ExecutionModel::MeshEXT);
|
|
bool is_frag_interface_var =
|
|
IsInterfaceVariable(_, inst, spv::ExecutionModel::Fragment);
|
|
|
|
const spv::StorageClass storage_class =
|
|
inst->GetOperandAs<spv::StorageClass>(2);
|
|
bool storage_output = (storage_class == spv::StorageClass::Output);
|
|
bool storage_input = (storage_class == spv::StorageClass::Input);
|
|
|
|
if (_.HasDecoration(inst->id(), spv::Decoration::PerPrimitiveEXT)) {
|
|
if (is_frag_interface_var && !storage_input) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "PerPrimitiveEXT decoration must be applied only to "
|
|
"variables in the Input Storage Class in the Fragment "
|
|
"Execution Model.";
|
|
}
|
|
|
|
if (is_mesh_interface_var && !storage_output) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< _.VkErrorID(4336)
|
|
<< "PerPrimitiveEXT decoration must be applied only to "
|
|
"variables in the Output Storage Class in the "
|
|
"Storage Class in the MeshEXT Execution Model.";
|
|
}
|
|
}
|
|
|
|
// This only applies to user interface variables, not built-ins (they
|
|
// are validated with the rest of the builtin)
|
|
if (is_mesh_interface_var && storage_output &&
|
|
!_.HasDecoration(inst->id(), spv::Decoration::BuiltIn)) {
|
|
const Instruction* pointer_inst = _.FindDef(inst->type_id());
|
|
if (pointer_inst->opcode() == spv::Op::OpTypePointer) {
|
|
if (!_.IsArrayType(pointer_inst->word(3))) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "In the MeshEXT Execution Mode, all Output Variables "
|
|
"must contain an Array.";
|
|
}
|
|
}
|
|
}
|
|
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
spv_result_t MeshShadingPass(ValidationState_t& _, const Instruction* inst) {
|
|
const spv::Op opcode = inst->opcode();
|
|
switch (opcode) {
|
|
case spv::Op::OpEmitMeshTasksEXT:
|
|
return ValidateEmitMeshTasks(_, inst);
|
|
case spv::Op::OpSetMeshOutputsEXT:
|
|
return ValidateSetMeshOutputs(_, inst);
|
|
case spv::Op::OpVariable:
|
|
return ValidateMeshVariable(_, inst);
|
|
// No validation rules (for the moment).
|
|
case spv::Op::OpWritePackedPrimitiveIndices4x8NV:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
} // namespace val
|
|
} // namespace spvtools
|