| // Copyright 2020 The Tint Authors. | |
| // | |
| // 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. | |
| #ifndef SRC_TRANSFORM_VERTEX_PULLING_H_ | |
| #define SRC_TRANSFORM_VERTEX_PULLING_H_ | |
| #include <memory> | |
| #include <string> | |
| #include <unordered_map> | |
| #include <vector> | |
| #include "src/transform/transform.h" | |
| namespace tint { | |
| namespace transform { | |
| /// Describes the format of data in a vertex buffer | |
| enum class VertexFormat { | |
| kVec2U8, | |
| kVec4U8, | |
| kVec2I8, | |
| kVec4I8, | |
| kVec2U8Norm, | |
| kVec4U8Norm, | |
| kVec2I8Norm, | |
| kVec4I8Norm, | |
| kVec2U16, | |
| kVec4U16, | |
| kVec2I16, | |
| kVec4I16, | |
| kVec2U16Norm, | |
| kVec4U16Norm, | |
| kVec2I16Norm, | |
| kVec4I16Norm, | |
| kVec2F16, | |
| kVec4F16, | |
| kF32, | |
| kVec2F32, | |
| kVec3F32, | |
| kVec4F32, | |
| kU32, | |
| kVec2U32, | |
| kVec3U32, | |
| kVec4U32, | |
| kI32, | |
| kVec2I32, | |
| kVec3I32, | |
| kVec4I32 | |
| }; | |
| /// Describes if a vertex attributes increments with vertex index or instance | |
| /// index | |
| enum class InputStepMode { kVertex, kInstance }; | |
| /// Describes a vertex attribute within a buffer | |
| struct VertexAttributeDescriptor { | |
| /// The format of the attribute | |
| VertexFormat format; | |
| /// The byte offset of the attribute in the buffer | |
| uint64_t offset; | |
| /// The shader location used for the attribute | |
| uint32_t shader_location; | |
| }; | |
| /// Describes a buffer containing multiple vertex attributes | |
| struct VertexBufferLayoutDescriptor { | |
| /// Constructor | |
| VertexBufferLayoutDescriptor(); | |
| /// Constructor | |
| /// @param in_array_stride the array stride of the in buffer | |
| /// @param in_step_mode the step mode of the in buffer | |
| /// @param in_attributes the in attributes | |
| VertexBufferLayoutDescriptor( | |
| uint64_t in_array_stride, | |
| InputStepMode in_step_mode, | |
| std::vector<VertexAttributeDescriptor> in_attributes); | |
| /// Copy constructor | |
| /// @param other the struct to copy | |
| VertexBufferLayoutDescriptor(const VertexBufferLayoutDescriptor& other); | |
| /// Assignment operator | |
| /// @param other the struct to copy | |
| /// @returns this struct | |
| VertexBufferLayoutDescriptor& operator=( | |
| const VertexBufferLayoutDescriptor& other); | |
| ~VertexBufferLayoutDescriptor(); | |
| /// The array stride used in the in buffer | |
| uint64_t array_stride = 0u; | |
| /// The input step mode used | |
| InputStepMode step_mode = InputStepMode::kVertex; | |
| /// The vertex attributes | |
| std::vector<VertexAttributeDescriptor> attributes; | |
| }; | |
| /// Describes vertex state, which consists of many buffers containing vertex | |
| /// attributes | |
| using VertexStateDescriptor = std::vector<VertexBufferLayoutDescriptor>; | |
| /// Converts a program to use vertex pulling | |
| /// | |
| /// Variables which accept vertex input are var<in> with a location decoration. | |
| /// This transform will convert those to be assigned from storage buffers | |
| /// instead. The intention is to allow vertex input to rely on a storage buffer | |
| /// clamping pass for out of bounds reads. We bind the storage buffers as arrays | |
| /// of u32, so any read to byte position `p` will actually need to read position | |
| /// `p / 4`, since `sizeof(u32) == 4`. | |
| /// | |
| /// `VertexFormat` represents the input type of the attribute. This isn't | |
| /// related to the type of the variable in the shader. For example, | |
| /// `VertexFormat::kVec2F16` tells us that the buffer will contain `f16` | |
| /// elements, to be read as vec2. In the shader, a user would make a `vec2<f32>` | |
| /// to be able to use them. The conversion between `f16` and `f32` will need to | |
| /// be handled by us (using unpack functions). | |
| /// | |
| /// To be clear, there won't be types such as `f16` or `u8` anywhere in WGSL | |
| /// code, but these are types that the data may arrive as. We need to convert | |
| /// these smaller types into the base types such as `f32` and `u32` for the | |
| /// shader to use. | |
| class VertexPulling : public Transform { | |
| public: | |
| /// Configuration options for the transform | |
| struct Config { | |
| /// Constructor | |
| Config(); | |
| /// Copy constructor | |
| Config(const Config&); | |
| /// Destructor | |
| ~Config(); | |
| /// The entry point to add assignments into | |
| std::string entry_point_name; | |
| /// The vertex state descriptor, containing info about attributes | |
| VertexStateDescriptor vertex_state; | |
| /// The "group" we will put all our vertex buffers into (as storage buffers) | |
| /// Default to 4 as it is past the limits of user-accessible groups | |
| uint32_t pulling_group = 4u; | |
| }; | |
| /// Constructor | |
| /// @param config the configuration options for the transform | |
| explicit VertexPulling(const Config& config); | |
| /// Destructor | |
| ~VertexPulling() override; | |
| /// Runs the transform on `program`, returning the transformation result. | |
| /// @param program the source program to transform | |
| /// @param data optional extra transform-specific input data | |
| /// @returns the transformation result | |
| Output Run(const Program* program, const DataMap& data = {}) override; | |
| private: | |
| Config cfg; | |
| struct State { | |
| State(CloneContext& ctx, const Config& c); | |
| explicit State(const State&); | |
| ~State(); | |
| /// Generate the vertex buffer binding name | |
| /// @param index index to append to buffer name | |
| std::string GetVertexBufferName(uint32_t index) const; | |
| /// Inserts vertex_index binding, or finds the existing one | |
| void FindOrInsertVertexIndexIfUsed(); | |
| /// Inserts instance_index binding, or finds the existing one | |
| void FindOrInsertInstanceIndexIfUsed(); | |
| /// Converts var<in> with a location decoration to var<private> | |
| void ConvertVertexInputVariablesToPrivate(); | |
| /// Adds storage buffer decorated variables for the vertex buffers | |
| void AddVertexStorageBuffers(); | |
| /// Creates and returns the assignment to the variables from the buffers | |
| ast::BlockStatement* CreateVertexPullingPreamble() const; | |
| /// Generates an expression holding a constant uint | |
| /// @param value uint value | |
| ast::Expression* GenUint(uint32_t value) const; | |
| /// Generates an expression to read the shader value `kPullingPosVarName` | |
| ast::Expression* CreatePullingPositionIdent() const; | |
| /// Generates an expression reading from a buffer a specific format. | |
| /// This reads the value wherever `kPullingPosVarName` points to at the time | |
| /// of the read. | |
| /// @param buffer the index of the vertex buffer | |
| /// @param format the format to read | |
| ast::Expression* AccessByFormat(uint32_t buffer, VertexFormat format) const; | |
| /// Generates an expression reading a uint32 from a vertex buffer | |
| /// @param buffer the index of the vertex buffer | |
| /// @param pos an expression for the position of the access, in bytes | |
| ast::Expression* AccessU32(uint32_t buffer, ast::Expression* pos) const; | |
| /// Generates an expression reading an int32 from a vertex buffer | |
| /// @param buffer the index of the vertex buffer | |
| /// @param pos an expression for the position of the access, in bytes | |
| ast::Expression* AccessI32(uint32_t buffer, ast::Expression* pos) const; | |
| /// Generates an expression reading a float from a vertex buffer | |
| /// @param buffer the index of the vertex buffer | |
| /// @param pos an expression for the position of the access, in bytes | |
| ast::Expression* AccessF32(uint32_t buffer, ast::Expression* pos) const; | |
| /// Generates an expression reading a basic type (u32, i32, f32) from a | |
| /// vertex buffer | |
| /// @param buffer the index of the vertex buffer | |
| /// @param pos an expression for the position of the access, in bytes | |
| /// @param format the underlying vertex format | |
| ast::Expression* AccessPrimitive(uint32_t buffer, | |
| ast::Expression* pos, | |
| VertexFormat format) const; | |
| /// Generates an expression reading a vec2/3/4 from a vertex buffer. | |
| /// This reads the value wherever `kPullingPosVarName` points to at the time | |
| /// of the read. | |
| /// @param buffer the index of the vertex buffer | |
| /// @param element_stride stride between elements, in bytes | |
| /// @param base_type underlying AST type | |
| /// @param base_format underlying vertex format | |
| /// @param count how many elements the vector has | |
| ast::Expression* AccessVec(uint32_t buffer, | |
| uint32_t element_stride, | |
| type::Type* base_type, | |
| VertexFormat base_format, | |
| uint32_t count) const; | |
| // Used to grab corresponding types from the type manager | |
| type::Type* GetU32Type() const; | |
| type::Type* GetI32Type() const; | |
| type::Type* GetF32Type() const; | |
| CloneContext& ctx; | |
| Config const cfg; | |
| /// LocationReplacement describes an ast::Variable replacement for a | |
| /// location input. | |
| struct LocationReplacement { | |
| /// The variable to replace in the source Program | |
| ast::Variable* from; | |
| /// The replacement to use in the target ProgramBuilder | |
| ast::Variable* to; | |
| }; | |
| std::unordered_map<uint32_t, ast::Variable*> location_to_var; | |
| std::vector<LocationReplacement> location_replacements; | |
| std::string vertex_index_name; | |
| std::string instance_index_name; | |
| }; | |
| }; | |
| } // namespace transform | |
| } // namespace tint | |
| #endif // SRC_TRANSFORM_VERTEX_PULLING_H_ |