Overte C++ Documentation
Procedural.h
1 //
2 // Created by Bradley Austin Davis on 2015/09/05
3 // Copyright 2013-2015 High Fidelity, Inc.
4 //
5 // Distributed under the Apache License, Version 2.0.
6 // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
7 //
8 
9 #pragma once
10 
11 #include <atomic>
12 
13 #include <QtCore/qglobal.h>
14 #include <QtCore/QString>
15 #include <QtCore/QUrl>
16 #include <QtCore/QJsonObject>
17 #include <QtCore/QJsonArray>
18 
19 #include <render/Args.h>
20 #include <gpu/Shader.h>
21 #include <gpu/Pipeline.h>
22 #include <gpu/Batch.h>
23 #include <material-networking/ShaderCache.h>
24 #include <material-networking/TextureCache.h>
25 #include "ProceduralMaterialCache.h"
26 
27 using UniformLambdas = std::list<std::function<void(gpu::Batch& batch)>>;
28 const size_t MAX_PROCEDURAL_TEXTURE_CHANNELS{ 4 };
29 
30 /*@jsdoc
31  * An object containing user-defined uniforms for communicating data to shaders.
32  * @typedef {object} ProceduralUniforms
33  */
34 
35 /*@jsdoc
36  * The data used to define a Procedural shader material.
37  * @typedef {object} ProceduralData
38  * @property {number} version=1 - The version of the procedural shader.
39  * @property {string} vertexShaderURL - A link to a vertex shader. Currently, only GLSL shaders are supported. The shader must implement a different method depending on the version.
40  * If a procedural material contains a vertex shader, the bounding box of the material entity is used to cull the object to which the material is applied.
41  * @property {string} fragmentShaderURL - A link to a fragment shader. Currently, only GLSL shaders are supported. The shader must implement a different method depending on the version.
42  * <code>shaderUrl</code> is an alias.
43  * @property {string[]|Entities.Texture[]} channels=[]] - An array of input textures or entity IDs. Currently, up to 4 are supported. An entity ID may be that of an Image or Web entity.
44  * @property {ProceduralUniforms} uniforms={} - A {@link ProceduralUniforms} object containing all the custom uniforms to be passed to the shader.
45  */
46 
47 struct ProceduralData {
48  static QJsonValue getProceduralData(const QString& proceduralJson);
49  static ProceduralData parse(const QString& userDataJson);
50  void parse(const QJsonObject&);
51 
52  // Rendering object descriptions, from userData
53  uint8_t version { 0 };
54  QUrl fragmentShaderUrl;
55  QUrl vertexShaderUrl;
56  QJsonObject uniforms;
57  QJsonArray channels;
58 };
59 
60 class ProceduralProgramKey {
61 public:
62  enum FlagBit {
63  IS_TRANSPARENT = 0,
64  IS_SKINNED,
65  IS_SKINNED_DQ,
66 
67  NUM_FLAGS
68  };
69  typedef std::bitset<NUM_FLAGS> Flags;
70 
71  Flags _flags;
72 
73  bool isTransparent() const { return _flags[IS_TRANSPARENT]; }
74  bool isSkinned() const { return _flags[IS_SKINNED]; }
75  bool isSkinnedDQ() const { return _flags[IS_SKINNED_DQ]; }
76 
77  ProceduralProgramKey(bool transparent = false, bool isSkinned = false, bool isSkinnedDQ = false) {
78  _flags.set(IS_TRANSPARENT, transparent);
79  _flags.set(IS_SKINNED, isSkinned);
80  _flags.set(IS_SKINNED_DQ, isSkinnedDQ);
81  }
82 };
83 template <>
84 struct std::hash<ProceduralProgramKey> {
85  size_t operator()(const ProceduralProgramKey& key) const {
86  return std::hash<std::bitset<ProceduralProgramKey::FlagBit::NUM_FLAGS>>()(key._flags);
87  }
88 };
89 inline bool operator==(const ProceduralProgramKey& a, const ProceduralProgramKey& b) {
90  return a._flags == b._flags;
91 }
92 inline bool operator!=(const ProceduralProgramKey& a, const ProceduralProgramKey& b) {
93  return a._flags != b._flags;
94 }
95 
96 // FIXME better encapsulation
97 // FIXME better mechanism for extending to things rendered using shaders other than simple.slv
98 struct Procedural {
99 public:
100  Procedural(bool useAA = true);
101  void setProceduralData(const ProceduralData& proceduralData);
102 
103  bool isReady() const;
104  bool isEnabled() const { return _enabled; }
105  void prepare(gpu::Batch& batch, const glm::vec3& position, const glm::vec3& size, const glm::quat& orientation,
106  const uint64_t& created, const ProceduralProgramKey key = ProceduralProgramKey());
107 
108  glm::vec4 getColor(const glm::vec4& entityColor) const;
109 
110  bool hasVertexShader() const;
111  void setBoundOperator(const std::function<AABox(RenderArgs*)>& boundOperator) { _boundOperator = boundOperator; }
112  bool hasBoundOperator() const { return (bool)_boundOperator; }
113  AABox getBound(RenderArgs* args) { return _boundOperator(args); }
114 
115  void setVertexReplacements(const std::unordered_map<std::string, std::string>& replacements);
116  void setFragmentReplacements(const std::unordered_map<std::string, std::string>& replacements);
117 
118  gpu::Shader::Source _vertexSource;
119  gpu::Shader::Source _vertexSourceSkinned;
120  gpu::Shader::Source _vertexSourceSkinnedDQ;
121  gpu::Shader::Source _opaqueFragmentSource;
122  gpu::Shader::Source _transparentFragmentSource;
123 
124  QString _errorFallbackFragmentPath;
125 
126  gpu::StatePointer _opaqueState { std::make_shared<gpu::State>() };
127  gpu::StatePointer _transparentState { std::make_shared<gpu::State>() };
128 
129  static std::function<void(gpu::StatePointer, bool)> opaqueStencil;
130  static std::function<void(gpu::StatePointer)> transparentStencil;
131 
132  static bool enableProceduralShaders;
133 
134 protected:
135  // DO NOT TOUCH
136  // We have to pack these in a particular way to match the ProceduralCommon.slh
137  // layout.
138  struct StandardInputs {
139  vec4 date;
140  vec4 position;
141  vec4 scale;
142  float timeSinceLastCompile;
143  float timeSinceFirstCompile;
144  float timeSinceEntityCreation;
145  int frameCount;
146  vec4 resolution[4];
147  mat4 orientation;
148  };
149 
150  static_assert(0 == offsetof(StandardInputs, date), "ProceduralOffsets");
151  static_assert(16 == offsetof(StandardInputs, position), "ProceduralOffsets");
152  static_assert(32 == offsetof(StandardInputs, scale), "ProceduralOffsets");
153  static_assert(48 == offsetof(StandardInputs, timeSinceLastCompile), "ProceduralOffsets");
154  static_assert(52 == offsetof(StandardInputs, timeSinceFirstCompile), "ProceduralOffsets");
155  static_assert(56 == offsetof(StandardInputs, timeSinceEntityCreation), "ProceduralOffsets");
156  static_assert(60 == offsetof(StandardInputs, frameCount), "ProceduralOffsets");
157  static_assert(64 == offsetof(StandardInputs, resolution), "ProceduralOffsets");
158  static_assert(128 == offsetof(StandardInputs, orientation), "ProceduralOffsets");
159 
160  // Procedural metadata
161  ProceduralData _data;
162 
163  bool _enabled { false };
164  uint64_t _lastCompile { 0 };
165  uint64_t _firstCompile { 0 };
166  int32_t _frameCount { 0 };
167 
168  // Rendering object descriptions
169  QString _vertexShaderSource;
170  QString _vertexShaderPath;
171  uint64_t _vertexShaderModified { 0 };
172  NetworkShaderPointer _networkVertexShader;
173  QString _fragmentShaderSource;
174  QString _fragmentShaderPath;
175  uint64_t _fragmentShaderModified { 0 };
176  NetworkShaderPointer _networkFragmentShader;
177  bool _shaderDirty { true };
178  bool _uniformsDirty { true };
179 
180  QString _errorFallbackFragmentSource;
181 
182  // Rendering objects
183  UniformLambdas _uniforms;
184  NetworkTexturePointer _channels[MAX_PROCEDURAL_TEXTURE_CHANNELS];
185  Sampler _samplers[MAX_PROCEDURAL_TEXTURE_CHANNELS];
186  std::unordered_map<std::string, std::string> _vertexReplacements;
187  std::unordered_map<std::string, std::string> _fragmentReplacements;
188  std::unordered_map<std::string, int> _slotMap;
189 
190  std::unordered_map<ProceduralProgramKey, gpu::PipelinePointer> _proceduralPipelines;
191  std::unordered_map<ProceduralProgramKey, gpu::PipelinePointer> _errorPipelines;
192  std::unordered_map<ProceduralProgramKey, gpu::PipelinePointer> _disabledPipelines;
193 
194  StandardInputs _standardInputs;
195  gpu::BufferPointer _standardInputsBuffer;
196 
197  // Entity metadata
198  glm::vec3 _entityDimensions;
199  glm::vec3 _entityPosition;
200  glm::mat3 _entityOrientation;
201  uint64_t _entityCreated;
202 
203 private:
204  void setupUniforms();
205 
206  ProceduralProgramKey _prevKey;
207 
208  std::function<AABox(RenderArgs*)> _boundOperator { nullptr };
209 
210  mutable std::mutex _mutex;
211 };
212 
213 namespace graphics {
214 
215 class ProceduralMaterial : public NetworkMaterial {
216 public:
217  ProceduralMaterial() : NetworkMaterial() { initializeProcedural(); }
218  ProceduralMaterial(const NetworkMaterial& material) : NetworkMaterial(material) { initializeProcedural(); }
219 
220  virtual bool isProcedural() const override { return true; }
221  virtual bool isEnabled() const override { return _procedural.isEnabled(); }
222  virtual bool isReady() const override { return _procedural.isReady(); }
223  virtual QString getProceduralString() const override { return _proceduralString; }
224 
225  void setProceduralData(const QString& data) {
226  _proceduralString = data;
227  _procedural.setProceduralData(ProceduralData::parse(data));
228  }
229  virtual glm::vec4 getColor(const glm::vec4& color) const { return _procedural.getColor(color); }
230  virtual bool hasVertexShader() const { return _procedural.hasVertexShader(); }
231  virtual void prepare(gpu::Batch& batch, const glm::vec3& position, const glm::vec3& size, const glm::quat& orientation,
232  const uint64_t& created, const ProceduralProgramKey key = ProceduralProgramKey()) {
233  _procedural.prepare(batch, position, size, orientation, created, key);
234  }
235 
236  virtual void initializeProcedural();
237 
238  void setBoundOperator(const std::function<AABox(RenderArgs*)>& boundOperator) { _procedural.setBoundOperator(boundOperator); }
239  bool hasBoundOperator() const { return _procedural.hasBoundOperator(); }
240  AABox getBound(RenderArgs* args) { return _procedural.getBound(args); }
241 
242 private:
243  QString _proceduralString;
244  Procedural _procedural;
245 };
246 typedef std::shared_ptr<ProceduralMaterial> ProceduralMaterialPointer;
247 
248 }
render::Args
Definition: Args.h:100