Converting codebase to SOL3

Signed-off-by: Hartmut Seichter <hartmut@technotecture.com>

src/binding/src/script_core.cpp

@@ -17,6 +17,7 @@
 namespace sol {
 template <> struct is_automagical<pw::matrix4x4> : std::false_type {};
 template <> struct is_automagical<pw::vector3> : std::false_type {};
+template <> struct is_automagical<pw::vector2> : std::false_type {};
 template <> struct is_automagical<pw::vector4> : std::false_type {};
 template <> struct is_automagical<pw::quaternion> : std::false_type {};
 template <> struct is_automagical<pw::rectangle> : std::false_type {};
@@ -24,22 +25,22 @@ template <> struct is_automagical<pw::rectangle> : std::false_type {};
 
 namespace pw {
 
-
+vector3 table_to_vector3(sol::table t)
-rectangle from_lua_table(sol::table t)
 {
-    float v[4];
+    return vector3(t[0],t[1],t[2]);
-
-    for (std::size_t i {1}; i <= t.size();i++){
-        v[i-1] = t[i];
-    }
-    return rectangle(v);
 }
 
-vector3 vector3_from_lua_table(sol::table t)
+template <typename elementType>
+std::vector<elementType> convert_sequence(sol::table t)
 {
-
+    const std::size_t sz = t.size();
-    return vector3();
+    std::vector<elementType> res(sz);
+    for (std::size_t i = 1; i <= sz; i++) {
+        res[i - 1] = t[i];
     }
+    return res;
+}
+
 
 
 void register_core_function(sol::state& lua,sol::table& ns)
@@ -51,16 +52,25 @@ void register_core_function(sol::state& lua,sol::table& ns)
 
 
     ns.new_usertype<matrix4x4>("matrix4x4"
-                               , sol::constructors<matrix4x4()>()
+                               , sol::call_constructor,sol::constructors<matrix4x4()>()
                                , "row",&matrix4x4::row
                                , "column",&matrix4x4::column
                                , "set_identity",&matrix4x4::set_identity
                                , "inverse",&matrix4x4::inverse
-                               , "identity", &matrix4x4::identity
+                               , "identity",sol::readonly_property(matrix4x4::identity)
+                               //                               , "set",[](sol::this_state s,sol::table t) { for (int i = 0;i < t.size();i++) s.Ldata[i] = t[i-1]; })
+                               //                               , "get",[]() ->sol::table { return sol::table(); }
+
+                               );
+
+    ns.new_usertype<vector2>("vector2"
+                            ,sol::call_constructor,sol::constructors<vector2(),vector2(Scalar,Scalar)>()
+                             ,"x", sol::property(sol::resolve<const vector2::value_type&() const>(&vector2::x), [](vector2& v,vector2::value_type val){ v.x() = val;})
+            ,"y", sol::property(sol::resolve<const vector2::value_type&() const>(&vector2::y), [](vector2& v,vector2::value_type val){ v.y() = val;})
     );
 
     ns.new_usertype<vector3>("vector3"
-                            ,sol::constructors<vector3(),vector3(Scalar,Scalar,Scalar)>()
+                            ,sol::call_constructor,sol::constructors<vector3(),vector3(Scalar,Scalar,Scalar)>()
                             ,"x", sol::property(sol::resolve<const vector3::value_type&() const>(&vector3::x), [](vector3& v,vector3::value_type val){ v.x() = val;})
                             ,"y", sol::property(sol::resolve<const vector3::value_type&() const>(&vector3::y), [](vector3& v,vector3::value_type val){ v.y() = val;})
                             ,"z", sol::property(sol::resolve<const vector3::value_type&() const>(&vector3::z), [](vector3& v,vector3::value_type val){ v.z() = val;})
@@ -79,7 +89,7 @@ void register_core_function(sol::state& lua,sol::table& ns)
                             );
 
     ns.new_usertype<vector4>("vector4"
-                             ,sol::constructors<vector4(),vector4(vector4::value_type,vector4::value_type,vector4::value_type,vector4::value_type)>()
+                             ,sol::call_constructor,sol::constructors<vector4(),vector4(vector4::value_type,vector4::value_type,vector4::value_type,vector4::value_type)>()
                              ,"x", sol::property(sol::resolve<const vector4::value_type&() const>(&vector4::x), [](vector4& v,vector4::value_type val){ v.x() = val;})
             ,"y", sol::property(sol::resolve<const vector4::value_type&() const>(&vector4::y), [](vector4& v,vector4::value_type val){ v.y() = val;})
     ,"z", sol::property(sol::resolve<const vector4::value_type&() const>(&vector4::z), [](vector4& v,vector4::value_type val){ v.z() = val;})
@@ -121,7 +131,7 @@ void register_core_function(sol::state& lua,sol::table& ns)
                           );
 
     ns.new_usertype<sizef>("sizef"
-                          , sol::constructors<sizef(),sizef(Scalar,Scalar)>()
+                          , sol::call_constructor, sol::constructors<sizef(),sizef(Scalar,Scalar)>()
                            , "width",&sizef::width
                            , "height",&sizef::height
                            , "cast_to_int",&sizef::cast<int>
@@ -151,8 +161,10 @@ void register_core_function(sol::state& lua,sol::table& ns)
     ns.new_usertype<geometry>("geometry"
                               , sol::constructors<geometry(),geometry(geometry::primitive_topology_type,vector3_array,geometry::indices_t)>()
                               , "primitive_topology", sol::property(&geometry::primitive_topology,&geometry::set_primitive_topology)
-                              , "vertices", sol::property(&geometry::vertices,&geometry::set_vertices)
+                              , "vertices", sol::property(&geometry::ref_vertices,&geometry::ref_vertices)
-                              , "indices", sol::property(&geometry::indices,&geometry::set_indices)
+                              , "indices", sol::property(&geometry::ref_indices,&geometry::ref_indices)
+                              , "add_texture_coordinates",&geometry::add_texture_coordinates
+                              //                              , "texture_coordinates",&geometry::texture_coordinates
                               , "compute_normals", &geometry::compute_normals);
 
     ns.new_enum<false>("primitive_topology_type"
@@ -182,7 +194,7 @@ void register_core_function(sol::state& lua,sol::table& ns)
                                              ,"change_count",sol::property(&image::change_count,&image::set_change_count)
                                              );
 
-    image_type.create_named("pixel_layout"
+    ns.create_named("pixel_layout"
                     ,"rgb8", image::RGB8
                     ,"rgb32", image::RGBA8
                     ,"gray", image::LUM

src/binding/src/script_visual.cpp

@@ -13,7 +13,7 @@
 
 namespace pw {
 
-void register_visual_function(sol::state&,sol::table &ns)
+void register_visual_function(sol::state& lua,sol::table &ns)
 {
 
     ns.new_usertype<pipeline>("pipeline"
@@ -36,16 +36,21 @@ void register_visual_function(sol::state&,sol::table &ns)
                             ,"set_uniform_vec4",&shader::set_uniform<vector4&>
                             ,"set_uniform_texture",&shader::set_uniform<texture&>
 
-                            ).new_enum<false>("shader_type"
+                            );
+
+
+    ns["shader_type"] = ns.create_named("shader_type"
                                        ,"fragment",shader::code_type::fragment
                                         ,"vertex",shader::code_type::vertex
                                         ,"geometry",shader::code_type::geometry
                                         ,"compute",shader::code_type::compute);
 
+//    new_enum<false>(
 
-    ns.new_usertype<render_pass>("render_pass"
+
-                                ,"submit",&render_pass::submit
+//    ns.new_usertype<render_pass>("render_pass"
-                                 );
+//                                ,"submit",&render_pass::submit
+//                                 );
 
 
     ns.new_usertype<renderer>("renderer"

src/core/include/pw/core/geometry.hpp

@@ -65,12 +65,20 @@ public:
     void set_vertices(vector3_array v);
     const vector3_array& vertices() const { return _vertices; }
 
+    vector3_array& ref_vertices() { return _vertices;}
+
     void set_indices(indices_t v);
     const indices_t& indices() const;
 
+    indices_t& ref_indices() { return _indices; }
+
     void set_normals(vector3_array v);
     const vector3_array& normals() const;
 
+    void add_texture_coordinates(vector2_array v);
+    const std::vector<vector2_array>& texture_coordinates() const { return _texture_coords;}
+
+
     void transform(const matrix4x4& m);
 
     void compute_normals();
@@ -90,7 +98,7 @@ protected:
     vector3_array _tangents;   //!< tangent data
     vector3_array _bitangents; //!< bitangent
 
-    std::vector<vector3_array> _texture_coords; //! texture coordinates
+    std::vector<vector2_array> _texture_coords; //! texture coordinates
 
     uint64_t _change_count { 0 };
 };

src/core/src/geometry.cpp

@@ -102,6 +102,13 @@ void geometry::set_normals(vector3_array v)
 
 const vector3_array &geometry::normals() const { return _normals; }
 
+
+void geometry::add_texture_coordinates(vector2_array v)
+{
+    _texture_coords.push_back(v);
+}
+
+
 //void geometry::set_vertices(const geometry::vertex3array_t &v)
 //{
 //    // first set vertices

src/scripts/demos/simple_003.lua

@@ -5,8 +5,8 @@
 -- we need everything
 pw.script:load_all()
 
-print(pw.path.get().executable_path)
+print("executable path:",pw.path.get().executable_path)
-print(pw.path.get().resource_path)
+print("resource path:",pw.path.get().resource_path)
 
 local img = pw.image.new()
 if not img:create(pw.size(64,64),pw.pixel_layout.rgb8) then
@@ -31,20 +31,27 @@ w.position = pw.point.new(100,100)
 -- create a new geometry
 local g = pw.geometry:new()
 
+
+-- create texture coordinates
+local tc = { pw.vector2(1.0,1.0),
+             pw.vector2(1.0,0.0),
+             pw.vector2(0.0,1.0),
+             pw.vector2(0.0,0.0) }
+
+g:add_texture_coordinates(tc)
+
+--print(g)
+
 g.primitive_topology = pw.primitive_topology_type.triangle_list -- meh
 
 z = -5.0
 s = 1
 
 -- geometry can only build with indexed facesets
-g.vertices:add(pw.vector3:new(-s, s, z)) -- 0
+g.vertices:add(pw.vector3(-s, s, z)) -- 0
-g.vertices:add(pw.vector3:new(-s,-s, z)) -- 1
+g.vertices:add(pw.vector3(-s,-s, z)) -- 1
-g.vertices:add(pw.vector3:new( s,-s, z)) -- 2
+g.vertices:add(pw.vector3( s,-s, z)) -- 2
-g.vertices:add(pw.vector3:new( s, s, z)) -- 3
+g.vertices:add(pw.vector3( s, s, z)) -- 3
-
--- 0 --- 3
--- |  \  |
--- 1 --- 2
 
 g.indices:add(0)
 g.indices:add(1)
@@ -55,9 +62,25 @@ g.indices:add(3)
 g.indices:add(0)
 
 
-local mm = pw.matrix4x4:new()
+print(#g.vertices,g.vertices,g.vertices[1].x,g.vertices[1].y,g.vertices[1].z)
-local mv = pw.matrix4x4:new()
+--print(g.vertices[1])
-local mp = pw.matrix4x4:new()
+
+local v3 = pw.vector3()
+
+print(g.indices,#g.indices)
+print(g.vertices,#g.vertices)
+
+--os.exit()
+
+-- 0 --- 3
+-- |  \  |
+-- 1 --- 2
+
+
+
+local mm = pw.matrix4x4.identity
+local mv = pw.matrix4x4()
+local mp = pw.matrix4x4()
 
 local s = pw.shader:new()
 
@@ -82,7 +105,7 @@ uniform sampler2D tex_color;
 out vec4 frag_color;
 
 void main() {
-    frag_color = texture(tex_color,vec2(1.0,1.0));
+    frag_color = color * texture(tex_color,vec2(1.0,1.0));
 }
 ]])
 
@@ -100,9 +123,9 @@ if not renderer:create(g) then
 end
 
 -- camera position
-local cam_pos = pw.vector3:new(0,0,0)
+local cam_pos = pw.vector3(0,0,0)
 
-local model_pos = pw.vector3:new(0,0,0)
+local model_pos = pw.vector3(0,0,0)
 
 
 local ctx = pw.context:new()
@@ -119,9 +142,6 @@ end
 -- setup a lua callback function as callback
 w.on_update = function(self)
 
-    -- set identity on model matrix
-    mm:set_identity()
-
     -- set view matrix with look_at - view matrix is moving the world - hence inverse!
     mv = pw.matrixtransform.look_at(cam_pos,cam_pos + pw.vector3.forward(),pw.vector3.up()):inverse()
 
@@ -135,21 +155,14 @@ w.on_update = function(self)
     local color_red  = pw.mathf.ping_pong(pw.time.now,1.0)
     local color_green = pw.mathf.ping_pong(pw.time.now + 1,1.0)
     local color_blue = 1.0 - pw.mathf.ping_pong(pw.time.now,1.0)
-    local cl = pw.vector4:new( color_red, color_green, color_blue, 1.0 )
+    local cl = pw.vector4( color_red, color_green, color_blue, 1.0 )
 
     img:generate_noise()
-
     tx:update(img)
 
-
---    print(img.change_count)
-
     -- bind the shader
     s:use()
 
-
-
-
     -- update the uniforms, currently the slow path
     s:set_uniform_mat4("model",mm)