intermediate state

src/core/include/pw/core/point.hpp

@@ -1,5 +1,5 @@
 #ifndef PW_CORE_POINT_HPP
-#define PW_CORE_SIZE_HPP
+#define PW_CORE_POINT_HPP
 
 #include <pw/core/globals.hpp>
 
@@ -8,13 +8,10 @@ namespace pw {
 template <typename T_>
 struct point_ {
 
-    T_ p[2] = { 0, 0 };
+	T_ x, y;
 
     point_() = default;
-    point_(T_ x,T_ y) : p( {x,y} ) {}
+	point_(T_ x_,T_ y_) : x(x_), y(y_) {}
-
-    const T_ x() { return p[0]; }
-    const T_ y() { return p[1]; }
 
 };
 

src/core/include/pw/core/size.hpp

@@ -33,14 +33,11 @@ namespace pw {
 template <typename T_>
 struct size_ {
 
-    T_ dim[2] = { 0, 0 };
+	T_ width,height;
 
     size_() = default;
 
-    size_(T_ w,T_ h) : dim( { w, h }) {}
+	size_(T_ w,T_ h) : width(w), height(h) {}
-
-	const T_ width() { return dim[0]; }
-	const T_ height() { return dim[1]; }
 
 };
 

src/core/include/pw/core/vector.hpp

@@ -192,16 +192,16 @@ typedef vector2_<long> vector2l;
 
 typedef vector2_<double> vector2d;
 typedef vector2_<float> vector2f;
+typedef vector2_<real_t> vector2;
 
-
+typedef vector3_<real_t> vector3;
-
-
 typedef vector3_<double> vector3d;
 typedef vector3_<float> vector3f;
 typedef vector3_<int> vector3i;
 typedef vector3_<unsigned int> vector3ui;
 
 
+typedef vector4_<real_t> vector4;
 typedef vector4_<double> vector4d;
 typedef vector4_<float> vector4f;
 typedef vector4_<int> vector4i;

src/scripting/src/script_core.cpp

@@ -4,6 +4,8 @@
 #include "pw/core/quaternion.hpp"
 #include "pw/core/axisangle.hpp"
 #include "pw/core/debug.hpp"
+#include "pw/core/size.hpp"
+#include "pw/core/point.hpp"
 
 
 namespace pw {
@@ -11,51 +13,68 @@ namespace pw {
 void script_core::load(sol::table &ns)
 {
 
-    typedef double Scalar;
+	typedef real_t Scalar;
 
 	ns.set("pi",pw::pi<Scalar>());
 
 
-    ns.new_usertype<vector3d>("vector3",
+	ns.new_usertype<vector3>("vector3",
-                              sol::constructors<vector3d(), vector3d(Scalar,Scalar,Scalar)>(),
+							 sol::constructors<vector3(), vector3(Scalar,Scalar,Scalar)>(),
-                              "set",&vector3d::set,
+							 "set",&vector3::set,
-                              "x", scripting::property(scripting::resolve<const Scalar&() const>(&vector3d::x), &vector3d::set_x),
+							 "x", scripting::property(scripting::resolve<const Scalar&() const>(&vector3::x), &vector3::set_x),
-                              "y", scripting::property(scripting::resolve<const Scalar&() const>(&vector3d::y), &vector3d::set_y),
+							 "y", scripting::property(scripting::resolve<const Scalar&() const>(&vector3::y), &vector3::set_y),
-                              "z", scripting::property(scripting::resolve<const Scalar&() const>(&vector3d::z), &vector3d::set_z),
+							 "z", scripting::property(scripting::resolve<const Scalar&() const>(&vector3::z), &vector3::set_z),
-                              "norm",&vector3d::norm,
+							 "norm",&vector3::norm,
-                              "cross",&vector3d::cross,
+							 "cross",&vector3::cross,
-                              "dot",&vector3d::dot,
+							 "dot",&vector3::dot,
-                              //									  sol::meta_function::addition, sol::resolve<vector3d(const vector3d&, const vector3d&)>(::operator+),
+							 //									  sol::meta_function::addition, sol::resolve<vector3(const vector3&, const vector3&)>(::operator+),
-                              //									  sol::meta_function::subtraction, &vector3d::operator-
+							 //									  sol::meta_function::subtraction, &vector3::operator-
-                              //                                      "v",&vector3d::values,
+							 //                                      "v",&vector3::values,
-                              "clone",&vector3d::clone
+							 "clone",&vector3::clone
 							 );
 
-    ns.new_usertype<quaterniond>("quaternion",
+	ns.new_usertype<quaternion>("quaternion",
-                                 sol::constructors<quaterniond(), quaterniond(Scalar,Scalar,Scalar,Scalar)>(),
+								sol::constructors<quaternion(), quaternion(Scalar,Scalar,Scalar,Scalar)>(),
-                                 "set",&quaterniond::set,
+								"set",&quaternion::set,
-                                 "x", scripting::property(scripting::resolve<const Scalar&() const>(&quaterniond::x), &quaterniond::set_x),
+								"x", scripting::property(scripting::resolve<const Scalar&() const>(&quaternion::x), &quaternion::set_x),
-                                 "y", scripting::property(scripting::resolve<const Scalar&() const>(&quaterniond::y), &quaterniond::set_y),
+								"y", scripting::property(scripting::resolve<const Scalar&() const>(&quaternion::y), &quaternion::set_y),
-                                 "z", scripting::property(scripting::resolve<const Scalar&() const>(&quaterniond::z), &quaterniond::set_z),
+								"z", scripting::property(scripting::resolve<const Scalar&() const>(&quaternion::z), &quaternion::set_z),
-                                 "w", scripting::property(scripting::resolve<const Scalar&() const>(&quaterniond::w), &quaterniond::set_w),
+								"w", scripting::property(scripting::resolve<const Scalar&() const>(&quaternion::w), &quaternion::set_w),
-                                 "dot",&quaterniond::dot,
+								"dot",&quaternion::dot,
-                                 "inverse",scripting::readonly_property(&quaterniond::inverse),
+								"inverse",scripting::readonly_property(&quaternion::inverse),
-                                 "normalized",&quaterniond::normalized,
+								"normalized",&quaternion::normalized,
-                                 "lerp",&quaterniond::lerp
+								"lerp",&quaternion::lerp,
+								"slerp",&quaternion::slerp
 								//                                      "v",&vector3d::values,
 								//                                      "clone",&vector3d::clone
 								);
 
-    ns.new_usertype<axisangled>("axisangle",
+	ns.new_usertype<axisangle>("axisangle",
-                                sol::constructors<axisangled(), axisangled(vector3d,Scalar)>(),
+							   sol::constructors<axisangle(), axisangle(vector3,Scalar)>(),
-                                "axis",scripting::property(&axisangled::axis,&axisangled::set_axis),
+							   "axis",scripting::property(&axisangle::axis,&axisangle::set_axis),
-                                "angle",scripting::property(&axisangled::angle,&axisangled::set_angle)
+							   "angle",scripting::property(&axisangle::angle,&axisangle::set_angle)
+							   );
+
+
+	ns.new_usertype<size>("size",
+						  sol::constructors<size(),size(Scalar,Scalar)>(),
+						  "width",&size::width,
+						  "height",&size::height
+						  //						   "none",sol::debug::level::none
+						  );
+
+	ns.new_usertype<point>("point",
+						   sol::constructors<point(),point(Scalar,Scalar)>(),
+						   "x",&point::x,
+						   "y",&point::y
 						   );
 
 
 	ns.new_usertype<debug>("debug",
 						   "new",sol::no_constructor,
-                           "get",&debug::get
+						   "get",&debug::get,
+						   "write",&debug::write
+						   //						   "none",sol::debug::level::none
 						   );
 
 }

src/scripting/src/script_system.cpp

@@ -11,13 +11,13 @@ void script_system::load(sol::table &ns)
 	ns.new_usertype<window>("window",
 							"update",&window::update,
 							"title",sol::writeonly_property(&window::set_title),
-                            "set_size",&window::set_size
+							"size",sol::property(&window::size,&window::set_size)
 							);
 
-//    ns.new_usertype<input>("input",
+	ns.new_usertype<input>("input",
-//                            "new", sol::no_constructor,
+						   "new", sol::no_constructor,
-//                            "get",&input::get
+						   "get",&input::get
-//                            );
+						   );
 
 }
 

src/scripts/demos/simple_000.lua

@@ -67,9 +67,12 @@ end
 
 local w = pw.window.new()
 
-w.title = "pixwerx 1.0"
+-- set title
+w.title = "pixwerx 0.1"
+
+-- set size
+w.size = pw.size.new(1200,800)
 
-w:set_size(1280,768)
 
 while w:update()
 do

src/system/include/pw/system/input.hpp

@@ -13,12 +13,13 @@ public:
 
     point mouse_position() const { return _mouse_position; }
 
+	~input() = default;
+
 protected:
 
     friend class window;
 
     input();
-    ~input() = default;
 
 private:
 

src/system/include/pw/system/window.hpp

@@ -16,12 +16,11 @@ public:
 
 	void set_title(const std::string& title);
 
-    void set_size(int w, int h);
+	void set_size(const size& s);
-    size get_size() const;
+	size size() const;
 
     typedef void drop_callback;
 
-
 protected:
 
 	struct impl;

src/system/src/window.cpp

@@ -178,12 +178,12 @@ void window::set_title(const std::string& title)
 	_impl->set_title(title);
 }
 
-void window::set_size(int w,int h)
+void window::set_size(const ::pw::size& s)
 {
-	_impl->set_size(w,h);
+	_impl->set_size(s.width,s.height);
 }
 
-size window::get_size() const
+size window::size() const
 {
     return _impl->size();
 }