Cumulia Illustrator Rendering Engine v1.1.0
A Rendering engine for industrial CAD/CAE model and optimized for greatest performance
 
Loading...
Searching...
No Matches
primitivemaker.h
1//##################################################################################################
2//
3// Copyright (c) 2024 Beijing Qiongqi Tech Co.,Ltd. All rights reserved.
4
5// This source code is confidential and proprietary to Beijing Qiongqi Tech Co.,Ltd(The Holder).
6// Any unauthorized use, copying, modification, or distribution of the code is strictly prohibited.
7// Any user shall obtain authorizaition from the Holder before modifying the source code. And the user shall not
8// sublicense, sell, distribute, or transfer the source code, whether in original or modified form, to any third party
9// without the prior written consent of the Holder.
10
11// This copyright notice and permission grant shall be included in all copies or substantial portions of the source code.
12
13// Author Cumulia Illustrator
14// Date 2024-10-31
15// Version V1.1.0
16//##################################################################################################
17
18#pragma once
19
20#include "../primitive/background.h"
21#include "../primitive/vertices.h"
22#include "../primitive/indices.h"
23#include "../primitive/state.h"
24#include "../primitive/geometry.h"
25#include "../primitive/sampler.h"
26#include "../primitive/program.h"
27#include "../primitive/material.h"
28#include "../primitive/primitive.h"
29#include "../primitive/target.h"
30#include "../make/variantmaker.h"
31
32#include <memory>
33#include <map>
34
35namespace cil
36{
37 // _vertices
38 std::shared_ptr<Vertices> _vertices(const std::shared_ptr<Float32Array>& buffer,
39 int offset = 0,
40 unsigned int stride = 0,
41 unsigned int divisor = 0);
42 std::shared_ptr<Vertices> _vertices(const std::shared_ptr<Int32Array>& buffer,
43 int offset = 0,
44 unsigned int stride = 0,
45 unsigned int divisor = 0);
46 std::shared_ptr<Vertices> _vertices(const std::initializer_list<float>& array,
47 int offset = 0,
48 unsigned int stride = 0,
49 unsigned int divisor = 0);
50
51 // _indices
52 std::shared_ptr<ArrayIndices> _arrayIndices(Indices::Mode mode,
53 int count,
54 int first = 0,
55 int primCount = 0);
56
57 std::shared_ptr<ArrayIndices> _triangles(int count,
58 int first = 0,
59 int primCount = 0);
60 std::shared_ptr<ArrayIndices> _triangle_fan(int count,
61 int first = 0,
62 int primCount = 0);
63 std::shared_ptr<ArrayIndices> _triangle_strip(int count,
64 int first = 0,
65 int primCount = 0);
66 std::shared_ptr<ArrayIndices> _lines(int count,
67 int first = 0,
68 int primCount = 0);
69 std::shared_ptr<ArrayIndices> _line_strip(int count,
70 int first = 0,
71 int primCount = 0);
72 std::shared_ptr<ArrayIndices> _line_loop(int count,
73 int first = 0,
74 int primCount = 0);
75 std::shared_ptr<ArrayIndices> _points(int count,
76 int first = 0,
77 int primCount = 0);
78
79 std::shared_ptr<ElementIndices> _elementIndices(Indices::Mode mode,
80 const std::shared_ptr<Uint8Array>& buffer,
81 int count = -1,
82 int offset = 0,
83 int primCount = 0);
84 std::shared_ptr<ElementIndices> _elementIndices(Indices::Mode mode,
85 const std::shared_ptr<Uint16Array>& buffer,
86 int count = -1,
87 int offset = 0,
88 int primCount = 0);
89 std::shared_ptr<ElementIndices> _elementIndices(Indices::Mode mode,
90 const std::shared_ptr<Uint32Array>& buffer,
91 int count = -1,
92 int offset = 0,
93 int primCount = 0);
94
95 std::shared_ptr<ElementIndices> _triangles(const std::shared_ptr<Uint8Array>& buffer,
96 int count = -1,
97 int offset = 0,
98 int primCount = 0);
99 std::shared_ptr<ElementIndices> _triangles(const std::shared_ptr<Uint16Array>& buffer,
100 int count = -1,
101 int offset = 0,
102 int primCount = 0);
103 std::shared_ptr<ElementIndices> _triangles(const std::shared_ptr<Uint32Array>& buffer,
104 int count = -1,
105 int offset = 0,
106 int primCount = 0);
107 std::shared_ptr<ElementIndices> _triangles(const std::initializer_list<unsigned int>& array,
108 int count = -1,
109 int offset = 0,
110 int primCount = 0);
111
112 std::shared_ptr<ElementIndices> _triangle_fan(const std::shared_ptr<Uint8Array>& buffer,
113 int count = -1,
114 int offset = 0,
115 int primCount = 0);
116 std::shared_ptr<ElementIndices> _triangle_fan(const std::shared_ptr<Uint16Array>& buffer,
117 int count = -1,
118 int offset = 0,
119 int primCount = 0);
120 std::shared_ptr<ElementIndices> _triangle_fan(const std::shared_ptr<Uint32Array>& buffer,
121 int count = -1,
122 int offset = 0,
123 int primCount = 0);
124 std::shared_ptr<ElementIndices> _triangle_fan(const std::initializer_list<unsigned int>& array,
125 int count = -1,
126 int offset = 0,
127 int primCount = 0);
128
129 std::shared_ptr<ElementIndices> _triangle_strip(const std::shared_ptr<Uint8Array>& buffer,
130 int count = -1,
131 int offset = 0,
132 int primCount = 0);
133 std::shared_ptr<ElementIndices> _triangle_strip(const std::shared_ptr<Uint16Array>& buffer,
134 int count = -1,
135 int offset = 0,
136 int primCount = 0);
137 std::shared_ptr<ElementIndices> _triangle_strip(const std::shared_ptr<Uint32Array>& buffer,
138 int count = -1,
139 int offset = 0,
140 int primCount = 0);
141 std::shared_ptr<ElementIndices> _triangle_strip(const std::initializer_list<unsigned int>& array,
142 int count = -1,
143 int offset = 0,
144 int primCount = 0);
145
146 std::shared_ptr<ElementIndices> _lines(const std::shared_ptr<Uint8Array>& buffer,
147 int count = -1,
148 int offset = 0,
149 int primCount = 0);
150 std::shared_ptr<ElementIndices> _lines(const std::shared_ptr<Uint16Array>& buffer,
151 int count = -1,
152 int offset = 0,
153 int primCount = 0);
154 std::shared_ptr<ElementIndices> _lines(const std::shared_ptr<Uint32Array>& buffer,
155 int count = -1,
156 int offset = 0,
157 int primCount = 0);
158 std::shared_ptr<ElementIndices> _lines(const std::initializer_list<unsigned int>& array,
159 int count = -1,
160 int offset = 0,
161 int primCount = 0);
162
163 std::shared_ptr<ElementIndices> _line_strip(const std::shared_ptr<Uint8Array>& buffer,
164 int count = -1,
165 int offset = 0,
166 int primCount = 0);
167 std::shared_ptr<ElementIndices> _line_strip(const std::shared_ptr<Uint16Array>& buffer,
168 int count = -1,
169 int offset = 0,
170 int primCount = 0);
171 std::shared_ptr<ElementIndices> _line_strip(const std::shared_ptr<Uint32Array>& buffer,
172 int count = -1,
173 int offset = 0,
174 int primCount = 0);
175 std::shared_ptr<ElementIndices> _line_strip(const std::initializer_list<unsigned int>& array,
176 int count = -1,
177 int offset = 0,
178 int primCount = 0);
179
180 std::shared_ptr<ElementIndices> _line_loop(const std::shared_ptr<Uint8Array>& buffer,
181 int count = -1,
182 int offset = 0,
183 int primCount = 0);
184 std::shared_ptr<ElementIndices> _line_loop(const std::shared_ptr<Uint16Array>& buffer,
185 int count = -1,
186 int offset = 0,
187 int primCount = 0);
188 std::shared_ptr<ElementIndices> _line_loop(const std::shared_ptr<Uint32Array>& buffer,
189 int count = -1,
190 int offset = 0,
191 int primCount = 0);
192 std::shared_ptr<ElementIndices> _line_loop(const std::initializer_list<unsigned int>& array,
193 int count = -1,
194 int offset = 0,
195 int primCount = 0);
196
197 std::shared_ptr<ElementIndices> _points(const std::shared_ptr<Uint8Array>& buffer,
198 int count = -1,
199 int offset = 0,
200 int primCount = 0);
201 std::shared_ptr<ElementIndices> _points(const std::shared_ptr<Uint16Array>& buffer,
202 int count = -1,
203 int offset = 0,
204 int primCount = 0);
205 std::shared_ptr<ElementIndices> _points(const std::shared_ptr<Uint32Array>& buffer,
206 int count = -1,
207 int offset = 0,
208 int primCount = 0);
209 std::shared_ptr<ElementIndices> _points(const std::initializer_list<unsigned int>& array,
210 int count = -1,
211 int offset = 0,
212 int primCount = 0);
213
214 // _verticesSet
215 std::shared_ptr<std::map<std::string, std::shared_ptr<Vertices>>> _verticesSet(const std::map<std::string, std::shared_ptr<Vertices>>& verticesMap = {});
216
217 // _geometry
218 std::shared_ptr<Geometry> _geometry(const std::shared_ptr<std::map<std::string, std::shared_ptr<Vertices>>>& verticesSet = _verticesSet(),
219 const std::shared_ptr<Indices>& indices = nullptr,
220 const std::shared_ptr<BoundingBox>& boundingBox = nullptr);
221 std::shared_ptr<Geometry> _geometry(std::map<std::string, std::shared_ptr<Vertices>> verticesSet,
222 const std::shared_ptr<Indices>& indices = nullptr,
223 const std::shared_ptr<BoundingBox>& boundingBox = nullptr);
224 std::shared_ptr<Geometry> _geometry(const std::shared_ptr<Indices>& indices,
225 const std::shared_ptr<BoundingBox>& boundingBox = nullptr);
226
227 // _blend
228 std::shared_ptr<Blend> _blend(bool enabled = false,
229 Blend::Function srcFunc = Blend::Function::SRC_ALPHA,
230 Blend::Function dstFunc = Blend::Function::ONE_MINUS_SRC_ALPHA,
231 Blend::Equation equation = Blend::Equation::FUNC_ADD);
232
233 // _colorMask
234 std::shared_ptr<ColorMask> _colorMask(bool red = true,
235 bool green = true,
236 bool blue = true,
237 bool alpha = true);
238
239 // _culling
240 std::shared_ptr<Culling> _culling(bool enabled = false,
241 Culling::Face face = Culling::Face::CCW,
242 Culling::Mode mode = Culling::Mode::BACK);
243
244 // _depth
245 std::shared_ptr<Depth> _depth(bool enabled = false,
246 Depth::Function func = Depth::Function::LESS,
247 bool writeMask = true);
248
249 // _line
250 std::shared_ptr<Line> _line(float width = 1.0f);
251
252 // _point
253 std::shared_ptr<Point> _point(float size = 1.0f,
254 bool programmable = false);
255
256 // _polygon
257 std::shared_ptr<Polygon> _polygon(Polygon::Mode mode = Polygon::Mode::FILL);
258
259 // _polygonOffset
260 std::shared_ptr<PolygonOffset> _polygonOffset(bool enabled = false,
261 float factor = 0.0f,
262 float units = 0.0f);
263
264 // _scissor
265 std::shared_ptr<Scissor> _scissor(bool enabled = false,
266 int x = 0,
267 int y = 0,
268 int width = 0,
269 int height = 0);
270
271 // _stencil
272 std::shared_ptr<Stencil> _stencil(bool enabled = false,
273 Stencil::Operation sfail = Stencil::Operation::KEEP,
274 Stencil::Operation dpfail = Stencil::Operation::KEEP,
275 Stencil::Operation dppass = Stencil::Operation::KEEP,
276 Stencil::Function func = Stencil::Function::ALWAYS,
277 int ref = 0,
278 int mask = 0xFF);
279
280 // _sampler
281 std::shared_ptr<Sampler> _sampler(
282 Sampler::Filter minFilter = Sampler::Filter::LINEAR_MIPMAP_NEAREST,
283 Sampler::Filter magFilter = Sampler::Filter::LINEAR,
284 Sampler::WrapMode wrapS = Sampler::WrapMode::REPEAT,
285 Sampler::WrapMode wrapT = Sampler::WrapMode::REPEAT);
286 std::shared_ptr<Sampler> _samplerClamp();
287 std::shared_ptr<Sampler> _samplerRepeat();
288 std::shared_ptr<Sampler> _samplerMirror();
289 std::shared_ptr<Sampler> _samplerCube();
290
291 // _texture
292 std::shared_ptr<Texture> _texture(int unit,
293 const std::shared_ptr<Image>& image,
294 const std::shared_ptr<Sampler>& sampler = nullptr);
295 std::shared_ptr<Texture> _texture0(const std::shared_ptr<Image>& image, const std::shared_ptr<Sampler>& sampler = nullptr);
296 std::shared_ptr<Texture> _texture1(const std::shared_ptr<Image>& image, const std::shared_ptr<Sampler>& sampler = nullptr);
297 std::shared_ptr<Texture> _texture2(const std::shared_ptr<Image>& image, const std::shared_ptr<Sampler>& sampler = nullptr);
298 std::shared_ptr<Texture> _texture3(const std::shared_ptr<Image>& image, const std::shared_ptr<Sampler>& sampler = nullptr);
299 std::shared_ptr<Texture> _texture4(const std::shared_ptr<Image>& image, const std::shared_ptr<Sampler>& sampler = nullptr);
300 std::shared_ptr<Texture> _texture5(const std::shared_ptr<Image>& image, const std::shared_ptr<Sampler>& sampler = nullptr);
301 std::shared_ptr<Texture> _texture6(const std::shared_ptr<Image>& image, const std::shared_ptr<Sampler>& sampler = nullptr);
302 std::shared_ptr<Texture> _texture7(const std::shared_ptr<Image>& image, const std::shared_ptr<Sampler>& sampler = nullptr);
303
304 // _program
305 std::shared_ptr<Program> _program(
306 const std::shared_ptr<VertexSource>& vertex = nullptr,
307 const std::shared_ptr<FragmentSource>& fragment = nullptr,
308 const std::shared_ptr<GeometrySource>& geometry = nullptr);
309 std::shared_ptr<Program> _program(
310 const std::shared_ptr<FragmentSource>& fragment,
311 const std::shared_ptr<GeometrySource>& geometry = nullptr);
312 std::shared_ptr<Program> _program(
313 const std::shared_ptr<GeometrySource>& geometry);
314 std::shared_ptr<Program> _program(const std::string& vertexString);
315 std::shared_ptr<Program> _program(const std::string& vertexString, const std::string& fragmentString);
316 std::shared_ptr<Program> _program(const std::string& vertexString, const std::string& fragmentString, const std::string& geometryString);
317
318 // _parameters
319 std::shared_ptr<std::map<std::string, std::shared_ptr<Variant>>> _parameters(const std::map<std::string, std::shared_ptr<Variant>>& parameters = {});
320
321 // _states
322 std::shared_ptr<std::vector<std::shared_ptr<State>>> _states(const std::vector<std::shared_ptr<State>>& states = {});
323
324 // _material
325 std::shared_ptr<Material> _material(
326 const std::shared_ptr<Program>& program = nullptr,
327 const std::shared_ptr<std::map<std::string, std::shared_ptr<Variant>>>& parameters = nullptr,
328 const std::shared_ptr<std::vector<std::shared_ptr<State>>>& states = nullptr);
329 std::shared_ptr<Material> _material(
330 const std::shared_ptr<Program>& program,
331 const std::shared_ptr<std::vector<std::shared_ptr<State>>>& states);
332 std::shared_ptr<Material> _material(
333 const std::shared_ptr<std::map<std::string, std::shared_ptr<Variant>>>& parameters,
334 const std::shared_ptr<std::vector<std::shared_ptr<State>>>& states = nullptr);
335
336 std::shared_ptr<Material> _material(
337 const std::vector<std::shared_ptr<Source>>& sources,
338 const std::map<std::string, std::shared_ptr<Variant>>& parameters,
339 const std::vector<std::shared_ptr<State>>& states);
340 std::shared_ptr<Material> _material(
341 const std::vector<std::shared_ptr<Source>>& sources,
342 const std::map<std::string, std::shared_ptr<Variant>>& parameters);
343 std::shared_ptr<Material> _material(
344 const std::vector<std::shared_ptr<Source>>& sources,
345 const std::vector<std::shared_ptr<State>>& states);
346 std::shared_ptr<Material> _material(
347 const std::vector<std::shared_ptr<Source>>& sources);
348
349 std::shared_ptr<Material> _material(
350 const std::shared_ptr<Program>& program,
351 const std::map<std::string, std::shared_ptr<Variant>>& parameters,
352 const std::vector<std::shared_ptr<State>>& states);
353 std::shared_ptr<Material> _material(
354 const std::shared_ptr<Program>& program,
355 const std::map<std::string, std::shared_ptr<Variant>>& parameters);
356 std::shared_ptr<Material> _material(
357 const std::shared_ptr<Program>& program,
358 const std::vector<std::shared_ptr<State>>& states);
359 std::shared_ptr<Material> _material(
360 const std::map<std::string, std::shared_ptr<Variant>>& parameters,
361 const std::vector<std::shared_ptr<State>>& states);
362 std::shared_ptr<Material> _material(
363 const std::map<std::string, std::shared_ptr<Variant>>& parameters);
364 std::shared_ptr<Material> _material(
365 const std::vector<std::shared_ptr<State>>& states);
366
367 // _background
368 std::shared_ptr<Background> _background(const std::shared_ptr<Vector2i>& size,
369 const std::shared_ptr<Color4f>& colorMask = nullptr,
370 const std::shared_ptr<Real>& depthMask = nullptr,
371 const std::shared_ptr<Integer>& stencilMask = nullptr,
372 const std::shared_ptr<Vector2i>& coordinate = _ivec2());
373 std::shared_ptr<Background> _simpleBackground(const std::shared_ptr<Vector2i>& size,
374 const std::shared_ptr<Color4f>& colorMask = _clr4(0.7, 0.7, 0.7, 1.0),
375 const std::shared_ptr<Real>& depthMask = _real(1.0),
376 const std::shared_ptr<Integer>& stencilMask = nullptr,
377 const std::shared_ptr<Vector2i>& coordinate = _ivec2());
378
379 // _colorBuf
380 std::shared_ptr<ImageBuffer> _colorBuf();
381
382 // _target
383 std::shared_ptr<Target> _target();
384 std::shared_ptr<Target> _target(const std::vector<std::shared_ptr<ImageBuffer>>& array);
385
386 // _primitive
387 std::shared_ptr<Primitive> _primitive(
388 const std::shared_ptr<Geometry>& geometry = nullptr,
389 const std::shared_ptr<Material>& material = nullptr,
390 int priority = 0);
391 std::shared_ptr<Primitive> _primitive(
392 const std::shared_ptr<Material>& material,
393 int priority = 0);
394}
cil::Blend::Function
Function
The factors in this enumeration specify how the source and destination color values are combined duri...
Definition state.h:48
cil::Blend::Equation
Equation
This enumeration defines different operations used in the blend equation. These operations determine ...
Definition state.h:68
cil::Culling::Mode
Mode
The enumeration defines the type of the face we want to cull.
Definition state.h:108
cil::Culling::Face
Face
The enumeration defines the ordering (counter-clockwise and clockwise) of the front-faces or the back...
Definition state.h:115
cil::Depth::Function
Function
This enumeration defines different comparison operators used for the depth test.
Definition state.h:136
cil::Indices::Mode
Mode
The Mode enumeration defines identifiers corresponding to different ways of rendering geometric primi...
Definition indices.h:36
cil::Polygon::Mode
Mode
Definition state.h:181
cil::Sampler::WrapMode
WrapMode
The enumeration defines three different wrapping mode.
Definition sampler.h:40
cil::Sampler::Filter
Filter
The enumeration defines how to map the texture pixel to the coordinates.
Definition sampler.h:30
cil::Stencil::Function
Function
This enumeration defines different comparison operators used for the stencil test.
Definition state.h:230
cil::Stencil::Operation
Operation
This enumeration defines how to update the stencil buffer after the stencil test.
Definition state.h:243
cil
Definition decal.h:23
cil::_samplerRepeat
std::shared_ptr< Sampler > _samplerRepeat()
cil::_texture3
std::shared_ptr< Texture > _texture3(const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)
cil::_samplerClamp
std::shared_ptr< Sampler > _samplerClamp()
cil::_ivec2
std::shared_ptr< Vector2i > _ivec2()
cil::_culling
std::shared_ptr< Culling > _culling(bool enabled=false, Culling::Face face=Culling::Face::CCW, Culling::Mode mode=Culling::Mode::BACK)
cil::_triangle_fan
std::shared_ptr< ArrayIndices > _triangle_fan(int count, int first=0, int primCount=0)
cil::_stencil
std::shared_ptr< Stencil > _stencil(bool enabled=false, Stencil::Operation sfail=Stencil::Operation::KEEP, Stencil::Operation dpfail=Stencil::Operation::KEEP, Stencil::Operation dppass=Stencil::Operation::KEEP, Stencil::Function func=Stencil::Function::ALWAYS, int ref=0, int mask=0xFF)
cil::_point
std::shared_ptr< Point > _point(float size=1.0f, bool programmable=false)
cil::_triangles
std::shared_ptr< ArrayIndices > _triangles(int count, int first=0, int primCount=0)
cil::_line_loop
std::shared_ptr< ArrayIndices > _line_loop(int count, int first=0, int primCount=0)
cil::_parameters
std::shared_ptr< std::map< std::string, std::shared_ptr< Variant > > > _parameters(const std::map< std::string, std::shared_ptr< Variant > > &parameters={})
cil::_simpleBackground
std::shared_ptr< Background > _simpleBackground(const std::shared_ptr< Vector2i > &size, const std::shared_ptr< Color4f > &colorMask=_clr4(0.7, 0.7, 0.7, 1.0), const std::shared_ptr< Real > &depthMask=_real(1.0), const std::shared_ptr< Integer > &stencilMask=nullptr, const std::shared_ptr< Vector2i > &coordinate=_ivec2())
cil::_line
std::shared_ptr< Line > _line(float width=1.0f)
cil::_texture7
std::shared_ptr< Texture > _texture7(const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)
cil::_samplerCube
std::shared_ptr< Sampler > _samplerCube()
cil::_program
std::shared_ptr< Program > _program(const std::shared_ptr< VertexSource > &vertex=nullptr, const std::shared_ptr< FragmentSource > &fragment=nullptr, const std::shared_ptr< GeometrySource > &geometry=nullptr)
cil::_clr4
std::shared_ptr< Color4f > _clr4()
cil::_vertices
std::shared_ptr< Vertices > _vertices(const std::shared_ptr< Float32Array > &buffer, int offset=0, unsigned int stride=0, unsigned int divisor=0)
cil::_polygon
std::shared_ptr< Polygon > _polygon(Polygon::Mode mode=Polygon::Mode::FILL)
cil::_samplerMirror
std::shared_ptr< Sampler > _samplerMirror()
cil::_material
std::shared_ptr< Material > _material(const std::shared_ptr< Program > &program=nullptr, const std::shared_ptr< std::map< std::string, std::shared_ptr< Variant > > > &parameters=nullptr, const std::shared_ptr< std::vector< std::shared_ptr< State > > > &states=nullptr)
cil::_scissor
std::shared_ptr< Scissor > _scissor(bool enabled=false, int x=0, int y=0, int width=0, int height=0)
cil::_texture1
std::shared_ptr< Texture > _texture1(const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)
cil::_verticesSet
std::shared_ptr< std::map< std::string, std::shared_ptr< Vertices > > > _verticesSet(const std::map< std::string, std::shared_ptr< Vertices > > &verticesMap={})
cil::_texture
std::shared_ptr< Texture > _texture(int unit, const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)
cil::_texture4
std::shared_ptr< Texture > _texture4(const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)
cil::_texture2
std::shared_ptr< Texture > _texture2(const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)
cil::_lines
std::shared_ptr< ArrayIndices > _lines(int count, int first=0, int primCount=0)
cil::_texture6
std::shared_ptr< Texture > _texture6(const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)
cil::_polygonOffset
std::shared_ptr< PolygonOffset > _polygonOffset(bool enabled=false, float factor=0.0f, float units=0.0f)
cil::_states
std::shared_ptr< std::vector< std::shared_ptr< State > > > _states(const std::vector< std::shared_ptr< State > > &states={})
cil::_line_strip
std::shared_ptr< ArrayIndices > _line_strip(int count, int first=0, int primCount=0)
cil::_points
std::shared_ptr< ArrayIndices > _points(int count, int first=0, int primCount=0)
cil::_background
std::shared_ptr< Background > _background(const std::shared_ptr< Vector2i > &size, const std::shared_ptr< Color4f > &colorMask=nullptr, const std::shared_ptr< Real > &depthMask=nullptr, const std::shared_ptr< Integer > &stencilMask=nullptr, const std::shared_ptr< Vector2i > &coordinate=_ivec2())
cil::_depth
std::shared_ptr< Depth > _depth(bool enabled=false, Depth::Function func=Depth::Function::LESS, bool writeMask=true)
cil::_texture5
std::shared_ptr< Texture > _texture5(const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)
cil::_arrayIndices
std::shared_ptr< ArrayIndices > _arrayIndices(Indices::Mode mode, int count, int first=0, int primCount=0)
cil::_triangle_strip
std::shared_ptr< ArrayIndices > _triangle_strip(int count, int first=0, int primCount=0)
cil::_colorBuf
std::shared_ptr< ImageBuffer > _colorBuf()
cil::_geometry
std::shared_ptr< Geometry > _geometry(const std::shared_ptr< std::map< std::string, std::shared_ptr< Vertices > > > &verticesSet=_verticesSet(), const std::shared_ptr< Indices > &indices=nullptr, const std::shared_ptr< BoundingBox > &boundingBox=nullptr)
cil::_elementIndices
std::shared_ptr< ElementIndices > _elementIndices(Indices::Mode mode, const std::shared_ptr< Uint8Array > &buffer, int count=-1, int offset=0, int primCount=0)
cil::_colorMask
std::shared_ptr< ColorMask > _colorMask(bool red=true, bool green=true, bool blue=true, bool alpha=true)
cil::_blend
std::shared_ptr< Blend > _blend(bool enabled=false, Blend::Function srcFunc=Blend::Function::SRC_ALPHA, Blend::Function dstFunc=Blend::Function::ONE_MINUS_SRC_ALPHA, Blend::Equation equation=Blend::Equation::FUNC_ADD)
cil::_target
std::shared_ptr< Target > _target()
cil::_primitive
std::shared_ptr< Primitive > _primitive(const std::shared_ptr< Geometry > &geometry=nullptr, const std::shared_ptr< Material > &material=nullptr, int priority=0)
cil::_texture0
std::shared_ptr< Texture > _texture0(const std::shared_ptr< Image > &image, const std::shared_ptr< Sampler > &sampler=nullptr)
cil::_sampler
std::shared_ptr< Sampler > _sampler(Sampler::Filter minFilter=Sampler::Filter::LINEAR_MIPMAP_NEAREST, Sampler::Filter magFilter=Sampler::Filter::LINEAR, Sampler::WrapMode wrapS=Sampler::WrapMode::REPEAT, Sampler::WrapMode wrapT=Sampler::WrapMode::REPEAT)
cil::_real
std::shared_ptr< Real > _real()