17345118961

Committed 30 Aug 2025 02:47PM UTC coverage: 74.197% (-0.1%) from 74.324%

Build # 17345118961

Build Type

push

github

Committed by

Razakhel

Commit Message

[CI] Changed the used Ubuntu & macOS images

- Bumped Ubuntu to 24.04, making available GCC 13.3.0 (previously 11.4.4) & Clang 18.1.3 (previously 14.0.0)

- Forced macOS to 15, making available Apple Clang 17.0 (previously 15.0)

Run Details

8319 of 11212 relevant lines covered (74.2%)

1740.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.55

/src/RaZ/Script/LuaShaderProgram.cpp

#include "RaZ/Render/ShaderProgram.hpp"
#include "RaZ/Script/LuaWrapper.hpp"
#include "RaZ/Utils/TypeUtils.hpp"

#define SOL_ALL_SAFETIES_ON 1
#include "sol/sol.hpp"

namespace Raz {

using namespace TypeUtils;

void LuaWrapper::registerShaderProgramTypes() {
  sol::state& state = getState();

#if !defined(USE_WEBGL)
  {
    sol::usertype<ComputeShaderProgram> computeShaderProgram = state.new_usertype<ComputeShaderProgram>("ComputeShaderProgram",
                                                                                                        sol::constructors<ComputeShaderProgram()>(),
                                                                                                        sol::base_classes, sol::bases<ShaderProgram>());
    computeShaderProgram["getShader"]     = [] (const ComputeShaderProgram& p) { return &p.getShader(); };
    computeShaderProgram["setShader"]     = [] (ComputeShaderProgram& p, ComputeShader& s) { p.setShader(std::move(s)); };
    computeShaderProgram["clone"]         = &ComputeShaderProgram::clone;
    computeShaderProgram["execute"]       = sol::overload([] (const ComputeShaderProgram& p, unsigned int x) { p.execute(x); },
                                                          [] (const ComputeShaderProgram& p, unsigned int x, unsigned int y) { p.execute(x, y); },
                                                          PickOverload<unsigned int, unsigned int, unsigned int>(&ComputeShaderProgram::execute));
    computeShaderProgram["destroyShader"] = &ComputeShaderProgram::destroyShader;
  }
#endif

  {
    sol::usertype<RenderShaderProgram> renderShaderProgram = state.new_usertype<RenderShaderProgram>("RenderShaderProgram",
                                                                                                     sol::constructors<RenderShaderProgram()>(),
                                                                                                     sol::base_classes, sol::bases<ShaderProgram>());
    renderShaderProgram["getVertexShader"]                     = [] (const RenderShaderProgram& p) { return &p.getVertexShader(); };
#if !defined(USE_OPENGL_ES)
    renderShaderProgram["hasTessellationControlShader"]        = &RenderShaderProgram::hasTessellationControlShader;
    renderShaderProgram["getTessellationControlShader"]        = [] (const RenderShaderProgram& p) { return &p.getTessellationControlShader(); };
    renderShaderProgram["hasTessellationEvaluationShader"]     = &RenderShaderProgram::hasTessellationEvaluationShader;
    renderShaderProgram["getTessellationEvaluationShader"]     = [] (const RenderShaderProgram& p) { return &p.getTessellationEvaluationShader(); };
    renderShaderProgram["hasGeometryShader"]                   = &RenderShaderProgram::hasGeometryShader;
    renderShaderProgram["getGeometryShader"]                   = [] (const RenderShaderProgram& p) { return &p.getGeometryShader(); };
#endif
    renderShaderProgram["getFragmentShader"]                   = [] (const RenderShaderProgram& p) { return &p.getFragmentShader(); };
    renderShaderProgram["setVertexShader"]                     = [] (RenderShaderProgram& p, VertexShader& s) { p.setVertexShader(std::move(s)); };
#if !defined(USE_OPENGL_ES)
    renderShaderProgram["setTessellationControlShader"]        = [] (RenderShaderProgram& p,
                                                                     TessellationControlShader& s) { p.setTessellationControlShader(std::move(s)); };
    renderShaderProgram["setTessellationEvaluationShader"]     = [] (RenderShaderProgram& p,
                                                                     TessellationEvaluationShader& s) { p.setTessellationEvaluationShader(std::move(s)); };
    renderShaderProgram["setGeometryShader"]                   = [] (RenderShaderProgram& p, GeometryShader& s) { p.setGeometryShader(std::move(s)); };
#endif
    renderShaderProgram["setFragmentShader"]                   = [] (RenderShaderProgram& p, FragmentShader& s) { p.setFragmentShader(std::move(s)); };
    renderShaderProgram["setShaders"]                          = sol::overload([] (RenderShaderProgram& p, VertexShader& v,
                                                                                   FragmentShader& f) { p.setShaders(std::move(v), std::move(f)); }
#if !defined(USE_OPENGL_ES)
                                                                               ,
                                                                               [] (RenderShaderProgram& p, VertexShader& v, GeometryShader& g,
                                                                                   FragmentShader& f) { p.setShaders(std::move(v), std::move(g),
                                                                                                                     std::move(f)); },
                                                                               [] (RenderShaderProgram& p, VertexShader& v, TessellationEvaluationShader& te,
                                                                                   FragmentShader& f) { p.setShaders(std::move(v), std::move(te),
                                                                                                                     std::move(f)); },
                                                                               [] (RenderShaderProgram& p, VertexShader& v, TessellationControlShader& tc,
                                                                                   TessellationEvaluationShader& te,
                                                                                   FragmentShader& f) { p.setShaders(std::move(v), std::move(tc),
                                                                                                                     std::move(te), std::move(f)); }
#endif
                                                                               );
    renderShaderProgram["clone"]                               = &RenderShaderProgram::clone;
    renderShaderProgram["destroyVertexShader"]                 = &RenderShaderProgram::destroyVertexShader;
#if !defined(USE_OPENGL_ES)
    renderShaderProgram["destroyTessellationControlShader"]    = &RenderShaderProgram::destroyTessellationControlShader;
    renderShaderProgram["destroyTessellationEvaluationShader"] = &RenderShaderProgram::destroyTessellationEvaluationShader;
    renderShaderProgram["destroyGeometryShader"]               = &RenderShaderProgram::destroyGeometryShader;
#endif
    renderShaderProgram["destroyFragmentShader"]               = &RenderShaderProgram::destroyFragmentShader;
  }

  {
    sol::table imageTextureUsage    = state["ImageTextureUsage"].get_or_create<sol::table>();
    imageTextureUsage["READ"]       = ImageTextureUsage::READ;
    imageTextureUsage["WRITE"]      = ImageTextureUsage::WRITE;
    imageTextureUsage["READ_WRITE"] = ImageTextureUsage::READ_WRITE;

    sol::usertype<ShaderProgram> shaderProgram = state.new_usertype<ShaderProgram>("ShaderProgram", sol::no_constructor);
    shaderProgram["hasAttribute"]           = [] (const ShaderProgram& p, const std::string& n) { return p.hasAttribute(n); };
    shaderProgram["getAttributeCount"]      = &ShaderProgram::getAttributeCount;
    shaderProgram["hasTexture"]             = sol::overload(PickOverload<const Texture&>(&ShaderProgram::hasTexture),
                                                            PickOverload<const std::string&>(&ShaderProgram::hasTexture));
    shaderProgram["getTextureCount"]        = &ShaderProgram::getTextureCount;
    shaderProgram["getTexture"]             = sol::overload([] (const ShaderProgram& p, std::size_t i) { return &p.getTexture(i); },
                                                            [] (const ShaderProgram& p, const std::string& n) { return &p.getTexture(n); });
#if !defined(USE_WEBGL)
    shaderProgram["hasImageTexture"]        = sol::overload(PickOverload<const Texture&>(&ShaderProgram::hasImageTexture),
                                                            PickOverload<const std::string&>(&ShaderProgram::hasImageTexture));
    shaderProgram["getImageTextureCount"]   = &ShaderProgram::getImageTextureCount;
    shaderProgram["getImageTexture"]        = sol::overload([] (const ShaderProgram& p, std::size_t i) { return &p.getImageTexture(i); },
                                                            [] (const ShaderProgram& p, const std::string& n) { return &p.getImageTexture(n); });
#endif
    shaderProgram["setIntAttribute"]        = &ShaderProgram::setAttribute<int>;
    shaderProgram["setUintAttribute"]       = &ShaderProgram::setAttribute<unsigned int>;
    shaderProgram["setFloatAttribute"]      = &ShaderProgram::setAttribute<float>;
    shaderProgram["setAttribute"]           = sol::overload(&ShaderProgram::setAttribute<const Vec2i&>,
                                                            &ShaderProgram::setAttribute<const Vec3i&>,
                                                            &ShaderProgram::setAttribute<const Vec4i&>,
                                                            &ShaderProgram::setAttribute<const Vec2u&>,
                                                            &ShaderProgram::setAttribute<const Vec3u&>,
                                                            &ShaderProgram::setAttribute<const Vec4u&>,
                                                            &ShaderProgram::setAttribute<const Vec2f&>,
                                                            &ShaderProgram::setAttribute<const Vec3f&>,
                                                            &ShaderProgram::setAttribute<const Vec4f&>,
                                                            &ShaderProgram::setAttribute<const Mat2f&>,
                                                            &ShaderProgram::setAttribute<const Mat3f&>,
                                                            &ShaderProgram::setAttribute<const Mat4f&>);
    // Sol does not seem to be able to bind shared pointers from derived classes to a shared pointer of the base class
    //   (e.g., Texture2DPtr cannot be given directly to setTexture(), which takes a TexturePtr)
    shaderProgram["setTexture"]             = sol::overload(
#if !defined(USE_OPENGL_ES)
                                                            [] (ShaderProgram& p, Texture1DPtr t, const std::string& n) { p.setTexture(std::move(t), n); },
#endif
                                                            [] (ShaderProgram& p, Texture2DPtr t, const std::string& n) { p.setTexture(std::move(t), n); },
                                                            [] (ShaderProgram& p, Texture3DPtr t, const std::string& n) { p.setTexture(std::move(t), n); });
#if !defined(USE_WEBGL)
    shaderProgram["setImageTexture"]        = sol::overload(
#if !defined(USE_OPENGL_ES)
                                                            [] (ShaderProgram& p, Texture1DPtr t,
                                                                const std::string& n) { p.setImageTexture(std::move(t), n, ImageTextureUsage::READ_WRITE); },
                                                            [] (ShaderProgram& p, Texture1DPtr t, const std::string& n,
                                                                ImageTextureUsage u) { p.setImageTexture(std::move(t), n, u); },
#endif
                                                            [] (ShaderProgram& p, Texture2DPtr t,
                                                                const std::string& n) { p.setImageTexture(std::move(t), n, ImageTextureUsage::READ_WRITE); },
                                                            [] (ShaderProgram& p, Texture2DPtr t, const std::string& n,
                                                                ImageTextureUsage u) { p.setImageTexture(std::move(t), n, u); },
                                                            [] (ShaderProgram& p, Texture3DPtr t,
                                                                const std::string& n) { p.setImageTexture(std::move(t), n, ImageTextureUsage::READ_WRITE); },
                                                            [] (ShaderProgram& p, Texture3DPtr t, const std::string& n,
                                                                ImageTextureUsage u) { p.setImageTexture(std::move(t), n, u); });
#endif
    shaderProgram["loadShaders"]            = &ShaderProgram::loadShaders;
    shaderProgram["compileShaders"]         = &ShaderProgram::compileShaders;
    shaderProgram["link"]                   = &ShaderProgram::link;
    shaderProgram["isLinked"]               = &ShaderProgram::isLinked;
    shaderProgram["updateShaders"]          = &ShaderProgram::updateShaders;
    shaderProgram["use"]                    = &ShaderProgram::use;
    shaderProgram["isUsed"]                 = &ShaderProgram::isUsed;
    shaderProgram["sendAttributes"]         = &ShaderProgram::sendAttributes;
    shaderProgram["removeAttribute"]        = &ShaderProgram::removeAttribute;
    shaderProgram["clearAttributes"]        = &ShaderProgram::clearAttributes;
    shaderProgram["initTextures"]           = &ShaderProgram::initTextures;
    shaderProgram["bindTextures"]           = &ShaderProgram::bindTextures;
    shaderProgram["removeTexture"]          = sol::overload(PickOverload<const Texture&>(&ShaderProgram::removeTexture),
                                                            PickOverload<const std::string&>(&ShaderProgram::removeTexture));
    shaderProgram["clearTextures"]          = &ShaderProgram::clearTextures;
#if !defined(USE_WEBGL)
    shaderProgram["initImageTextures"]      = &ShaderProgram::initImageTextures;
    shaderProgram["bindImageTextures"]      = &ShaderProgram::bindImageTextures;
    shaderProgram["removeImageTexture"]     = sol::overload(PickOverload<const Texture&>(&ShaderProgram::removeImageTexture),
                                                            PickOverload<const std::string&>(&ShaderProgram::removeImageTexture));
    shaderProgram["clearImageTextures"]     = &ShaderProgram::clearImageTextures;
#endif
    shaderProgram["recoverUniformLocation"] = &ShaderProgram::recoverUniformLocation;
  }
}

} // namespace Raz

1	#include "RaZ/Render/ShaderProgram.hpp"
2	#include "RaZ/Script/LuaWrapper.hpp"
3	#include "RaZ/Utils/TypeUtils.hpp"
4
5	#define SOL_ALL_SAFETIES_ON 1
6	#include "sol/sol.hpp"
7
8	namespace Raz {
9
10	using namespace TypeUtils;
11
12	void LuaWrapper::registerShaderProgramTypes() {	2✔
13	sol::state& state = getState();	2✔
14
15	#if !defined(USE_WEBGL)
16	{
17	sol::usertype<ComputeShaderProgram> computeShaderProgram = state.new_usertype<ComputeShaderProgram>("ComputeShaderProgram",
18	sol::constructors<ComputeShaderProgram()>(),	×
19	sol::base_classes, sol::bases<ShaderProgram>());	2✔
20	computeShaderProgram["getShader"] = [] (const ComputeShaderProgram& p) { return &p.getShader(); };	3✔
21	computeShaderProgram["setShader"] = [] (ComputeShaderProgram& p, ComputeShader& s) { p.setShader(std::move(s)); };	3✔
22	computeShaderProgram["clone"] = &ComputeShaderProgram::clone;	2✔
23	computeShaderProgram["execute"] = sol::overload([] (const ComputeShaderProgram& p, unsigned int x) { p.execute(x); },	3✔
24	[] (const ComputeShaderProgram& p, unsigned int x, unsigned int y) { p.execute(x, y); },	1✔
25	PickOverload<unsigned int, unsigned int, unsigned int>(&ComputeShaderProgram::execute));	4✔
26	computeShaderProgram["destroyShader"] = &ComputeShaderProgram::destroyShader;	2✔
27	}	2✔
28	#endif
29
30	{
31	sol::usertype<RenderShaderProgram> renderShaderProgram = state.new_usertype<RenderShaderProgram>("RenderShaderProgram",
32	sol::constructors<RenderShaderProgram()>(),	×
33	sol::base_classes, sol::bases<ShaderProgram>());	2✔
34	renderShaderProgram["getVertexShader"] = [] (const RenderShaderProgram& p) { return &p.getVertexShader(); };	3✔
35	#if !defined(USE_OPENGL_ES)
36	renderShaderProgram["hasTessellationControlShader"] = &RenderShaderProgram::hasTessellationControlShader;	2✔
37	renderShaderProgram["getTessellationControlShader"] = [] (const RenderShaderProgram& p) { return &p.getTessellationControlShader(); };	3✔
38	renderShaderProgram["hasTessellationEvaluationShader"] = &RenderShaderProgram::hasTessellationEvaluationShader;	2✔
39	renderShaderProgram["getTessellationEvaluationShader"] = [] (const RenderShaderProgram& p) { return &p.getTessellationEvaluationShader(); };	3✔
40	renderShaderProgram["hasGeometryShader"] = &RenderShaderProgram::hasGeometryShader;	2✔
41	renderShaderProgram["getGeometryShader"] = [] (const RenderShaderProgram& p) { return &p.getGeometryShader(); };	3✔
42	#endif
43	renderShaderProgram["getFragmentShader"] = [] (const RenderShaderProgram& p) { return &p.getFragmentShader(); };	3✔
44	renderShaderProgram["setVertexShader"] = [] (RenderShaderProgram& p, VertexShader& s) { p.setVertexShader(std::move(s)); };	3✔
45	#if !defined(USE_OPENGL_ES)
46	renderShaderProgram["setTessellationControlShader"] = [] (RenderShaderProgram& p,	×
47	TessellationControlShader& s) { p.setTessellationControlShader(std::move(s)); };	3✔
48	renderShaderProgram["setTessellationEvaluationShader"] = [] (RenderShaderProgram& p,	×
49	TessellationEvaluationShader& s) { p.setTessellationEvaluationShader(std::move(s)); };	3✔
50	renderShaderProgram["setGeometryShader"] = [] (RenderShaderProgram& p, GeometryShader& s) { p.setGeometryShader(std::move(s)); };	3✔
51	#endif
52	renderShaderProgram["setFragmentShader"] = [] (RenderShaderProgram& p, FragmentShader& s) { p.setFragmentShader(std::move(s)); };	3✔
53	renderShaderProgram["setShaders"] = sol::overload([] (RenderShaderProgram& p, VertexShader& v,	2✔
54	FragmentShader& f) { p.setShaders(std::move(v), std::move(f)); }	1✔
55	#if !defined(USE_OPENGL_ES)
56	,
57	[] (RenderShaderProgram& p, VertexShader& v, GeometryShader& g,	×
58	FragmentShader& f) { p.setShaders(std::move(v), std::move(g),	1✔
59	std::move(f)); },	1✔
60	[] (RenderShaderProgram& p, VertexShader& v, TessellationEvaluationShader& te,	×
61	FragmentShader& f) { p.setShaders(std::move(v), std::move(te),	1✔
62	std::move(f)); },	1✔
63	[] (RenderShaderProgram& p, VertexShader& v, TessellationControlShader& tc,	×
64	TessellationEvaluationShader& te,
65	FragmentShader& f) { p.setShaders(std::move(v), std::move(tc),	1✔
66	std::move(te), std::move(f)); }	1✔
67	#endif
68	);	2✔
69	renderShaderProgram["clone"] = &RenderShaderProgram::clone;	2✔
70	renderShaderProgram["destroyVertexShader"] = &RenderShaderProgram::destroyVertexShader;	2✔
71	#if !defined(USE_OPENGL_ES)
72	renderShaderProgram["destroyTessellationControlShader"] = &RenderShaderProgram::destroyTessellationControlShader;	2✔
73	renderShaderProgram["destroyTessellationEvaluationShader"] = &RenderShaderProgram::destroyTessellationEvaluationShader;	2✔
74	renderShaderProgram["destroyGeometryShader"] = &RenderShaderProgram::destroyGeometryShader;	2✔
75	#endif
76	renderShaderProgram["destroyFragmentShader"] = &RenderShaderProgram::destroyFragmentShader;	2✔
77	}	2✔
78
79	{
80	sol::table imageTextureUsage = state["ImageTextureUsage"].get_or_create<sol::table>();	2✔
81	imageTextureUsage["READ"] = ImageTextureUsage::READ;	2✔
82	imageTextureUsage["WRITE"] = ImageTextureUsage::WRITE;	2✔
83	imageTextureUsage["READ_WRITE"] = ImageTextureUsage::READ_WRITE;	2✔
84
85	sol::usertype<ShaderProgram> shaderProgram = state.new_usertype<ShaderProgram>("ShaderProgram", sol::no_constructor);	2✔
86	shaderProgram["hasAttribute"] = [] (const ShaderProgram& p, const std::string& n) { return p.hasAttribute(n); };	10✔
87	shaderProgram["getAttributeCount"] = &ShaderProgram::getAttributeCount;	2✔
88	shaderProgram["hasTexture"] = sol::overload(PickOverload<const Texture&>(&ShaderProgram::hasTexture),	2✔
89	PickOverload<const std::string&>(&ShaderProgram::hasTexture));	4✔
90	shaderProgram["getTextureCount"] = &ShaderProgram::getTextureCount;	2✔
91	shaderProgram["getTexture"] = sol::overload([] (const ShaderProgram& p, std::size_t i) { return &p.getTexture(i); },	5✔
92	[] (const ShaderProgram& p, const std::string& n) { return &p.getTexture(n); });	5✔
93	#if !defined(USE_WEBGL)
94	shaderProgram["hasImageTexture"] = sol::overload(PickOverload<const Texture&>(&ShaderProgram::hasImageTexture),	2✔
95	PickOverload<const std::string&>(&ShaderProgram::hasImageTexture));	4✔
96	shaderProgram["getImageTextureCount"] = &ShaderProgram::getImageTextureCount;	2✔
97	shaderProgram["getImageTexture"] = sol::overload([] (const ShaderProgram& p, std::size_t i) { return &p.getImageTexture(i); },	3✔
98	[] (const ShaderProgram& p, const std::string& n) { return &p.getImageTexture(n); });	3✔
99	#endif
100	shaderProgram["setIntAttribute"] = &ShaderProgram::setAttribute<int>;	2✔
101	shaderProgram["setUintAttribute"] = &ShaderProgram::setAttribute<unsigned int>;	2✔
102	shaderProgram["setFloatAttribute"] = &ShaderProgram::setAttribute<float>;	2✔
103	shaderProgram["setAttribute"] = sol::overload(&ShaderProgram::setAttribute<const Vec2i&>,	2✔
104	&ShaderProgram::setAttribute<const Vec3i&>,
105	&ShaderProgram::setAttribute<const Vec4i&>,
106	&ShaderProgram::setAttribute<const Vec2u&>,
107	&ShaderProgram::setAttribute<const Vec3u&>,
108	&ShaderProgram::setAttribute<const Vec4u&>,
109	&ShaderProgram::setAttribute<const Vec2f&>,
110	&ShaderProgram::setAttribute<const Vec3f&>,
111	&ShaderProgram::setAttribute<const Vec4f&>,
112	&ShaderProgram::setAttribute<const Mat2f&>,
113	&ShaderProgram::setAttribute<const Mat3f&>,
114	&ShaderProgram::setAttribute<const Mat4f&>);	2✔
115	// Sol does not seem to be able to bind shared pointers from derived classes to a shared pointer of the base class
116	// (e.g., Texture2DPtr cannot be given directly to setTexture(), which takes a TexturePtr)
117	shaderProgram["setTexture"] = sol::overload(	2✔
118	#if !defined(USE_OPENGL_ES)
119	[] (ShaderProgram& p, Texture1DPtr t, const std::string& n) { p.setTexture(std::move(t), n); },	3✔
120	#endif
121	[] (ShaderProgram& p, Texture2DPtr t, const std::string& n) { p.setTexture(std::move(t), n); },	3✔
122	[] (ShaderProgram& p, Texture3DPtr t, const std::string& n) { p.setTexture(std::move(t), n); });	5✔
123	#if !defined(USE_WEBGL)
124	shaderProgram["setImageTexture"] = sol::overload(	2✔
125	#if !defined(USE_OPENGL_ES)
126	[] (ShaderProgram& p, Texture1DPtr t,	×
127	const std::string& n) { p.setImageTexture(std::move(t), n, ImageTextureUsage::READ_WRITE); },	×
128	[] (ShaderProgram& p, Texture1DPtr t, const std::string& n,	×
129	ImageTextureUsage u) { p.setImageTexture(std::move(t), n, u); },	×
130	#endif
131	[] (ShaderProgram& p, Texture2DPtr t,	×
132	const std::string& n) { p.setImageTexture(std::move(t), n, ImageTextureUsage::READ_WRITE); },	×
133	[] (ShaderProgram& p, Texture2DPtr t, const std::string& n,	×
134	ImageTextureUsage u) { p.setImageTexture(std::move(t), n, u); },	3✔
135	[] (ShaderProgram& p, Texture3DPtr t,	×
136	const std::string& n) { p.setImageTexture(std::move(t), n, ImageTextureUsage::READ_WRITE); },	×
137	[] (ShaderProgram& p, Texture3DPtr t, const std::string& n,	×
138	ImageTextureUsage u) { p.setImageTexture(std::move(t), n, u); });	2✔
139	#endif
140	shaderProgram["loadShaders"] = &ShaderProgram::loadShaders;	2✔
141	shaderProgram["compileShaders"] = &ShaderProgram::compileShaders;	2✔
142	shaderProgram["link"] = &ShaderProgram::link;	2✔
143	shaderProgram["isLinked"] = &ShaderProgram::isLinked;	2✔
144	shaderProgram["updateShaders"] = &ShaderProgram::updateShaders;	2✔
145	shaderProgram["use"] = &ShaderProgram::use;	2✔
146	shaderProgram["isUsed"] = &ShaderProgram::isUsed;	2✔
147	shaderProgram["sendAttributes"] = &ShaderProgram::sendAttributes;	2✔
148	shaderProgram["removeAttribute"] = &ShaderProgram::removeAttribute;	2✔
149	shaderProgram["clearAttributes"] = &ShaderProgram::clearAttributes;	2✔
150	shaderProgram["initTextures"] = &ShaderProgram::initTextures;	2✔
151	shaderProgram["bindTextures"] = &ShaderProgram::bindTextures;	2✔
152	shaderProgram["removeTexture"] = sol::overload(PickOverload<const Texture&>(&ShaderProgram::removeTexture),	2✔
153	PickOverload<const std::string&>(&ShaderProgram::removeTexture));	4✔
154	shaderProgram["clearTextures"] = &ShaderProgram::clearTextures;	2✔
155	#if !defined(USE_WEBGL)
156	shaderProgram["initImageTextures"] = &ShaderProgram::initImageTextures;	2✔
157	shaderProgram["bindImageTextures"] = &ShaderProgram::bindImageTextures;	2✔
158	shaderProgram["removeImageTexture"] = sol::overload(PickOverload<const Texture&>(&ShaderProgram::removeImageTexture),	2✔
159	PickOverload<const std::string&>(&ShaderProgram::removeImageTexture));	4✔
160	shaderProgram["clearImageTextures"] = &ShaderProgram::clearImageTextures;	2✔
161	#endif
162	shaderProgram["recoverUniformLocation"] = &ShaderProgram::recoverUniformLocation;	2✔
163	}	2✔
164	}	2✔
165
166	} // namespace Raz

Razakhel / RaZ / 17345118961

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous