248 lines
9.2 KiB
C++
248 lines
9.2 KiB
C++
// Copyright 2018 The Amber 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_PIPELINE_DATA_H_
|
|
#define SRC_PIPELINE_DATA_H_
|
|
|
|
#include <limits>
|
|
|
|
#include "src/command_data.h"
|
|
|
|
namespace amber {
|
|
|
|
struct Viewport {
|
|
float x;
|
|
float y;
|
|
float w;
|
|
float h;
|
|
float mind;
|
|
float maxd;
|
|
};
|
|
|
|
/// Stores information used to configure a pipeline.
|
|
class PipelineData {
|
|
public:
|
|
PipelineData();
|
|
~PipelineData();
|
|
PipelineData(const PipelineData&);
|
|
|
|
PipelineData& operator=(const PipelineData&) = default;
|
|
|
|
void SetTopology(Topology topo) { topology_ = topo; }
|
|
Topology GetTopology() const { return topology_; }
|
|
|
|
void SetPolygonMode(PolygonMode mode) { polygon_mode_ = mode; }
|
|
PolygonMode GetPolygonMode() const { return polygon_mode_; }
|
|
|
|
void SetCullMode(CullMode mode) { cull_mode_ = mode; }
|
|
CullMode GetCullMode() const { return cull_mode_; }
|
|
|
|
void SetFrontFace(FrontFace face) { front_face_ = face; }
|
|
FrontFace GetFrontFace() const { return front_face_; }
|
|
|
|
void SetDepthCompareOp(CompareOp op) { depth_compare_op_ = op; }
|
|
CompareOp GetDepthCompareOp() const { return depth_compare_op_; }
|
|
|
|
void SetColorWriteMask(uint8_t mask) { color_write_mask_ = mask; }
|
|
uint8_t GetColorWriteMask() const { return color_write_mask_; }
|
|
|
|
void SetFrontFailOp(StencilOp op) { front_fail_op_ = op; }
|
|
StencilOp GetFrontFailOp() const { return front_fail_op_; }
|
|
|
|
void SetFrontPassOp(StencilOp op) { front_pass_op_ = op; }
|
|
StencilOp GetFrontPassOp() const { return front_pass_op_; }
|
|
|
|
void SetFrontDepthFailOp(StencilOp op) { front_depth_fail_op_ = op; }
|
|
StencilOp GetFrontDepthFailOp() const { return front_depth_fail_op_; }
|
|
|
|
void SetFrontCompareOp(CompareOp op) { front_compare_op_ = op; }
|
|
CompareOp GetFrontCompareOp() const { return front_compare_op_; }
|
|
|
|
void SetFrontCompareMask(uint32_t mask) { front_compare_mask_ = mask; }
|
|
uint32_t GetFrontCompareMask() const { return front_compare_mask_; }
|
|
|
|
void SetFrontWriteMask(uint32_t mask) { front_write_mask_ = mask; }
|
|
uint32_t GetFrontWriteMask() const { return front_write_mask_; }
|
|
|
|
void SetFrontReference(uint32_t ref) { front_reference_ = ref; }
|
|
uint32_t GetFrontReference() const { return front_reference_; }
|
|
|
|
void SetBackFailOp(StencilOp op) { back_fail_op_ = op; }
|
|
StencilOp GetBackFailOp() const { return back_fail_op_; }
|
|
|
|
void SetBackPassOp(StencilOp op) { back_pass_op_ = op; }
|
|
StencilOp GetBackPassOp() const { return back_pass_op_; }
|
|
|
|
void SetBackDepthFailOp(StencilOp op) { back_depth_fail_op_ = op; }
|
|
StencilOp GetBackDepthFailOp() const { return back_depth_fail_op_; }
|
|
|
|
void SetBackCompareOp(CompareOp op) { back_compare_op_ = op; }
|
|
CompareOp GetBackCompareOp() const { return back_compare_op_; }
|
|
|
|
void SetBackCompareMask(uint32_t mask) { back_compare_mask_ = mask; }
|
|
uint32_t GetBackCompareMask() const { return back_compare_mask_; }
|
|
|
|
void SetBackWriteMask(uint32_t mask) { back_write_mask_ = mask; }
|
|
uint32_t GetBackWriteMask() const { return back_write_mask_; }
|
|
|
|
void SetBackReference(uint32_t ref) { back_reference_ = ref; }
|
|
uint32_t GetBackReference() const { return back_reference_; }
|
|
|
|
void SetLineWidth(float width) { line_width_ = width; }
|
|
float GetLineWidth() const { return line_width_; }
|
|
|
|
void SetEnableBlend(bool v) { enable_blend_ = v; }
|
|
bool GetEnableBlend() const { return enable_blend_; }
|
|
|
|
void SetEnableDepthTest(bool v) { enable_depth_test_ = v; }
|
|
bool GetEnableDepthTest() const { return enable_depth_test_; }
|
|
|
|
void SetEnableDepthWrite(bool v) { enable_depth_write_ = v; }
|
|
bool GetEnableDepthWrite() const { return enable_depth_write_; }
|
|
|
|
void SetEnableStencilTest(bool v) { enable_stencil_test_ = v; }
|
|
bool GetEnableStencilTest() const { return enable_stencil_test_; }
|
|
|
|
void SetEnablePrimitiveRestart(bool v) { enable_primitive_restart_ = v; }
|
|
bool GetEnablePrimitiveRestart() const { return enable_primitive_restart_; }
|
|
|
|
void SetEnableDepthClamp(bool v) { enable_depth_clamp_ = v; }
|
|
bool GetEnableDepthClamp() const { return enable_depth_clamp_; }
|
|
|
|
void SetEnableRasterizerDiscard(bool v) { enable_rasterizer_discard_ = v; }
|
|
bool GetEnableRasterizerDiscard() const { return enable_rasterizer_discard_; }
|
|
|
|
void SetEnableDepthBias(bool v) { enable_depth_bias_ = v; }
|
|
bool GetEnableDepthBias() const { return enable_depth_bias_; }
|
|
|
|
void SetEnableLogicOp(bool v) { enable_logic_op_ = v; }
|
|
bool GetEnableLogicOp() const { return enable_logic_op_; }
|
|
|
|
void SetEnableDepthBoundsTest(bool v) { enable_depth_bounds_test_ = v; }
|
|
bool GetEnableDepthBoundsTest() const { return enable_depth_bounds_test_; }
|
|
|
|
void SetDepthBiasConstantFactor(float f) { depth_bias_constant_factor_ = f; }
|
|
float GetDepthBiasConstantFactor() const {
|
|
return depth_bias_constant_factor_;
|
|
}
|
|
|
|
void SetDepthBiasClamp(float f) { depth_bias_clamp_ = f; }
|
|
float GetDepthBiasClamp() const { return depth_bias_clamp_; }
|
|
|
|
void SetDepthBiasSlopeFactor(float f) { depth_bias_slope_factor_ = f; }
|
|
float GetDepthBiasSlopeFactor() const { return depth_bias_slope_factor_; }
|
|
|
|
void SetMinDepthBounds(float f) { min_depth_bounds_ = f; }
|
|
float GetMinDepthBounds() const { return min_depth_bounds_; }
|
|
|
|
void SetMaxDepthBounds(float f) { max_depth_bounds_ = f; }
|
|
float GetMaxDepthBounds() const { return max_depth_bounds_; }
|
|
|
|
void SetLogicOp(LogicOp op) { logic_op_ = op; }
|
|
LogicOp GetLogicOp() const { return logic_op_; }
|
|
|
|
void SetSrcColorBlendFactor(BlendFactor f) { src_color_blend_factor_ = f; }
|
|
BlendFactor GetSrcColorBlendFactor() const { return src_color_blend_factor_; }
|
|
|
|
void SetDstColorBlendFactor(BlendFactor f) { dst_color_blend_factor_ = f; }
|
|
BlendFactor GetDstColorBlendFactor() const { return dst_color_blend_factor_; }
|
|
|
|
void SetSrcAlphaBlendFactor(BlendFactor f) { src_alpha_blend_factor_ = f; }
|
|
BlendFactor GetSrcAlphaBlendFactor() const { return src_alpha_blend_factor_; }
|
|
|
|
void SetDstAlphaBlendFactor(BlendFactor f) { dst_alpha_blend_factor_ = f; }
|
|
BlendFactor GetDstAlphaBlendFactor() const { return dst_alpha_blend_factor_; }
|
|
|
|
void SetColorBlendOp(BlendOp op) { color_blend_op_ = op; }
|
|
BlendOp GetColorBlendOp() const { return color_blend_op_; }
|
|
|
|
void SetAlphaBlendOp(BlendOp op) { alpha_blend_op_ = op; }
|
|
BlendOp GetAlphaBlendOp() const { return alpha_blend_op_; }
|
|
|
|
void SetViewport(const Viewport& v) {
|
|
has_viewport_data = true;
|
|
vp = v;
|
|
}
|
|
|
|
bool HasViewportData() const { return has_viewport_data; }
|
|
const Viewport& GetViewport() const { return vp; }
|
|
|
|
void SetPatchControlPoints(uint32_t control_points) {
|
|
patch_control_points_ = control_points;
|
|
}
|
|
uint32_t GetPatchControlPoints() const { return patch_control_points_; }
|
|
|
|
private:
|
|
StencilOp front_fail_op_ = StencilOp::kKeep;
|
|
StencilOp front_pass_op_ = StencilOp::kKeep;
|
|
StencilOp front_depth_fail_op_ = StencilOp::kKeep;
|
|
CompareOp front_compare_op_ = CompareOp::kAlways;
|
|
|
|
StencilOp back_fail_op_ = StencilOp::kKeep;
|
|
StencilOp back_pass_op_ = StencilOp::kKeep;
|
|
StencilOp back_depth_fail_op_ = StencilOp::kKeep;
|
|
CompareOp back_compare_op_ = CompareOp::kAlways;
|
|
|
|
Topology topology_ = Topology::kTriangleStrip;
|
|
PolygonMode polygon_mode_ = PolygonMode::kFill;
|
|
CullMode cull_mode_ = CullMode::kNone;
|
|
FrontFace front_face_ = FrontFace::kCounterClockwise;
|
|
CompareOp depth_compare_op_ = CompareOp::kAlways;
|
|
LogicOp logic_op_ = LogicOp::kClear;
|
|
BlendFactor src_color_blend_factor_ = BlendFactor::kOne;
|
|
BlendFactor dst_color_blend_factor_ = BlendFactor::kZero;
|
|
BlendFactor src_alpha_blend_factor_ = BlendFactor::kOne;
|
|
BlendFactor dst_alpha_blend_factor_ = BlendFactor::kZero;
|
|
BlendOp color_blend_op_ = BlendOp::kAdd;
|
|
BlendOp alpha_blend_op_ = BlendOp::kAdd;
|
|
|
|
uint32_t front_compare_mask_ = std::numeric_limits<uint32_t>::max();
|
|
uint32_t front_write_mask_ = std::numeric_limits<uint32_t>::max();
|
|
uint32_t front_reference_ = 0;
|
|
|
|
uint32_t back_compare_mask_ = std::numeric_limits<uint32_t>::max();
|
|
uint32_t back_write_mask_ = std::numeric_limits<uint32_t>::max();
|
|
uint32_t back_reference_ = 0;
|
|
|
|
uint8_t color_write_mask_ =
|
|
kColorMaskR | kColorMaskG | kColorMaskB | kColorMaskA;
|
|
|
|
bool enable_blend_ = false;
|
|
bool enable_depth_test_ = false;
|
|
bool enable_depth_write_ = false;
|
|
bool enable_depth_clamp_ = false;
|
|
bool enable_depth_bias_ = false;
|
|
bool enable_depth_bounds_test_ = false;
|
|
bool enable_stencil_test_ = false;
|
|
bool enable_primitive_restart_ = false;
|
|
bool enable_rasterizer_discard_ = false;
|
|
bool enable_logic_op_ = false;
|
|
|
|
float line_width_ = 1.0f;
|
|
float depth_bias_constant_factor_ = 0.0f;
|
|
float depth_bias_clamp_ = 0.0f;
|
|
float depth_bias_slope_factor_ = 0.0f;
|
|
float min_depth_bounds_ = 0.0f;
|
|
float max_depth_bounds_ = 0.0f;
|
|
|
|
bool has_viewport_data = false;
|
|
Viewport vp;
|
|
|
|
uint32_t patch_control_points_ = 3u;
|
|
};
|
|
|
|
} // namespace amber
|
|
|
|
#endif // SRC_PIPELINE_DATA_H_
|