• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2018 The Amber Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //     http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #ifndef SRC_COMMAND_H_
16 #define SRC_COMMAND_H_
17 
18 #include <cstdint>
19 #include <memory>
20 #include <string>
21 #include <utility>
22 #include <vector>
23 
24 #include "amber/shader_info.h"
25 #include "amber/value.h"
26 #include "src/buffer.h"
27 #include "src/command_data.h"
28 #include "src/debug.h"
29 #include "src/pipeline_data.h"
30 #include "src/sampler.h"
31 
32 namespace amber {
33 
34 class BufferCommand;
35 class ClearColorCommand;
36 class ClearCommand;
37 class ClearDepthCommand;
38 class ClearStencilCommand;
39 class CompareBufferCommand;
40 class ComputeCommand;
41 class CopyCommand;
42 class DrawArraysCommand;
43 class DrawRectCommand;
44 class DrawGridCommand;
45 class EntryPointCommand;
46 class PatchParameterVerticesCommand;
47 class Pipeline;
48 class ProbeCommand;
49 class ProbeSSBOCommand;
50 class RepeatCommand;
51 
52 /// Base class for all commands.
53 class Command {
54  public:
55   enum class Type : uint8_t {
56     kClear = 0,
57     kClearColor,
58     kClearDepth,
59     kClearStencil,
60     kCompute,
61     kCompareBuffer,
62     kCopy,
63     kDrawArrays,
64     kDrawRect,
65     kDrawGrid,
66     kEntryPoint,
67     kPatchParameterVertices,
68     kPipelineProperties,
69     kProbe,
70     kProbeSSBO,
71     kBuffer,
72     kRepeat,
73     kSampler
74   };
75 
76   virtual ~Command();
77 
GetType()78   Command::Type GetType() const { return command_type_; }
79 
IsDrawRect()80   bool IsDrawRect() const { return command_type_ == Type::kDrawRect; }
IsDrawGrid()81   bool IsDrawGrid() const { return command_type_ == Type::kDrawGrid; }
IsDrawArrays()82   bool IsDrawArrays() const { return command_type_ == Type::kDrawArrays; }
IsCompareBuffer()83   bool IsCompareBuffer() const { return command_type_ == Type::kCompareBuffer; }
IsCompute()84   bool IsCompute() const { return command_type_ == Type::kCompute; }
IsCopy()85   bool IsCopy() const { return command_type_ == Type::kCopy; }
IsProbe()86   bool IsProbe() const { return command_type_ == Type::kProbe; }
IsProbeSSBO()87   bool IsProbeSSBO() const { return command_type_ == Type::kProbeSSBO; }
IsBuffer()88   bool IsBuffer() const { return command_type_ == Type::kBuffer; }
IsClear()89   bool IsClear() const { return command_type_ == Type::kClear; }
IsClearColor()90   bool IsClearColor() const { return command_type_ == Type::kClearColor; }
IsClearDepth()91   bool IsClearDepth() const { return command_type_ == Type::kClearDepth; }
IsClearStencil()92   bool IsClearStencil() const { return command_type_ == Type::kClearStencil; }
IsPatchParameterVertices()93   bool IsPatchParameterVertices() const {
94     return command_type_ == Type::kPatchParameterVertices;
95   }
IsEntryPoint()96   bool IsEntryPoint() const { return command_type_ == Type::kEntryPoint; }
IsRepeat()97   bool IsRepeat() { return command_type_ == Type::kRepeat; }
98 
99   ClearCommand* AsClear();
100   ClearColorCommand* AsClearColor();
101   ClearDepthCommand* AsClearDepth();
102   ClearStencilCommand* AsClearStencil();
103   CompareBufferCommand* AsCompareBuffer();
104   ComputeCommand* AsCompute();
105   CopyCommand* AsCopy();
106   DrawArraysCommand* AsDrawArrays();
107   DrawRectCommand* AsDrawRect();
108   DrawGridCommand* AsDrawGrid();
109   EntryPointCommand* AsEntryPoint();
110   PatchParameterVerticesCommand* AsPatchParameterVertices();
111   ProbeCommand* AsProbe();
112   ProbeSSBOCommand* AsProbeSSBO();
113   BufferCommand* AsBuffer();
114   RepeatCommand* AsRepeat();
115 
116   virtual std::string ToString() const = 0;
117 
118   /// Sets the input file line number this command is declared on.
SetLine(size_t line)119   void SetLine(size_t line) { line_ = line; }
120   /// Returns the input file line this command was declared on.
GetLine()121   size_t GetLine() const { return line_; }
122 
123   /// Sets the debug script to run for this command.
SetDebugScript(std::unique_ptr<debug::Script> && debug)124   void SetDebugScript(std::unique_ptr<debug::Script>&& debug) {
125     debug_ = std::move(debug);
126   }
127 
128   /// Returns the optional debug script associated with this command.
GetDebugScript()129   debug::Script* GetDebugScript() { return debug_.get(); }
130 
131  protected:
132   explicit Command(Type type);
133 
134   Type command_type_;
135   size_t line_ = 1;
136   std::unique_ptr<debug::Script> debug_;
137 };
138 
139 /// Base class for commands which contain a pipeline.
140 class PipelineCommand : public Command {
141  public:
142   ~PipelineCommand() override;
143 
GetPipeline()144   Pipeline* GetPipeline() const { return pipeline_; }
145 
146  protected:
147   PipelineCommand(Type type, Pipeline* pipeline);
148 
149   Pipeline* pipeline_ = nullptr;
150 };
151 
152 /// Command to draw a rectangle on screen.
153 class DrawRectCommand : public PipelineCommand {
154  public:
155   DrawRectCommand(Pipeline* pipeline, PipelineData data);
156   ~DrawRectCommand() override;
157 
GetPipelineData()158   const PipelineData* GetPipelineData() const { return &data_; }
159 
EnableOrtho()160   void EnableOrtho() { is_ortho_ = true; }
IsOrtho()161   bool IsOrtho() const { return is_ortho_; }
162 
EnablePatch()163   void EnablePatch() { is_patch_ = true; }
IsPatch()164   bool IsPatch() const { return is_patch_; }
165 
SetX(float x)166   void SetX(float x) { x_ = x; }
GetX()167   float GetX() const { return x_; }
168 
SetY(float y)169   void SetY(float y) { y_ = y; }
GetY()170   float GetY() const { return y_; }
171 
SetWidth(float w)172   void SetWidth(float w) { width_ = w; }
GetWidth()173   float GetWidth() const { return width_; }
174 
SetHeight(float h)175   void SetHeight(float h) { height_ = h; }
GetHeight()176   float GetHeight() const { return height_; }
177 
ToString()178   std::string ToString() const override { return "DrawRectCommand"; }
179 
180  private:
181   PipelineData data_;
182   bool is_ortho_ = false;
183   bool is_patch_ = false;
184   float x_ = 0.0;
185   float y_ = 0.0;
186   float width_ = 0.0;
187   float height_ = 0.0;
188 };
189 
190 /// Command to draw a grid of recrangles on screen.
191 class DrawGridCommand : public PipelineCommand {
192  public:
193   DrawGridCommand(Pipeline* pipeline, PipelineData data);
194   ~DrawGridCommand() override;
195 
GetPipelineData()196   const PipelineData* GetPipelineData() const { return &data_; }
197 
SetX(float x)198   void SetX(float x) { x_ = x; }
GetX()199   float GetX() const { return x_; }
200 
SetY(float y)201   void SetY(float y) { y_ = y; }
GetY()202   float GetY() const { return y_; }
203 
SetWidth(float w)204   void SetWidth(float w) { width_ = w; }
GetWidth()205   float GetWidth() const { return width_; }
206 
SetHeight(float h)207   void SetHeight(float h) { height_ = h; }
GetHeight()208   float GetHeight() const { return height_; }
209 
SetColumns(uint32_t c)210   void SetColumns(uint32_t c) { columns_ = c; }
GetColumns()211   uint32_t GetColumns() const { return columns_; }
212 
SetRows(uint32_t r)213   void SetRows(uint32_t r) { rows_ = r; }
GetRows()214   uint32_t GetRows() const { return rows_; }
215 
ToString()216   std::string ToString() const override { return "DrawGridCommand"; }
217 
218  private:
219   PipelineData data_;
220   float x_ = 0.0;
221   float y_ = 0.0;
222   float width_ = 0.0;
223   float height_ = 0.0;
224   uint32_t columns_ = 0;
225   uint32_t rows_ = 0;
226 };
227 
228 /// Command to draw from a vertex and index buffer.
229 class DrawArraysCommand : public PipelineCommand {
230  public:
231   DrawArraysCommand(Pipeline* pipeline, PipelineData data);
232   ~DrawArraysCommand() override;
233 
GetPipelineData()234   const PipelineData* GetPipelineData() const { return &data_; }
235 
EnableIndexed()236   void EnableIndexed() { is_indexed_ = true; }
IsIndexed()237   bool IsIndexed() const { return is_indexed_; }
238 
SetTopology(Topology topo)239   void SetTopology(Topology topo) { topology_ = topo; }
GetTopology()240   Topology GetTopology() const { return topology_; }
241 
SetFirstVertexIndex(uint32_t idx)242   void SetFirstVertexIndex(uint32_t idx) { first_vertex_index_ = idx; }
GetFirstVertexIndex()243   uint32_t GetFirstVertexIndex() const { return first_vertex_index_; }
244 
SetVertexCount(uint32_t count)245   void SetVertexCount(uint32_t count) { vertex_count_ = count; }
GetVertexCount()246   uint32_t GetVertexCount() const { return vertex_count_; }
247 
SetFirstInstance(uint32_t idx)248   void SetFirstInstance(uint32_t idx) { first_instance_ = idx; }
GetFirstInstance()249   uint32_t GetFirstInstance() const { return first_instance_; }
250 
SetInstanceCount(uint32_t count)251   void SetInstanceCount(uint32_t count) { instance_count_ = count; }
GetInstanceCount()252   uint32_t GetInstanceCount() const { return instance_count_; }
253 
ToString()254   std::string ToString() const override { return "DrawArraysCommand"; }
255 
256  private:
257   PipelineData data_;
258   bool is_indexed_ = false;
259   Topology topology_ = Topology::kUnknown;
260   uint32_t first_vertex_index_ = 0;
261   uint32_t vertex_count_ = 0;
262   uint32_t first_instance_ = 0;
263   uint32_t instance_count_ = 1;
264 };
265 
266 /// A command to compare two buffers.
267 class CompareBufferCommand : public Command {
268  public:
269   enum class Comparator { kEq, kRmse, kHistogramEmd };
270 
271   CompareBufferCommand(Buffer* buffer_1, Buffer* buffer_2);
272   ~CompareBufferCommand() override;
273 
GetBuffer1()274   Buffer* GetBuffer1() const { return buffer_1_; }
GetBuffer2()275   Buffer* GetBuffer2() const { return buffer_2_; }
276 
SetComparator(Comparator type)277   void SetComparator(Comparator type) { comparator_ = type; }
GetComparator()278   Comparator GetComparator() const { return comparator_; }
279 
SetTolerance(float tolerance)280   void SetTolerance(float tolerance) { tolerance_ = tolerance; }
GetTolerance()281   float GetTolerance() const { return tolerance_; }
282 
ToString()283   std::string ToString() const override { return "CompareBufferCommand"; }
284 
285  private:
286   Buffer* buffer_1_;
287   Buffer* buffer_2_;
288   float tolerance_ = 0.0;
289   Comparator comparator_ = Comparator::kEq;
290 };
291 
292 /// Command to execute a compute command.
293 class ComputeCommand : public PipelineCommand {
294  public:
295   explicit ComputeCommand(Pipeline* pipeline);
296   ~ComputeCommand() override;
297 
SetX(uint32_t x)298   void SetX(uint32_t x) { x_ = x; }
GetX()299   uint32_t GetX() const { return x_; }
300 
SetY(uint32_t y)301   void SetY(uint32_t y) { y_ = y; }
GetY()302   uint32_t GetY() const { return y_; }
303 
SetZ(uint32_t z)304   void SetZ(uint32_t z) { z_ = z; }
GetZ()305   uint32_t GetZ() const { return z_; }
306 
ToString()307   std::string ToString() const override { return "ComputeCommand"; }
308 
309  private:
310   uint32_t x_ = 0;
311   uint32_t y_ = 0;
312   uint32_t z_ = 0;
313 };
314 
315 /// Command to copy data from one buffer to another.
316 class CopyCommand : public Command {
317  public:
318   CopyCommand(Buffer* buffer_from, Buffer* buffer_to);
319   ~CopyCommand() override;
320 
GetBufferFrom()321   Buffer* GetBufferFrom() const { return buffer_from_; }
GetBufferTo()322   Buffer* GetBufferTo() const { return buffer_to_; }
323 
ToString()324   std::string ToString() const override { return "CopyCommand"; }
325 
326  private:
327   Buffer* buffer_from_;
328   Buffer* buffer_to_;
329 };
330 
331 /// Base class for probe commands.
332 class Probe : public Command {
333  public:
334   /// Wrapper around tolerance information for the probe.
335   struct Tolerance {
ToleranceTolerance336     Tolerance(bool percent, double val) : is_percent(percent), value(val) {}
337 
338     bool is_percent = false;
339     double value = 0.0;
340   };
341 
342   ~Probe() override;
343 
GetBuffer()344   Buffer* GetBuffer() const { return buffer_; }
345 
HasTolerances()346   bool HasTolerances() const { return !tolerances_.empty(); }
SetTolerances(const std::vector<Tolerance> & t)347   void SetTolerances(const std::vector<Tolerance>& t) { tolerances_ = t; }
GetTolerances()348   const std::vector<Tolerance>& GetTolerances() const { return tolerances_; }
349 
350  protected:
351   Probe(Type type, Buffer* buffer);
352 
353  private:
354   Buffer* buffer_;
355   std::vector<Tolerance> tolerances_;
356 };
357 
358 /// Command to probe an image buffer.
359 class ProbeCommand : public Probe {
360  public:
361   explicit ProbeCommand(Buffer* buffer);
362   ~ProbeCommand() override;
363 
SetWholeWindow()364   void SetWholeWindow() { is_whole_window_ = true; }
IsWholeWindow()365   bool IsWholeWindow() const { return is_whole_window_; }
366 
SetProbeRect()367   void SetProbeRect() { is_probe_rect_ = true; }
IsProbeRect()368   bool IsProbeRect() const { return is_probe_rect_; }
369 
SetRelative()370   void SetRelative() { is_relative_ = true; }
IsRelative()371   bool IsRelative() const { return is_relative_; }
372 
SetIsRGBA()373   void SetIsRGBA() { color_format_ = ColorFormat::kRGBA; }
IsRGBA()374   bool IsRGBA() const { return color_format_ == ColorFormat::kRGBA; }
375 
SetX(float x)376   void SetX(float x) { x_ = x; }
GetX()377   float GetX() const { return x_; }
378 
SetY(float y)379   void SetY(float y) { y_ = y; }
GetY()380   float GetY() const { return y_; }
381 
SetWidth(float w)382   void SetWidth(float w) { width_ = w; }
GetWidth()383   float GetWidth() const { return width_; }
384 
SetHeight(float h)385   void SetHeight(float h) { height_ = h; }
GetHeight()386   float GetHeight() const { return height_; }
387 
388   // Colours are stored in the range 0.0 - 1.0
SetR(float r)389   void SetR(float r) { r_ = r; }
GetR()390   float GetR() const { return r_; }
391 
SetG(float g)392   void SetG(float g) { g_ = g; }
GetG()393   float GetG() const { return g_; }
394 
SetB(float b)395   void SetB(float b) { b_ = b; }
GetB()396   float GetB() const { return b_; }
397 
SetA(float a)398   void SetA(float a) { a_ = a; }
GetA()399   float GetA() const { return a_; }
400 
ToString()401   std::string ToString() const override { return "ProbeCommand"; }
402 
403  private:
404   enum class ColorFormat {
405     kRGB = 0,
406     kRGBA,
407   };
408 
409   bool is_whole_window_ = false;
410   bool is_probe_rect_ = false;
411   bool is_relative_ = false;
412   ColorFormat color_format_ = ColorFormat::kRGB;
413 
414   float x_ = 0.0;
415   float y_ = 0.0;
416   float width_ = 1.0;
417   float height_ = 1.0;
418 
419   float r_ = 0.0;
420   float g_ = 0.0;
421   float b_ = 0.0;
422   float a_ = 0.0;
423 };
424 
425 /// Command to probe a data buffer.
426 class ProbeSSBOCommand : public Probe {
427  public:
428   enum class Comparator {
429     kEqual,
430     kNotEqual,
431     kFuzzyEqual,
432     kLess,
433     kLessOrEqual,
434     kGreater,
435     kGreaterOrEqual
436   };
437 
438   explicit ProbeSSBOCommand(Buffer* buffer);
439   ~ProbeSSBOCommand() override;
440 
SetComparator(Comparator comp)441   void SetComparator(Comparator comp) { comparator_ = comp; }
GetComparator()442   Comparator GetComparator() const { return comparator_; }
443 
SetDescriptorSet(uint32_t id)444   void SetDescriptorSet(uint32_t id) { descriptor_set_id_ = id; }
GetDescriptorSet()445   uint32_t GetDescriptorSet() const { return descriptor_set_id_; }
446 
SetBinding(uint32_t id)447   void SetBinding(uint32_t id) { binding_num_ = id; }
GetBinding()448   uint32_t GetBinding() const { return binding_num_; }
449 
SetOffset(uint32_t offset)450   void SetOffset(uint32_t offset) { offset_ = offset; }
GetOffset()451   uint32_t GetOffset() const { return offset_; }
452 
SetFormat(Format * fmt)453   void SetFormat(Format* fmt) { format_ = fmt; }
GetFormat()454   Format* GetFormat() const { return format_; }
455 
SetValues(std::vector<Value> && values)456   void SetValues(std::vector<Value>&& values) { values_ = std::move(values); }
GetValues()457   const std::vector<Value>& GetValues() const { return values_; }
458 
ToString()459   std::string ToString() const override { return "ProbeSSBOCommand"; }
460 
461  private:
462   Comparator comparator_ = Comparator::kEqual;
463   uint32_t descriptor_set_id_ = 0;
464   uint32_t binding_num_ = 0;
465   uint32_t offset_ = 0;
466   Format* format_;
467   std::vector<Value> values_;
468 };
469 
470 /// Base class for BufferCommand and SamplerCommand to handle binding.
471 class BindableResourceCommand : public PipelineCommand {
472  public:
473   BindableResourceCommand(Type type, Pipeline* pipeline);
474   ~BindableResourceCommand() override;
475 
SetDescriptorSet(uint32_t set)476   void SetDescriptorSet(uint32_t set) { descriptor_set_ = set; }
GetDescriptorSet()477   uint32_t GetDescriptorSet() const { return descriptor_set_; }
478 
SetBinding(uint32_t num)479   void SetBinding(uint32_t num) { binding_num_ = num; }
GetBinding()480   uint32_t GetBinding() const { return binding_num_; }
481 
482  private:
483   uint32_t descriptor_set_ = 0;
484   uint32_t binding_num_ = 0;
485 };
486 
487 /// Command to set the size of a buffer, or update a buffers contents.
488 class BufferCommand : public BindableResourceCommand {
489  public:
490   enum class BufferType {
491     kSSBO,
492     kSSBODynamic,
493     kUniform,
494     kUniformDynamic,
495     kPushConstant,
496     kStorageImage,
497     kSampledImage,
498     kCombinedImageSampler,
499     kUniformTexelBuffer,
500     kStorageTexelBuffer
501   };
502 
503   BufferCommand(BufferType type, Pipeline* pipeline);
504   ~BufferCommand() override;
505 
IsSSBO()506   bool IsSSBO() const { return buffer_type_ == BufferType::kSSBO; }
IsSSBODynamic()507   bool IsSSBODynamic() const {
508     return buffer_type_ == BufferType::kSSBODynamic;
509   }
IsUniform()510   bool IsUniform() const { return buffer_type_ == BufferType::kUniform; }
IsUniformDynamic()511   bool IsUniformDynamic() const {
512     return buffer_type_ == BufferType::kUniformDynamic;
513   }
IsStorageImage()514   bool IsStorageImage() const {
515     return buffer_type_ == BufferType::kStorageImage;
516   }
IsSampledImage()517   bool IsSampledImage() const {
518     return buffer_type_ == BufferType::kSampledImage;
519   }
IsCombinedImageSampler()520   bool IsCombinedImageSampler() const {
521     return buffer_type_ == BufferType::kCombinedImageSampler;
522   }
IsUniformTexelBuffer()523   bool IsUniformTexelBuffer() const {
524     return buffer_type_ == BufferType::kUniformTexelBuffer;
525   }
IsStorageTexelBuffer()526   bool IsStorageTexelBuffer() const {
527     return buffer_type_ == BufferType::kStorageTexelBuffer;
528   }
IsPushConstant()529   bool IsPushConstant() const {
530     return buffer_type_ == BufferType::kPushConstant;
531   }
532 
SetIsSubdata()533   void SetIsSubdata() { is_subdata_ = true; }
IsSubdata()534   bool IsSubdata() const { return is_subdata_; }
535 
SetOffset(uint32_t offset)536   void SetOffset(uint32_t offset) { offset_ = offset; }
GetOffset()537   uint32_t GetOffset() const { return offset_; }
538 
SetBaseMipLevel(uint32_t base_mip_level)539   void SetBaseMipLevel(uint32_t base_mip_level) {
540     base_mip_level_ = base_mip_level;
541   }
GetBaseMipLevel()542   uint32_t GetBaseMipLevel() const { return base_mip_level_; }
543 
SetDynamicOffset(uint32_t dynamic_offset)544   void SetDynamicOffset(uint32_t dynamic_offset) {
545     dynamic_offset_ = dynamic_offset;
546   }
GetDynamicOffset()547   uint32_t GetDynamicOffset() const { return dynamic_offset_; }
548 
SetValues(std::vector<Value> && values)549   void SetValues(std::vector<Value>&& values) { values_ = std::move(values); }
GetValues()550   const std::vector<Value>& GetValues() const { return values_; }
551 
SetBuffer(Buffer * buffer)552   void SetBuffer(Buffer* buffer) { buffer_ = buffer; }
GetBuffer()553   Buffer* GetBuffer() const { return buffer_; }
554 
SetSampler(Sampler * sampler)555   void SetSampler(Sampler* sampler) { sampler_ = sampler; }
GetSampler()556   Sampler* GetSampler() const { return sampler_; }
557 
ToString()558   std::string ToString() const override { return "BufferCommand"; }
559 
560  private:
561   Buffer* buffer_ = nullptr;
562   Sampler* sampler_ = nullptr;
563   BufferType buffer_type_;
564   bool is_subdata_ = false;
565   uint32_t offset_ = 0;
566   uint32_t base_mip_level_ = 0;
567   uint32_t dynamic_offset_ = 0;
568   std::vector<Value> values_;
569 };
570 
571 /// Command for setting sampler parameters and binding.
572 class SamplerCommand : public BindableResourceCommand {
573  public:
574   explicit SamplerCommand(Pipeline* pipeline);
575   ~SamplerCommand() override;
576 
SetSampler(Sampler * sampler)577   void SetSampler(Sampler* sampler) { sampler_ = sampler; }
GetSampler()578   Sampler* GetSampler() const { return sampler_; }
579 
ToString()580   std::string ToString() const override { return "SamplerCommand"; }
581 
582  private:
583   Sampler* sampler_ = nullptr;
584 };
585 
586 /// Command to clear the colour attachments.
587 class ClearCommand : public PipelineCommand {
588  public:
589   explicit ClearCommand(Pipeline* pipeline);
590   ~ClearCommand() override;
591 
ToString()592   std::string ToString() const override { return "ClearCommand"; }
593 };
594 
595 /// Command to set the colour for the clear command.
596 class ClearColorCommand : public PipelineCommand {
597  public:
598   explicit ClearColorCommand(Pipeline* pipeline);
599   ~ClearColorCommand() override;
600 
601   // Colours are stored in the range 0.0 - 1.0
SetR(float r)602   void SetR(float r) { r_ = r; }
GetR()603   float GetR() const { return r_; }
604 
SetG(float g)605   void SetG(float g) { g_ = g; }
GetG()606   float GetG() const { return g_; }
607 
SetB(float b)608   void SetB(float b) { b_ = b; }
GetB()609   float GetB() const { return b_; }
610 
SetA(float a)611   void SetA(float a) { a_ = a; }
GetA()612   float GetA() const { return a_; }
613 
ToString()614   std::string ToString() const override { return "ClearColorCommand"; }
615 
616  private:
617   float r_ = 0.0;
618   float g_ = 0.0;
619   float b_ = 0.0;
620   float a_ = 0.0;
621 };
622 
623 /// Command to set the depth value for the clear command.
624 class ClearDepthCommand : public PipelineCommand {
625  public:
626   explicit ClearDepthCommand(Pipeline* pipeline);
627   ~ClearDepthCommand() override;
628 
SetValue(float val)629   void SetValue(float val) { value_ = val; }
GetValue()630   float GetValue() const { return value_; }
631 
ToString()632   std::string ToString() const override { return "ClearDepthCommand"; }
633 
634  private:
635   float value_ = 0.0;
636 };
637 
638 /// Command to set the stencil value for the clear command.
639 class ClearStencilCommand : public PipelineCommand {
640  public:
641   explicit ClearStencilCommand(Pipeline* pipeline);
642   ~ClearStencilCommand() override;
643 
SetValue(uint32_t val)644   void SetValue(uint32_t val) { value_ = val; }
GetValue()645   uint32_t GetValue() const { return value_; }
646 
ToString()647   std::string ToString() const override { return "ClearStencilCommand"; }
648 
649  private:
650   uint32_t value_ = 0;
651 };
652 
653 /// Command to set the patch parameter vertices.
654 class PatchParameterVerticesCommand : public PipelineCommand {
655  public:
656   explicit PatchParameterVerticesCommand(Pipeline* pipeline);
657   ~PatchParameterVerticesCommand() override;
658 
SetControlPointCount(uint32_t count)659   void SetControlPointCount(uint32_t count) { control_point_count_ = count; }
GetControlPointCount()660   uint32_t GetControlPointCount() const { return control_point_count_; }
661 
ToString()662   std::string ToString() const override {
663     return "PatchParameterVerticesCommand";
664   }
665 
666  private:
667   uint32_t control_point_count_ = 0;
668 };
669 
670 /// Command to set the entry point to use for a given shader type.
671 class EntryPointCommand : public PipelineCommand {
672  public:
673   explicit EntryPointCommand(Pipeline* pipeline);
674   ~EntryPointCommand() override;
675 
SetShaderType(ShaderType type)676   void SetShaderType(ShaderType type) { shader_type_ = type; }
GetShaderType()677   ShaderType GetShaderType() const { return shader_type_; }
678 
SetEntryPointName(const std::string & name)679   void SetEntryPointName(const std::string& name) { entry_point_name_ = name; }
GetEntryPointName()680   std::string GetEntryPointName() const { return entry_point_name_; }
681 
ToString()682   std::string ToString() const override { return "EntryPointCommand"; }
683 
684  private:
685   ShaderType shader_type_ = kShaderTypeVertex;
686   std::string entry_point_name_;
687 };
688 
689 /// Command to repeat the given set of commands a number of times.
690 class RepeatCommand : public Command {
691  public:
692   explicit RepeatCommand(uint32_t count);
693   ~RepeatCommand() override;
694 
GetCount()695   uint32_t GetCount() const { return count_; }
696 
SetCommands(std::vector<std::unique_ptr<Command>> cmds)697   void SetCommands(std::vector<std::unique_ptr<Command>> cmds) {
698     commands_ = std::move(cmds);
699   }
700 
GetCommands()701   const std::vector<std::unique_ptr<Command>>& GetCommands() const {
702     return commands_;
703   }
704 
ToString()705   std::string ToString() const override { return "RepeatCommand"; }
706 
707  private:
708   uint32_t count_ = 0;
709   std::vector<std::unique_ptr<Command>> commands_;
710 };
711 
712 }  // namespace amber
713 
714 #endif  // SRC_COMMAND_H_
715