iridescence
Loading...
Searching...
No Matches
shader_setting.hpp
Go to the documentation of this file.
1#ifndef GUIK_SHADER_SETTING_HPP
2#define GUIK_SHADER_SETTING_HPP
3
4#include <memory>
5#include <optional>
6#include <unordered_map>
7
8#include <glk/drawable.hpp>
9#include <glk/make_shared.hpp>
10#include <guik/gl_canvas.hpp>
12
13namespace guik {
14
21struct ColorMode {
23};
24
29 enum MODE { SCREENSPACE = 0, METRIC = 1 };
30};
31
36 enum MODE { RECTANGLE = 0, CIRCLE = 1 };
37};
38
41
43template <typename T>
45 if constexpr (std::is_same<T, int>::value) {
47 } else if constexpr (std::is_same<T, Eigen::Vector2i>::value) {
49 } else if constexpr (std::is_same<T, Eigen::Vector3i>::value) {
51 } else if constexpr (std::is_same<T, Eigen::Vector4i>::value) {
53 } else if constexpr (std::is_same<T, float>::value) {
55 } else if constexpr (std::is_same<T, Eigen::Vector2f>::value) {
57 } else if constexpr (std::is_same<T, Eigen::Vector3f>::value) {
59 } else if constexpr (std::is_same<T, Eigen::Vector4f>::value) {
61 } else if constexpr (std::is_same<T, Eigen::Matrix4f>::value) {
63 } else if constexpr (std::is_same<T, std::vector<int>>::value) {
65 } else if constexpr (std::is_same<T, std::vector<float>>::value) {
67 } else {
69 }
70}
71
75public:
77 ShaderParameter() : type(ShaderDataType::INVALID), name(0), mat4f(Eigen::Matrix4f::Zero()) {}
78
80 template <typename T>
81 ShaderParameter(std::uint64_t name, const T& v) : type(deduce_data_type<T>()),
82 name(name) {
83 set_value<T>(v);
84 }
85
87 bool valid() const { return type != ShaderDataType::INVALID && name != 0; }
88
90 void invalidate() {
92 name = 0;
93 mat4f.setZero();
94 }
95
97 template <typename T>
98 T get_value() const {
99 if (type != deduce_data_type<T>()) {
100 std::cerr << "error: type mismatch when getting shader parameter " << name << std::endl;
101 abort();
102 }
103
104 if constexpr (std::is_same<T, std::vector<int>>::value || std::is_same<T, std::vector<float>>::value) {
105 const int* ptr = reinterpret_cast<const int*>(&mat4f);
106 int num_data = ptr[0];
107
108 T v(num_data);
109 memcpy(v.data(), &ptr[1], sizeof(typename T::value_type) * num_data);
110 return v;
111 } else {
112 return *reinterpret_cast<const T*>(&mat4f);
113 }
114 }
115
117 template <typename T>
118 void set_value(const T& value) {
119 if (type != deduce_data_type<T>()) {
120 std::cerr << "error: type mismatch when getting shader parameter " << name << std::endl;
121 abort();
122 }
123
124 if constexpr (std::is_same<T, std::vector<int>>::value || std::is_same<T, std::vector<float>>::value) {
125 if (value.size() > 15) {
126 std::cerr << "error: array size exceeds the maximum limit of 15 for shader parameter " << name << std::endl;
127 abort();
128 }
129
130 int* ptr = reinterpret_cast<int*>(&mat4f);
131 ptr[0] = static_cast<int>(value.size());
132 memcpy(&ptr[1], value.data(), sizeof(typename T::value_type) * value.size());
133 } else {
134 *reinterpret_cast<T*>(&mat4f) = value;
135 }
136 }
137
139 void set(glk::GLSLShader& shader) const {
140 switch (type) {
143 break;
146 break;
149 break;
152 break;
155 break;
158 break;
161 break;
164 break;
167 break;
169 shader.set_uniform(name, get_value<std::vector<int>>());
170 break;
172 shader.set_uniform(name, get_value<std::vector<float>>());
173 break;
174 default:
175 std::cerr << "error: invalid shader parameter type for " << name << std::endl;
176 break;
177 }
178 }
179
180public:
182 std::uint64_t name;
183 Eigen::Matrix4f mat4f;
184};
185
188public:
189 using Ptr = std::shared_ptr<ShaderSetting>;
190 using ConstPtr = std::shared_ptr<const ShaderSetting>;
191
198
202
206 ShaderSetting(int color_mode, const Eigen::Matrix4f& transform);
207
211 template <typename Transform>
212 ShaderSetting(int color_mode, const Transform& transform) : ShaderSetting(color_mode, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {}
213
216
219
221 virtual ~ShaderSetting() {}
222
225
230 template <typename T>
231 ShaderSetting& add(const std::string& name_, const T& value) {
232 const std::uint64_t name = glk::hash(name_);
233
234 for (int i = 0; i < params.size() && params[i].valid(); i++) {
235 if (params[i].name == name) {
236 params[i] = ShaderParameter(name, value);
237 return *this;
238 }
239 }
240
241 params.emplace_back(ShaderParameter(name, value));
242 return *this;
243 }
244
248 template <typename T>
249 std::optional<T> get(const std::string& name_) {
250 const std::uint64_t name = glk::hash(name_);
251
252 for (const auto& param : params) {
253 if (!param.valid() || param.name != name) {
254 continue;
255 }
256
257 if (param.type != deduce_data_type<T>()) {
258 std::cerr << "warning: type mismatch for shader parameter " << name_ << std::endl;
259 return std::nullopt;
260 }
261
262 return param.get_value<T>();
263 }
264
265 return std::nullopt;
266 }
267
271 template <typename T>
272 std::optional<T> get(const std::string& name_) const {
273 const std::uint64_t name = glk::hash(name_);
274
275 for (const auto& param : params) {
276 if (!param.valid() || param.name != name) {
277 continue;
278 }
279
280 if (param.type != deduce_data_type<T>()) {
281 std::cerr << "warning: type mismatch for shader parameter " << name_ << std::endl;
282 return std::nullopt;
283 }
284
285 return param.get_value<T>();
286 }
287
288 return std::nullopt;
289 }
290
294 template <typename T>
295 T cast(const std::string& name_) const {
296 const std::uint64_t name = glk::hash(name_);
297
298 for (const auto& param : params) {
299 if (!param.valid() || param.name != name) {
300 continue;
301 }
302
303 if (param.type != deduce_data_type<T>()) {
304 std::cerr << "error: type mismatch for shader parameter " << name << std::endl;
305 abort();
306 }
307
308 return param.get_value<T>();
309 }
310
311 std::cerr << "error: " << name << " not found in the param list" << std::endl;
312 abort();
313 }
314
317 void set(glk::GLSLShader& shader) const;
318
319 // Object type (static/dynamic)
324
325 // Color
327 Eigen::Vector4f material_color() const;
329 ShaderSetting& set_color(float r, float g, float b, float a);
330
333 template <typename Color>
334 ShaderSetting& set_color(const Color& color_) {
335 const Eigen::Vector4f color = color_.template cast<float>();
336 if (color.w() < 0.999f) {
337 transparent = true;
338 }
339 return add("material_color", color);
340 }
341
346
348 ShaderSetting& set_rainbow_range(const Eigen::Vector2f& minmax_z);
350 ShaderSetting& set_rainbow_axis(const Eigen::Vector3f& axis);
351
353 ShaderSetting& set_colormap_range(const Eigen::Vector2f& minmax);
354
355 // Point size and scale
357 float point_scale() const;
360
362 float point_size() const;
367
368 // Point shape mode
375
376 // Point scale mode
383
388 ShaderSetting& set_point_shape(float point_size, bool metric, bool circle);
389
392
393 // Calling `remove_model_matrix` invalidates model matrix operations (translate, rotate, and scale)
395
397 int color_mode() const;
400
402 Eigen::Matrix4f model_matrix() const;
404 Eigen::Vector3f translation() const;
406 Eigen::Matrix3f rotation() const;
407
410 template <typename Transform>
412 Eigen::Matrix4f mat = (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix();
413
414 auto& p = params[2];
415 p.set_value<Eigen::Matrix4f>(mat);
416 return *this;
417 }
418
422 template <typename Transform>
423 ShaderSetting& transform(const Transform& transform) {
424 auto& p = params[2];
425 Eigen::Matrix4f current = p.get_value<Eigen::Matrix4f>();
426 Eigen::Matrix4f trans_mat = (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix();
427 p.set_value<Eigen::Matrix4f>(current * trans_mat);
428 return *this;
429 }
430
432 ShaderSetting& translate(float tx, float ty, float tz);
434 ShaderSetting& translate(const Eigen::Vector3f& translation);
437 template <typename Vector>
439 auto& p = params[2];
440 const auto trans = translation.eval();
441 p.mat4f.block<3, 1>(0, 3) += trans.template cast<float>().template head<3>();
442 return *this;
443 }
444
446 ShaderSetting& rotate(const float angle, const Eigen::Vector3f& axis);
448 template <typename Vector>
449 ShaderSetting& rotate(const float angle, const Vector& axis) {
450 const Eigen::Vector3f ax = axis.eval().template cast<float>();
451 auto& p = params[2];
452 p.mat4f = p.mat4f * (Eigen::Isometry3f::Identity() * Eigen::AngleAxisf(angle, ax)).matrix();
453 return *this;
454 }
455
457 template <typename Scalar>
458 ShaderSetting& rotate(const Eigen::Quaternion<Scalar>& quat) {
459 auto& p = params[2];
460 p.mat4f = p.mat4f * (Eigen::Isometry3f::Identity() * quat.template cast<float>()).matrix();
461 return *this;
462 }
463
465 template <typename Scalar, int Dim>
466 ShaderSetting& rotate(const Eigen::Matrix<Scalar, Dim, Dim>& rot) {
467 Eigen::Isometry3f R = Eigen::Isometry3f::Identity();
468 R.linear() = rot.template cast<float>().template block<3, 3>(0, 0);
469
470 auto& p = params[2];
471 p.mat4f = p.mat4f * R.matrix();
472 return *this;
473 }
474
476 ShaderSetting& scale(float scaling);
478 ShaderSetting& scale(float sx, float sy, float sz);
480 ShaderSetting& scale(const Eigen::Vector3f& scaling);
483 template <typename Vector>
484 std::enable_if_t<!std::is_arithmetic_v<Vector>, ShaderSetting&> scale(const Vector& scaling) {
485 auto& p = params[2];
486 const auto s = scaling.eval();
487 p.mat4f.col(0) *= s[0];
488 p.mat4f.col(1) *= s[1];
489 p.mat4f.col(2) *= s[2];
490 return *this;
491 }
492
493public:
495 std::vector<ShaderParameter> params;
496};
497
498template <>
499inline ShaderSetting& ShaderSetting::add(const std::string& name, const Eigen::Isometry3f& value) {
500 return add<Eigen::Matrix4f>(name, value.matrix());
501}
502
503template <>
504inline ShaderSetting& ShaderSetting::add(const std::string& name, const Eigen::Affine3f& value) {
505 return add<Eigen::Matrix4f>(name, value.matrix());
506}
507
511struct Rainbow : public ShaderSetting {
512public:
514
515 template <typename Transform>
516 Rainbow(const Transform& transform) : ShaderSetting(ColorMode::RAINBOW, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {}
517
518 virtual ~Rainbow() override {}
519};
520
523struct FlatColor : public ShaderSetting {
524public:
525 explicit FlatColor(float r, float g, float b, float a = 1.0f) : ShaderSetting(ColorMode::FLAT_COLOR) {
526 add("material_color", Eigen::Vector4f(r, g, b, a));
527 transparent = a < 0.999f;
528 }
529
530 explicit FlatColor(const Eigen::Vector4f& color) : ShaderSetting(ColorMode::FLAT_COLOR) {
531 add("material_color", color);
532 transparent = color.w() < 0.999f;
533 }
534
535 template <typename Transform>
536 explicit FlatColor(const Eigen::Vector4f& color, const Transform& transform)
537 : ShaderSetting(ColorMode::FLAT_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {
538 add("material_color", color);
539 transparent = color.w() < 0.999f;
540 }
541
542 template <typename Color>
543 explicit FlatColor(const Color& color) : ShaderSetting(ColorMode::FLAT_COLOR) {
544 const Eigen::Vector4f c = color.eval().template cast<float>();
545 add("material_color", c);
546 transparent = color.w() < 0.999f;
547 }
548
549 template <typename Transform>
550 explicit FlatColor(float r, float g, float b, float a, const Transform& transform)
551 : ShaderSetting(ColorMode::FLAT_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {
552 add("material_color", Eigen::Vector4f(r, g, b, a));
553 transparent = a < 0.999f;
554 }
555
556 template <typename Color, typename Transform>
557 explicit FlatColor(const Color& color, const Transform& transform)
558 : ShaderSetting(ColorMode::FLAT_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {
559 const Eigen::Vector4f c = color.eval().template cast<float>();
560 add("material_color", c);
561 transparent = color.w() < 0.999f;
562 }
563
564 template <typename T>
565 explicit FlatColor(std::initializer_list<T> i) : ShaderSetting(ColorMode::FLAT_COLOR) {
566 Eigen::Vector4f color = Eigen::Vector4f::Zero();
567 std::copy(i.begin(), i.end(), color.data());
568 add("material_color", color);
569 transparent = color.w() < 0.999f;
570 }
571
572 template <typename T, typename Transform>
573 explicit FlatColor(std::initializer_list<T> i, const Transform& transform)
574 : ShaderSetting(ColorMode::FLAT_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {
575 Eigen::Vector4f color = Eigen::Vector4f::Zero();
576 std::copy(i.begin(), i.end(), color.data());
577 add("material_color", color);
578 transparent = color.w() < 0.999f;
579 }
580
581 virtual ~FlatColor() override {}
582};
583
584/* primitive colors */
586struct FlatRed : public FlatColor {
587 FlatRed() : FlatColor(1.0f, 0.0f, 0.0f, 1.0f) {}
588
589 template <typename Transform>
590 FlatRed(const Transform& transform) : FlatColor(1.0f, 0.0f, 0.0f, 1.0f, transform) {}
591};
592
594struct FlatGreen : public FlatColor {
595 FlatGreen() : FlatColor(0.0f, 1.0f, 0.0f, 1.0f) {}
596
597 template <typename Transform>
598 FlatGreen(const Transform& transform) : FlatColor(0.0f, 1.0f, 0.0f, 1.0f, transform) {}
599};
600
602struct FlatBlue : public FlatColor {
603 FlatBlue() : FlatColor(0.0f, 0.0f, 1.0f, 1.0f) {}
604
605 template <typename Transform>
606 FlatBlue(const Transform& transform) : FlatColor(0.0f, 0.0f, 1.0f, 1.0f, transform) {}
607};
608
610struct FlatOrange : public FlatColor {
611 FlatOrange() : FlatColor(1.0f, 0.5f, 0.0f, 1.0f) {}
612
613 template <typename Transform>
614 FlatOrange(const Transform& transform) : FlatColor(1.0f, 0.5f, 0.0f, 1.0f, transform) {}
615};
616
618struct FlatWhite : public FlatColor {
619 FlatWhite() : FlatColor(1.0f, 1.0f, 1.0f, 1.0f) {}
620
621 template <typename Transform>
622 FlatWhite(const Transform& transform) : FlatColor(1.0f, 1.0f, 1.0f, 1.0f, transform) {}
623};
624
626struct FlatGray : public FlatColor {
627 FlatGray() : FlatColor(0.7f, 0.7f, 0.7f, 1.0f) {}
628
629 template <typename Transform>
630 FlatGray(const Transform& transform) : FlatColor(0.7f, 0.7f, 0.7f, 1.0f, transform) {}
631};
632
634struct FlatDarkGray : public FlatColor {
635 FlatDarkGray() : FlatColor(0.3f, 0.3f, 0.3f, 1.0f) {}
636
637 template <typename Transform>
638 FlatDarkGray(const Transform& transform) : FlatColor(0.3f, 0.3f, 0.3f, 1.0f, transform) {}
639};
640
642struct FlatBlack : public FlatColor {
643 FlatBlack() : FlatColor(0.0f, 0.0f, 0.0f, 1.0f) {}
644
645 template <typename Transform>
646 FlatBlack(const Transform& transform) : FlatColor(0.0f, 0.0f, 0.0f, 1.0f, transform) {}
647};
648
650struct VertexColor : public ShaderSetting {
651public:
652 VertexColor() : ShaderSetting(ColorMode::VERTEX_COLOR) {}
653
654 template <typename Transform>
655 VertexColor(const Transform& transform) : ShaderSetting(ColorMode::VERTEX_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {}
656
657 virtual ~VertexColor() override {}
658};
659
662public:
663 TextureColor() : ShaderSetting(ColorMode::TEXTURE_COLOR) {}
664
665 template <typename Transform>
666 TextureColor(const Transform& transform) : ShaderSetting(ColorMode::TEXTURE_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {}
667
668 virtual ~TextureColor() override {}
669};
670
673public:
674 VertexColorMap() : ShaderSetting(ColorMode::VERTEX_COLORMAP) {}
675
676 template <typename Transform>
677 VertexColorMap(const Transform& transform) : ShaderSetting(ColorMode::VERTEX_COLORMAP, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {}
678
679 virtual ~VertexColorMap() override {}
680};
681
682} // namespace guik
683
684#endif
GLSLShader is a wrapper for OpenGL shader programs.
Definition glsl_shader.hpp:49
void set_uniform(std::uint64_t name, int value, const char *debug_msg=nullptr)
std::uint64_t hash(const void *data, std::size_t size, std::uint64_t seed=0)
RapidHash (https://github.com/Nicoshev/rapidhash).
Definition drawable_container.hpp:9
ShaderDataType
Data type of shader parameter.
Definition shader_setting.hpp:40
@ INT3
Definition shader_setting.hpp:40
@ INT
Definition shader_setting.hpp:40
@ FLOAT_ARRAY
Definition shader_setting.hpp:40
@ FLOAT3
Definition shader_setting.hpp:40
@ INT2
Definition shader_setting.hpp:40
@ INT4
Definition shader_setting.hpp:40
@ FLOAT2
Definition shader_setting.hpp:40
@ INVALID
Definition shader_setting.hpp:40
@ INT_ARRAY
Definition shader_setting.hpp:40
@ FLOAT
Definition shader_setting.hpp:40
@ FLOAT4
Definition shader_setting.hpp:40
@ MATRIX4
Definition shader_setting.hpp:40
ShaderDataType deduce_data_type()
Deduce shader data type from C++ type.
Definition shader_setting.hpp:44
Fragment color mode. RAINBOW : Color mapped by 3D coordinates of pixels (by default,...
Definition shader_setting.hpp:21
MODE
Definition shader_setting.hpp:22
@ VERTEX_COLOR
Definition shader_setting.hpp:22
@ FLAT_COLOR
Definition shader_setting.hpp:22
@ TEXTURE_COLOR
Definition shader_setting.hpp:22
@ VERTEX_COLORMAP
Definition shader_setting.hpp:22
@ RAINBOW
Definition shader_setting.hpp:22
FlatBlack(const Transform &transform)
Definition shader_setting.hpp:646
FlatBlack()
Definition shader_setting.hpp:643
FlatBlue()
Definition shader_setting.hpp:603
FlatBlue(const Transform &transform)
Definition shader_setting.hpp:606
FlatColor(const Eigen::Vector4f &color, const Transform &transform)
Definition shader_setting.hpp:536
FlatColor(float r, float g, float b, float a=1.0f)
Definition shader_setting.hpp:525
FlatColor(std::initializer_list< T > i, const Transform &transform)
Definition shader_setting.hpp:573
FlatColor(const Eigen::Vector4f &color)
Definition shader_setting.hpp:530
FlatColor(std::initializer_list< T > i)
Definition shader_setting.hpp:565
FlatColor(float r, float g, float b, float a, const Transform &transform)
Definition shader_setting.hpp:550
virtual ~FlatColor() override
Definition shader_setting.hpp:581
FlatColor(const Color &color)
Definition shader_setting.hpp:543
FlatColor(const Color &color, const Transform &transform)
Definition shader_setting.hpp:557
FlatDarkGray()
Definition shader_setting.hpp:635
FlatDarkGray(const Transform &transform)
Definition shader_setting.hpp:638
FlatGray(const Transform &transform)
Definition shader_setting.hpp:630
FlatGray()
Definition shader_setting.hpp:627
FlatGreen()
Definition shader_setting.hpp:595
FlatGreen(const Transform &transform)
Definition shader_setting.hpp:598
FlatOrange()
Definition shader_setting.hpp:611
FlatOrange(const Transform &transform)
Definition shader_setting.hpp:614
FlatRed()
Definition shader_setting.hpp:587
FlatRed(const Transform &transform)
Definition shader_setting.hpp:590
FlatWhite()
Definition shader_setting.hpp:619
FlatWhite(const Transform &transform)
Definition shader_setting.hpp:622
Point size scale mode. SCREENSPACE : Screen space size METRIC : Metric size (in meters).
Definition shader_setting.hpp:28
MODE
Definition shader_setting.hpp:29
@ SCREENSPACE
Definition shader_setting.hpp:29
@ METRIC
Definition shader_setting.hpp:29
Point shape mode. RECTANGLE : Square/rectangle shape CIRCLE : Circle shape.
Definition shader_setting.hpp:35
MODE
Definition shader_setting.hpp:36
@ CIRCLE
Definition shader_setting.hpp:36
@ RECTANGLE
Definition shader_setting.hpp:36
virtual ~Rainbow() override
Definition shader_setting.hpp:518
Rainbow(const Transform &transform)
Definition shader_setting.hpp:516
Rainbow()
Definition shader_setting.hpp:513
Shader parameter class that holds a single parameter for shader setting.
Definition shader_setting.hpp:74
std::uint64_t name
Name of the parameter (hashed).
Definition shader_setting.hpp:182
ShaderParameter(std::uint64_t name, const T &v)
Constructor.
Definition shader_setting.hpp:81
Eigen::Matrix4f mat4f
Value of the parameter (stored as 4x4 float matrix).
Definition shader_setting.hpp:183
ShaderDataType type
Data type of the parameter.
Definition shader_setting.hpp:181
void set(glk::GLSLShader &shader) const
Set the parameter to the shader.
Definition shader_setting.hpp:139
ShaderParameter()
Default constructor.
Definition shader_setting.hpp:77
T get_value() const
Get the parameter value.
Definition shader_setting.hpp:98
void invalidate()
Invalidate the parameter.
Definition shader_setting.hpp:90
bool valid() const
Check if the parameter is valid.
Definition shader_setting.hpp:87
void set_value(const T &value)
Get the parameter value.
Definition shader_setting.hpp:118
ShaderSetting & scale(float scaling)
Apply uniform scaling to the model matrix.
ShaderSetting & add(const std::string &name_, const T &value)
Add a new parameter to the shader setting.
Definition shader_setting.hpp:231
ShaderSetting & set_point_shape(float point_size, bool metric, bool circle)
Set point shape with common settings.
ShaderSetting & set_color_mode(int color_mode)
Set color mode.
std::enable_if_t<!std::is_arithmetic_v< Vector >, ShaderSetting & > scale(const Vector &scaling)
Apply scaling to the model matrix (non-uniform).
Definition shader_setting.hpp:484
ShaderSetting & remove_model_matrix()
ShaderSetting & set_old_default_point_shape()
Set old (v0.1.9) default point shape (rectangle + screenspace).
ShaderSetting & make_transparent()
Make the object transparent (alpha blending).
ShaderSetting clone() const
Clone the shader setting.
ShaderSetting(int color_mode)
Constructor.
ShaderSetting & set_point_scale_screenspace()
Set point size scale to screen space.
ShaderSetting & set_color(const Color &color_)
Set material color (for FLAT_COLOR).
Definition shader_setting.hpp:334
std::optional< T > get(const std::string &name_) const
Get a parameter value from the shader setting.
Definition shader_setting.hpp:272
ShaderSetting & operator=(const ShaderSetting &other)
Copy assignment operator.
ShaderSetting & translate(const Vector &translation)
Apply translation to the model matrix.
Definition shader_setting.hpp:438
Eigen::Matrix4f model_matrix() const
Get model matrix.
virtual ~ShaderSetting()
Destructor.
Definition shader_setting.hpp:221
ShaderSetting & set_rainbow_axis(const Eigen::Vector3f &axis)
Set RAINBOW coloring axis.
ShaderSetting & set_point_size(float size)
Set point size.
ShaderSetting & dynamic_object()
Set dynamic object flag.
ShaderSetting & scale(const Eigen::Vector3f &scaling)
Apply scaling to the model matrix (non-uniform).
ShaderSetting & set_point_shape_rectangle()
Set point shape to rectangle.
std::shared_ptr< const ShaderSetting > ConstPtr
Definition shader_setting.hpp:190
ShaderSetting & set_rainbow_range(const Eigen::Vector2f &minmax_z)
Set RAINBOW color range.
ShaderSetting & static_object()
Set static object flag.
ShaderSetting & transform(const Transform &transform)
Apply transformation to the model matrix.
Definition shader_setting.hpp:423
ShaderSetting & translate(float tx, float ty, float tz)
Apply translation to the model matrix.
ShaderSetting & translate(const Eigen::Vector3f &translation)
Apply translation to the model matrix.
ShaderSetting & set_model_matrix(const Transform &transform)
Set model matrix.
Definition shader_setting.hpp:411
ShaderSetting & set_alpha(float alpha)
Set alpha value of the material color.
ShaderSetting & set_point_size_offset(float offset)
Set point size offset.
Eigen::Vector3f translation() const
Get translation vector from the model matrix.
ShaderSetting & set_point_scale_mode(guik::PointScaleMode::MODE mode)
Set point size scale mode.
ShaderSetting(int color_mode, const Transform &transform)
Constructor.
Definition shader_setting.hpp:212
Eigen::Vector4f material_color() const
Get material color (FLAT_COLOR).
ShaderSetting & set_point_scale_metric()
Set point size scale to metric.
ShaderSetting & set_color(float r, float g, float b, float a)
Set material color (FLAT_COLOR).
ShaderSetting & rotate(const Eigen::Quaternion< Scalar > &quat)
Apply rotation to the model matrix.
Definition shader_setting.hpp:458
ShaderSetting & set_colormap_range(const Eigen::Vector2f &minmax)
Set VERTEX_COLORMAP color range.
ShaderSetting & rotate(const float angle, const Vector &axis)
Apply rotation to the model matrix.
Definition shader_setting.hpp:449
ShaderSetting()
Default constructor.
Eigen::Matrix3f rotation() const
Get rotation matrix from the model matrix.
ShaderSetting & set_point_shape_mode(guik::PointShapeMode::MODE mode)
Set point shape mode.
int color_mode() const
Get color mode.
std::shared_ptr< ShaderSetting > Ptr
Definition shader_setting.hpp:189
ShaderSetting & set_point_scale(float scaling)
Set point size scale factor.
float point_scale() const
Get point size scale factor.
void set(glk::GLSLShader &shader) const
Set shader parameters to the shader program.
ShaderSetting(const ShaderSetting &other)
Copy constructor.
T cast(const std::string &name_) const
Get a parameter value from the shader setting. This method avoid type checking. Fast but unsafe.
Definition shader_setting.hpp:295
ShaderSetting & rotate(const float angle, const Eigen::Vector3f &axis)
Apply rotation to the model matrix.
ShaderSetting & rotate(const Eigen::Matrix< Scalar, Dim, Dim > &rot)
Apply rotation to the model matrix.
Definition shader_setting.hpp:466
float point_size() const
Get point size.
ShaderSetting(int color_mode, const Eigen::Matrix4f &transform)
Constructor.
bool transparent
If true, the object is rendered as transparent.
Definition shader_setting.hpp:494
ShaderSetting & scale(float sx, float sy, float sz)
Apply scaling to the model matrix (non-uniform).
ShaderSetting & set_point_shape_circle()
Set point shape to circle.
std::vector< ShaderParameter > params
Shader parameters.
Definition shader_setting.hpp:495
std::optional< T > get(const std::string &name_)
Get a parameter value from the shader setting.
Definition shader_setting.hpp:249
TextureColor(const Transform &transform)
Definition shader_setting.hpp:666
virtual ~TextureColor() override
Definition shader_setting.hpp:668
TextureColor()
Definition shader_setting.hpp:663
virtual ~VertexColorMap() override
Definition shader_setting.hpp:679
VertexColorMap()
Definition shader_setting.hpp:674
VertexColorMap(const Transform &transform)
Definition shader_setting.hpp:677
VertexColor(const Transform &transform)
Definition shader_setting.hpp:655
virtual ~VertexColor() override
Definition shader_setting.hpp:657
VertexColor()
Definition shader_setting.hpp:652