diff --git a/dtool/src/dtoolbase/cmath.I b/dtool/src/dtoolbase/cmath.I index 2fd28b6a01..f1b7940c90 100644 --- a/dtool/src/dtoolbase/cmath.I +++ b/dtool/src/dtoolbase/cmath.I @@ -336,6 +336,28 @@ cpow(double x, double y) { return pow(x, y); } +//////////////////////////////////////////////////////////////////// +// Function: cpow +// Description: +//////////////////////////////////////////////////////////////////// +INLINE int +cpow(int x, int y) { + int result = 1; + + if (y >= 0) { + for(; y > 0; --y) { + result *= x; + } + return result; + + } else { + for(; y < 0; ++y) { + result *= x; + } + return 1 / result; + } +} + //////////////////////////////////////////////////////////////////// // Function: cnan // Description: diff --git a/dtool/src/dtoolbase/cmath.h b/dtool/src/dtoolbase/cmath.h index 23e9d920c9..4812b2a891 100644 --- a/dtool/src/dtoolbase/cmath.h +++ b/dtool/src/dtoolbase/cmath.h @@ -62,6 +62,8 @@ INLINE double cacos(double v); INLINE double cmod(double x, double y); INLINE double cpow(double x, double y); +INLINE int cpow(int x, int y); + // Returns true if the number is NaN, false if it's a genuine number // or infinity. INLINE bool cnan(double v); diff --git a/dtool/src/dtoolbase/nearly_zero.h b/dtool/src/dtoolbase/nearly_zero.h index 828dc424e6..0b36d4652d 100644 --- a/dtool/src/dtoolbase/nearly_zero.h +++ b/dtool/src/dtoolbase/nearly_zero.h @@ -35,6 +35,13 @@ get_nearly_zero_value(float) { return 1.0e-6f; } +INLINE int +get_nearly_zero_value(int) { + // This is a bit silly, but we should nevertheless define it in + // case it is called for an integer type. + return 0; +} + // IS_THRESHOLD_ZERO(value, threshold) returns true if the value is // within threshold of zero. @@ -73,7 +80,7 @@ get_nearly_zero_value(float) { // MAYBE_ZERO(value) returns 0 if the value is nearly zero, and the // value itself otherwise. #define MAYBE_ZERO(value) \ - (IS_NEARLY_ZERO(value) ? 0.0 : (value)) + (IS_NEARLY_ZERO(value) ? 0 : (value)) #endif diff --git a/dtool/src/pystub/pystub.cxx b/dtool/src/pystub/pystub.cxx index 9118c15209..75724d427c 100644 --- a/dtool/src/pystub/pystub.cxx +++ b/dtool/src/pystub/pystub.cxx @@ -85,6 +85,7 @@ extern "C" { EXPCL_PYSTUB int PyModule_AddStringConstant(...); EXPCL_PYSTUB int PyModule_Create2(...); EXPCL_PYSTUB int PyNumber_Float(...); + EXPCL_PYSTUB int PyNumber_Int(...); EXPCL_PYSTUB int PyNumber_Long(...); EXPCL_PYSTUB int PyObject_ASCII(...); EXPCL_PYSTUB int PyObject_Call(...); @@ -249,6 +250,7 @@ int PyModule_AddObject(...) { return 0; }; int PyModule_AddStringConstant(...) { return 0; }; int PyModule_Create2(...) { return 0; }; int PyNumber_Float(...) { return 0; } +int PyNumber_Int(...) { return 0; } int PyNumber_Long(...) { return 0; } int PyObject_ASCII(...) { return 0; } int PyObject_Call(...) { return 0; } diff --git a/panda/src/display/windowProperties.I b/panda/src/display/windowProperties.I index afae00b4f2..ca307062a4 100644 --- a/panda/src/display/windowProperties.I +++ b/panda/src/display/windowProperties.I @@ -63,12 +63,38 @@ is_any_specified() const { // including decorations. //////////////////////////////////////////////////////////////////// INLINE void WindowProperties:: -set_origin(int x_origin, int y_origin) { - _x_origin = x_origin; - _y_origin = y_origin; +set_origin(const LPoint2i &origin) { + _origin = origin; _specified |= S_origin; } +//////////////////////////////////////////////////////////////////// +// Function: WindowProperties::set_origin +// Access: Published +// Description: Specifies the origin on the screen (in pixels, +// relative to the top-left corner) at which the window +// should appear. This is the origin of the top-left +// corner of the useful part of the window, not +// including decorations. +//////////////////////////////////////////////////////////////////// +INLINE void WindowProperties:: +set_origin(int x_origin, int y_origin) { + _origin.set(x_origin, y_origin); + _specified |= S_origin; +} + +//////////////////////////////////////////////////////////////////// +// Function: WindowProperties::get_origin +// Access: Published +// Description: Returns the coordinates of the window's top-left +// corner, not including decorations. +//////////////////////////////////////////////////////////////////// +INLINE const LPoint2i &WindowProperties:: +get_origin() const { + nassertr(has_origin(), LPoint2i::zero()); + return _origin; +} + //////////////////////////////////////////////////////////////////// // Function: WindowProperties::get_x_origin // Access: Published @@ -78,7 +104,7 @@ set_origin(int x_origin, int y_origin) { INLINE int WindowProperties:: get_x_origin() const { nassertr(has_origin(), 0); - return _x_origin; + return _origin.get_x(); } //////////////////////////////////////////////////////////////////// @@ -90,7 +116,7 @@ get_x_origin() const { INLINE int WindowProperties:: get_y_origin() const { nassertr(has_origin(), 0); - return _y_origin; + return _origin.get_y(); } //////////////////////////////////////////////////////////////////// @@ -112,8 +138,20 @@ has_origin() const { INLINE void WindowProperties:: clear_origin() { _specified &= ~S_origin; - _x_origin = 0; - _y_origin = 0; + _origin = LPoint2i::zero(); +} + +//////////////////////////////////////////////////////////////////// +// Function: WindowProperties::set_size +// Access: Published +// Description: Specifies the requested size of the window, in +// pixels. This is the size of the useful part of the +// window, not including decorations. +//////////////////////////////////////////////////////////////////// +INLINE void WindowProperties:: +set_size(const LVector2i &size) { + _size = size; + _specified |= S_size; } //////////////////////////////////////////////////////////////////// @@ -125,11 +163,22 @@ clear_origin() { //////////////////////////////////////////////////////////////////// INLINE void WindowProperties:: set_size(int x_size, int y_size) { - _x_size = x_size; - _y_size = y_size; + _size.set(x_size, y_size); _specified |= S_size; } +//////////////////////////////////////////////////////////////////// +// Function: WindowProperties::get_origin +// Access: Published +// Description: Returns size in pixels of the useful part of the +// window, not including decorations. +//////////////////////////////////////////////////////////////////// +INLINE const LVector2i &WindowProperties:: +get_size() const { + nassertr(has_size(), LVector2i::zero()); + return _size; +} + //////////////////////////////////////////////////////////////////// // Function: WindowProperties::get_x_size // Access: Published @@ -140,7 +189,7 @@ set_size(int x_size, int y_size) { INLINE int WindowProperties:: get_x_size() const { nassertr(has_size(), 0); - return _x_size; + return _size.get_x(); } //////////////////////////////////////////////////////////////////// @@ -153,7 +202,7 @@ get_x_size() const { INLINE int WindowProperties:: get_y_size() const { nassertr(has_size(), 0); - return _y_size; + return _size.get_y(); } //////////////////////////////////////////////////////////////////// @@ -175,8 +224,7 @@ has_size() const { INLINE void WindowProperties:: clear_size() { _specified &= ~S_size; - _x_size = 0; - _y_size = 0; + _size = LVector2i::zero(); } //////////////////////////////////////////////////////////////////// diff --git a/panda/src/display/windowProperties.cxx b/panda/src/display/windowProperties.cxx index 2e007598ed..d38241f2ce 100644 --- a/panda/src/display/windowProperties.cxx +++ b/panda/src/display/windowProperties.cxx @@ -36,10 +36,8 @@ WindowProperties() { void WindowProperties:: operator = (const WindowProperties ©) { _specified = copy._specified; - _x_origin = copy._x_origin; - _y_origin = copy._y_origin; - _x_size = copy._x_size; - _y_size = copy._y_size; + _origin = copy._origin; + _size = copy._size; _title = copy._title; _icon_filename = copy._icon_filename; _cursor_filename = copy._cursor_filename; @@ -169,10 +167,8 @@ bool WindowProperties:: operator == (const WindowProperties &other) const { return (_specified == other._specified && _flags == other._flags && - _x_origin == other._x_origin && - _y_origin == other._y_origin && - _x_size == other._x_size && - _y_size == other._y_size && + _origin == other._origin && + _size == other._size && _z_order == other._z_order && _title == other._title && _icon_filename == other._icon_filename && @@ -191,10 +187,8 @@ operator == (const WindowProperties &other) const { void WindowProperties:: clear() { _specified = 0; - _x_origin = 0; - _y_origin = 0; - _x_size = 0; - _y_size = 0; + _origin = LPoint2i::zero(); + _size = LVector2i::zero(); _title = string(); _icon_filename = Filename(); _cursor_filename = Filename(); @@ -244,10 +238,10 @@ set_parent_window(size_t parent) { void WindowProperties:: add_properties(const WindowProperties &other) { if (other.has_origin()) { - set_origin(other.get_x_origin(), other.get_y_origin()); + set_origin(other.get_origin()); } if (other.has_size()) { - set_size(other.get_x_size(), other.get_y_size()); + set_size(other.get_size()); } if (other.has_title()) { set_title(other.get_title()); diff --git a/panda/src/display/windowProperties.h b/panda/src/display/windowProperties.h index a7098cb1b8..5f8a6bb32d 100644 --- a/panda/src/display/windowProperties.h +++ b/panda/src/display/windowProperties.h @@ -19,7 +19,9 @@ #include "filename.h" #include "pnotify.h" #include "windowHandle.h" - +#include "lpoint2.h" +#include "lvector2.h" + //////////////////////////////////////////////////////////////////// // Class : WindowProperties // Description : A container for the various kinds of properties we @@ -57,14 +59,18 @@ PUBLISHED: void clear(); INLINE bool is_any_specified() const; - + + INLINE void set_origin(const LPoint2i &origin); INLINE void set_origin(int x_origin, int y_origin); + INLINE const LPoint2i &get_origin() const; INLINE int get_x_origin() const; INLINE int get_y_origin() const; INLINE bool has_origin() const; INLINE void clear_origin(); + INLINE void set_size(const LVector2i &size); INLINE void set_size(int x_size, int y_size); + INLINE const LVector2i &get_size() const; INLINE int get_x_size() const; INLINE int get_y_size() const; INLINE bool has_size() const; @@ -73,7 +79,7 @@ PUBLISHED: INLINE bool has_mouse_mode() const; INLINE void set_mouse_mode(MouseMode mode); INLINE MouseMode get_mouse_mode() const; - INLINE void clear_mouse_mode(); + INLINE void clear_mouse_mode(); INLINE void set_title(const string &title); INLINE const string &get_title() const; @@ -183,10 +189,8 @@ private: }; int _specified; - int _x_origin; - int _y_origin; - int _x_size; - int _y_size; + LPoint2i _origin; + LVector2i _size; MouseMode _mouse_mode; string _title; Filename _cursor_filename; diff --git a/panda/src/glstuff/glImmediateModeSender_src.cxx b/panda/src/glstuff/glImmediateModeSender_src.cxx index 6e1ca3dd85..347423cbb7 100644 --- a/panda/src/glstuff/glImmediateModeSender_src.cxx +++ b/panda/src/glstuff/glImmediateModeSender_src.cxx @@ -564,7 +564,7 @@ issue_vertex() { //////////////////////////////////////////////////////////////////// void CLP(ImmediateModeSender)::VectorSender2fui:: issue_vertex() { - const int *d = _reader->get_data2i(); + const LVecBase2i &d = _reader->get_data2i(); #ifndef NDEBUG if (GLCAT.is_spam()) { GLCAT.spam() @@ -573,7 +573,7 @@ issue_vertex() { } #endif // NDEBUG - (*_func)(2, (const GLuint *)d); + (*_func)(2, (const GLuint *)d.get_data()); } //////////////////////////////////////////////////////////////////// @@ -583,7 +583,7 @@ issue_vertex() { //////////////////////////////////////////////////////////////////// void CLP(ImmediateModeSender)::VectorSender3fui:: issue_vertex() { - const int *d = _reader->get_data3i(); + const LVecBase3i &d = _reader->get_data3i(); #ifndef NDEBUG if (GLCAT.is_spam()) { GLCAT.spam() @@ -592,7 +592,7 @@ issue_vertex() { } #endif // NDEBUG - (*_func)(3, (const GLuint *)d); + (*_func)(3, (const GLuint *)d.get_data()); } //////////////////////////////////////////////////////////////////// @@ -602,7 +602,7 @@ issue_vertex() { //////////////////////////////////////////////////////////////////// void CLP(ImmediateModeSender)::VectorSender4fui:: issue_vertex() { - const int *d = _reader->get_data4i(); + const LVecBase4i &d = _reader->get_data4i(); #ifndef NDEBUG if (GLCAT.is_spam()) { GLCAT.spam() @@ -611,7 +611,7 @@ issue_vertex() { } #endif // NDEBUG - (*_func)(4, (const GLuint *)d); + (*_func)(4, (const GLuint *)d.get_data()); } #endif // SUPPORT_IMMEDIATE_MODE diff --git a/panda/src/gobj/geomVertexColumn.cxx b/panda/src/gobj/geomVertexColumn.cxx index 0c272ad477..d629121ffc 100644 --- a/panda/src/gobj/geomVertexColumn.cxx +++ b/panda/src/gobj/geomVertexColumn.cxx @@ -1043,75 +1043,69 @@ get_data1i(const unsigned char *pointer) { // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -const int *GeomVertexColumn::Packer:: +const LVecBase2i &GeomVertexColumn::Packer:: get_data2i(const unsigned char *pointer) { switch (_column->get_num_values()) { case 1: - _i[0] = get_data1i(pointer); - _i[1] = 0; - return _i; + _v2i.set(get_data1i(pointer), 0); + return _v2i; default: switch (_column->get_numeric_type()) { case NT_uint8: - _i[0] = pointer[0]; - _i[1] = pointer[1]; - return _i; + _v2i.set(pointer[0], pointer[1]); + return _v2i; case NT_uint16: { const PN_uint16 *pi = (const PN_uint16 *)pointer; - _i[0] = pi[0]; - _i[1] = pi[1]; + _v2i.set(pi[0], pi[1]); } - return _i; + return _v2i; case NT_uint32: { const PN_uint32 *pi = (const PN_uint32 *)pointer; - _i[0] = pi[0]; - _i[1] = pi[1]; + _v2i.set(pi[0], pi[1]); } - return _i; + return _v2i; case NT_packed_dcba: { PN_uint32 dword = *(const PN_uint32 *)pointer; - _i[0] = GeomVertexData::unpack_abcd_d(dword); - _i[1] = GeomVertexData::unpack_abcd_c(dword); + _v2i.set(GeomVertexData::unpack_abcd_d(dword), + GeomVertexData::unpack_abcd_c(dword)); } - return _i; + return _v2i; case NT_packed_dabc: { PN_uint32 dword = *(const PN_uint32 *)pointer; - _i[0] = GeomVertexData::unpack_abcd_b(dword); - _i[1] = GeomVertexData::unpack_abcd_c(dword); + _v2i.set(GeomVertexData::unpack_abcd_b(dword), + GeomVertexData::unpack_abcd_c(dword)); } - return _i; + return _v2i; case NT_float32: { const PN_float32 *pi = (const PN_float32 *)pointer; - _i[0] = (int)pi[0]; - _i[1] = (int)pi[1]; + _v2i.set((int)pi[0], (int)pi[1]); } - return _i; + return _v2i; case NT_float64: { const PN_float64 *pi = (const PN_float64 *)pointer; - _i[0] = (int)pi[0]; - _i[1] = (int)pi[1]; + _v2i.set((int)pi[0], (int)pi[1]); } - return _i; + return _v2i; case NT_stdfloat: - nassertr(false, _i); + nassertr(false, _v2i); } } - return _i; + return _v2i; } //////////////////////////////////////////////////////////////////// @@ -1119,92 +1113,78 @@ get_data2i(const unsigned char *pointer) { // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -const int *GeomVertexColumn::Packer:: +const LVecBase3i &GeomVertexColumn::Packer:: get_data3i(const unsigned char *pointer) { switch (_column->get_num_values()) { case 1: - _i[0] = get_data1i(pointer); - _i[1] = 0; - _i[2] = 0; - return _i; + _v3i.set(get_data1i(pointer), 0, 0); + return _v3i; case 2: { - const int *i = get_data2i(pointer); - _i[0] = i[0]; - _i[1] = i[1]; - _i[2] = 0; + const LVecBase2i &v2 = get_data2i(pointer); + _v3i.set(v2[0], v2[1], 0); } - return _i; + return _v3i; default: switch (_column->get_numeric_type()) { case NT_uint8: - _i[0] = pointer[0]; - _i[1] = pointer[1]; - _i[2] = pointer[2]; - return _i; - + _v3i.set(pointer[0], pointer[1], 0); + return _v3i; + case NT_uint16: { const PN_uint16 *pi = (const PN_uint16 *)pointer; - _i[0] = pi[0]; - _i[1] = pi[1]; - _i[2] = pi[2]; + _v3i.set(pi[0], pi[1], pi[2]); } - return _i; - + return _v3i; + case NT_uint32: { const PN_uint32 *pi = (const PN_uint32 *)pointer; - _i[0] = pi[0]; - _i[1] = pi[1]; - _i[2] = pi[2]; + _v3i.set(pi[0], pi[1], pi[2]); } - return _i; - + return _v3i; + case NT_packed_dcba: { PN_uint32 dword = *(const PN_uint32 *)pointer; - _i[0] = GeomVertexData::unpack_abcd_d(dword); - _i[1] = GeomVertexData::unpack_abcd_c(dword); - _i[2] = GeomVertexData::unpack_abcd_b(dword); + _v3i.set(GeomVertexData::unpack_abcd_d(dword), + GeomVertexData::unpack_abcd_c(dword), + GeomVertexData::unpack_abcd_b(dword)); } - return _i; - + return _v3i; + case NT_packed_dabc: { PN_uint32 dword = *(const PN_uint32 *)pointer; - _i[0] = GeomVertexData::unpack_abcd_b(dword); - _i[1] = GeomVertexData::unpack_abcd_c(dword); - _i[2] = GeomVertexData::unpack_abcd_d(dword); + _v3i.set(GeomVertexData::unpack_abcd_b(dword), + GeomVertexData::unpack_abcd_c(dword), + GeomVertexData::unpack_abcd_d(dword)); } - return _i; - + return _v3i; + case NT_float32: { const PN_float32 *pi = (const PN_float32 *)pointer; - _i[0] = (int)pi[0]; - _i[1] = (int)pi[1]; - _i[2] = (int)pi[2]; + _v3i.set((int)pi[0], (int)pi[1], (int)pi[2]); } - return _i; - + return _v3i; + case NT_float64: { const PN_float64 *pi = (const PN_float64 *)pointer; - _i[0] = (int)pi[0]; - _i[1] = (int)pi[1]; - _i[2] = (int)pi[2]; + _v3i.set((int)pi[0], (int)pi[1], (int)pi[2]); } - return _i; + return _v3i; case NT_stdfloat: - nassertr(false, _i); + nassertr(false, _v3i); } } - return _i; + return _v3i; } //////////////////////////////////////////////////////////////////// @@ -1212,111 +1192,87 @@ get_data3i(const unsigned char *pointer) { // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -const int *GeomVertexColumn::Packer:: +const LVecBase4i &GeomVertexColumn::Packer:: get_data4i(const unsigned char *pointer) { switch (_column->get_num_values()) { case 1: - _i[0] = get_data1i(pointer); - _i[1] = 0; - _i[2] = 0; - _i[3] = 0; - return _i; + _v4i.set(get_data1i(pointer), 0, 0, 0); + return _v4i; case 2: { - const int *i = get_data2i(pointer); - _i[0] = i[0]; - _i[1] = i[1]; - _i[2] = 0; - _i[3] = 0; + const LVecBase2i &v2 = get_data2i(pointer); + _v4i.set(v2[0], v2[1], 0, 0); } - return _i; + return _v4i; case 3: { - const int *i = get_data3i(pointer); - _i[0] = i[0]; - _i[1] = i[1]; - _i[2] = i[2]; - _i[3] = 0; + const LVecBase3i &v3 = get_data3i(pointer); + _v4i.set(v3[0], v3[1], v3[2], 0); } - return _i; + return _v4i; default: switch (_column->get_numeric_type()) { case NT_uint8: - _i[0] = pointer[0]; - _i[1] = pointer[1]; - _i[2] = pointer[2]; - _i[3] = pointer[3]; - return _i; + _v4i.set(pointer[0], pointer[1], pointer[2], pointer[3]); + return _v4i; case NT_uint16: { const PN_uint16 *pi = (const PN_uint16 *)pointer; - _i[0] = pi[0]; - _i[1] = pi[1]; - _i[2] = pi[2]; - _i[3] = pi[3]; + _v4i.set(pi[0], pi[1], pi[2], pi[3]); } - return _i; + return _v4i; case NT_uint32: { const PN_uint32 *pi = (const PN_uint32 *)pointer; - _i[0] = pi[0]; - _i[1] = pi[1]; - _i[2] = pi[2]; - _i[3] = pi[3]; + _v4i.set(pi[0], pi[1], pi[2], pi[3]); } - return _i; + return _v4i; case NT_packed_dcba: { PN_uint32 dword = *(const PN_uint32 *)pointer; - _i[0] = GeomVertexData::unpack_abcd_d(dword); - _i[1] = GeomVertexData::unpack_abcd_c(dword); - _i[2] = GeomVertexData::unpack_abcd_b(dword); - _i[3] = GeomVertexData::unpack_abcd_a(dword); + _v4i.set(GeomVertexData::unpack_abcd_d(dword), + GeomVertexData::unpack_abcd_c(dword), + GeomVertexData::unpack_abcd_b(dword), + GeomVertexData::unpack_abcd_a(dword)); } - return _i; + return _v4i; case NT_packed_dabc: { PN_uint32 dword = *(const PN_uint32 *)pointer; - _i[0] = GeomVertexData::unpack_abcd_b(dword); - _i[1] = GeomVertexData::unpack_abcd_c(dword); - _i[2] = GeomVertexData::unpack_abcd_d(dword); - _i[3] = GeomVertexData::unpack_abcd_a(dword); + _v4i.set(GeomVertexData::unpack_abcd_b(dword), + GeomVertexData::unpack_abcd_c(dword), + GeomVertexData::unpack_abcd_d(dword), + GeomVertexData::unpack_abcd_a(dword)); } - return _i; + return _v4i; case NT_float32: { const PN_float32 *pi = (const PN_float32 *)pointer; - _i[0] = (int)pi[0]; - _i[1] = (int)pi[1]; - _i[2] = (int)pi[2]; - _i[3] = (int)pi[3]; + _v4i.set((int)pi[0], (int)pi[1], (int)pi[2], (int)pi[3]); } - return _i; + return _v4i; case NT_float64: { const PN_float64 *pi = (const PN_float64 *)pointer; - _i[0] = (int)pi[0]; - _i[1] = (int)pi[1]; - _i[2] = (int)pi[2]; - _i[3] = (int)pi[3]; + _v4i.set((int)pi[0], (int)pi[1], (int)pi[2], (int)pi[3]); } - return _i; + return _v4i; case NT_stdfloat: - nassertr(false, _i); + nassertr(false, _v4i); } } - return _i; + return _v4i; } //////////////////////////////////////////////////////////////////// @@ -1903,22 +1859,22 @@ set_data4d(unsigned char *pointer, const LVecBase4d &data) { // Description: //////////////////////////////////////////////////////////////////// void GeomVertexColumn::Packer:: -set_data1i(unsigned char *pointer, int a) { +set_data1i(unsigned char *pointer, int data) { switch (_column->get_num_values()) { case 1: switch (_column->get_numeric_type()) { case NT_uint8: - *pointer = a; - nassertv((*pointer) == a); + *pointer = data; + nassertv((*pointer) == data); break; case NT_uint16: - *(PN_uint16 *)pointer = a; - nassertv(*(PN_uint16 *)pointer == a); + *(PN_uint16 *)pointer = data; + nassertv(*(PN_uint16 *)pointer == data); break; case NT_uint32: - *(PN_uint32 *)pointer = a; + *(PN_uint32 *)pointer = data; break; case NT_packed_dcba: @@ -1927,11 +1883,11 @@ set_data1i(unsigned char *pointer, int a) { break; case NT_float32: - *(PN_float32 *)pointer = (float)a; + *(PN_float32 *)pointer = (float)data; break; case NT_float64: - *(PN_float64 *)pointer = (double)a; + *(PN_float64 *)pointer = (double)data; break; case NT_stdfloat: @@ -1940,15 +1896,15 @@ set_data1i(unsigned char *pointer, int a) { break; case 2: - set_data2i(pointer, a, 0); + set_data2i(pointer, LVecBase2i(data, 0)); break; case 3: - set_data3i(pointer, a, 0, 0); + set_data3i(pointer, LVecBase3i(data, 0, 0)); break; default: - set_data4i(pointer, a, 0, 0, 0); + set_data4i(pointer, LVecBase4i(data, 0, 0, 0)); break; } } @@ -1959,32 +1915,32 @@ set_data1i(unsigned char *pointer, int a) { // Description: //////////////////////////////////////////////////////////////////// void GeomVertexColumn::Packer:: -set_data2i(unsigned char *pointer, int a, int b) { +set_data2i(unsigned char *pointer, const LVecBase2i &data) { switch (_column->get_num_values()) { case 1: - set_data1i(pointer, a); + set_data1i(pointer, data[0]); break; case 2: switch (_column->get_numeric_type()) { case NT_uint8: - pointer[0] = a; - pointer[1] = b; + pointer[0] = data[0]; + pointer[1] = data[1]; break; case NT_uint16: { PN_uint16 *pi = (PN_uint16 *)pointer; - pi[0] = a; - pi[1] = b; + pi[0] = data[0]; + pi[1] = data[1]; } break; case NT_uint32: { PN_uint32 *pi = (PN_uint32 *)pointer; - pi[0] = a; - pi[1] = b; + pi[0] = data[0]; + pi[1] = data[1]; } break; @@ -1996,16 +1952,16 @@ set_data2i(unsigned char *pointer, int a, int b) { case NT_float32: { PN_float32 *pi = (PN_float32 *)pointer; - pi[0] = a; - pi[1] = b; + pi[0] = data[0]; + pi[1] = data[1]; } break; case NT_float64: { PN_float64 *pi = (PN_float64 *)pointer; - pi[0] = a; - pi[1] = b; + pi[0] = data[0]; + pi[1] = data[1]; } break; @@ -2015,11 +1971,11 @@ set_data2i(unsigned char *pointer, int a, int b) { break; case 3: - set_data3i(pointer, a, b, 0); + set_data3i(pointer, LVecBase3i(data[0], data[1], 0)); break; default: - set_data4i(pointer, a, b, 0, 0); + set_data4i(pointer, LVecBase4i(data[0], data[1], 0, 0)); break; } } @@ -2030,39 +1986,39 @@ set_data2i(unsigned char *pointer, int a, int b) { // Description: //////////////////////////////////////////////////////////////////// void GeomVertexColumn::Packer:: -set_data3i(unsigned char *pointer, int a, int b, int c) { +set_data3i(unsigned char *pointer, const LVecBase3i &data) { switch (_column->get_num_values()) { case 1: - set_data1i(pointer, a); + set_data1i(pointer, data[0]); break; case 2: - set_data2i(pointer, a, b); + set_data2i(pointer, LVecBase2i(data[0], data[1])); break; case 3: switch (_column->get_numeric_type()) { case NT_uint8: - pointer[0] = a; - pointer[1] = b; - pointer[2] = c; + pointer[0] = data[0]; + pointer[1] = data[1]; + pointer[2] = data[2]; break; case NT_uint16: { PN_uint16 *pi = (PN_uint16 *)pointer; - pi[0] = a; - pi[1] = b; - pi[2] = c; + pi[0] = data[0]; + pi[1] = data[1]; + pi[2] = data[2]; } break; case NT_uint32: { PN_uint32 *pi = (PN_uint32 *)pointer; - pi[0] = a; - pi[1] = b; - pi[2] = c; + pi[0] = data[0]; + pi[1] = data[1]; + pi[2] = data[2]; } break; @@ -2074,18 +2030,18 @@ set_data3i(unsigned char *pointer, int a, int b, int c) { case NT_float32: { PN_float32 *pi = (PN_float32 *)pointer; - pi[0] = a; - pi[1] = b; - pi[2] = c; + pi[0] = data[0]; + pi[1] = data[1]; + pi[2] = data[2]; } break; case NT_float64: { PN_float64 *pi = (PN_float64 *)pointer; - pi[0] = a; - pi[1] = b; - pi[2] = c; + pi[0] = data[0]; + pi[1] = data[1]; + pi[2] = data[2]; } break; @@ -2095,7 +2051,7 @@ set_data3i(unsigned char *pointer, int a, int b, int c) { break; default: - set_data4i(pointer, a, b, c, 0); + set_data4i(pointer, LVecBase4i(data[0], data[1], data[2], 0)); break; } } @@ -2106,74 +2062,74 @@ set_data3i(unsigned char *pointer, int a, int b, int c) { // Description: //////////////////////////////////////////////////////////////////// void GeomVertexColumn::Packer:: -set_data4i(unsigned char *pointer, int a, int b, int c, int d) { +set_data4i(unsigned char *pointer, const LVecBase4i &data) { switch (_column->get_num_values()) { case 1: - set_data1i(pointer, a); + set_data1i(pointer, data[0]); break; case 2: - set_data2i(pointer, a, b); + set_data2i(pointer, LVecBase2i(data[0], data[1])); break; case 3: - set_data3i(pointer, a, b, c); + set_data3i(pointer, LVecBase3i(data[0], data[1], data[2])); break; default: switch (_column->get_numeric_type()) { case NT_uint8: - pointer[0] = a; - pointer[1] = b; - pointer[2] = c; - pointer[3] = d; + pointer[0] = data[0]; + pointer[1] = data[1]; + pointer[2] = data[2]; + pointer[3] = data[3]; break; case NT_uint16: { PN_uint16 *pi = (PN_uint16 *)pointer; - pi[0] = a; - pi[1] = b; - pi[2] = c; - pi[3] = d; + pi[0] = data[0]; + pi[1] = data[1]; + pi[2] = data[2]; + pi[3] = data[3]; } break; case NT_uint32: { PN_uint32 *pi = (PN_uint32 *)pointer; - pi[0] = a; - pi[1] = b; - pi[2] = c; - pi[3] = d; + pi[0] = data[0]; + pi[1] = data[1]; + pi[2] = data[2]; + pi[3] = data[3]; } break; case NT_packed_dcba: - *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(d, c, b, a); + *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(data[3], data[2], data[1], data[0]); break; case NT_packed_dabc: - *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(d, a, b, c); + *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(data[3], data[0], data[1], data[2]); break; case NT_float32: { PN_float32 *pi = (PN_float32 *)pointer; - pi[0] = a; - pi[1] = b; - pi[2] = c; - pi[3] = d; + pi[0] = data[0]; + pi[1] = data[1]; + pi[2] = data[2]; + pi[3] = data[3]; } break; case NT_float64: { PN_float64 *pi = (PN_float64 *)pointer; - pi[0] = a; - pi[1] = b; - pi[2] = c; - pi[3] = d; + pi[0] = data[0]; + pi[1] = data[1]; + pi[2] = data[2]; + pi[3] = data[3]; } break; diff --git a/panda/src/gobj/geomVertexColumn.h b/panda/src/gobj/geomVertexColumn.h index 09510a3e89..88384c4909 100644 --- a/panda/src/gobj/geomVertexColumn.h +++ b/panda/src/gobj/geomVertexColumn.h @@ -124,9 +124,9 @@ private: virtual const LVecBase4d &get_data4d(const unsigned char *pointer); virtual int get_data1i(const unsigned char *pointer); - virtual const int *get_data2i(const unsigned char *pointer); - virtual const int *get_data3i(const unsigned char *pointer); - virtual const int *get_data4i(const unsigned char *pointer); + virtual const LVecBase2i &get_data2i(const unsigned char *pointer); + virtual const LVecBase3i &get_data3i(const unsigned char *pointer); + virtual const LVecBase4i &get_data4i(const unsigned char *pointer); virtual void set_data1f(unsigned char *pointer, float data); virtual void set_data2f(unsigned char *pointer, const LVecBase2f &data); @@ -138,10 +138,10 @@ private: virtual void set_data3d(unsigned char *pointer, const LVecBase3d &data); virtual void set_data4d(unsigned char *pointer, const LVecBase4d &data); - virtual void set_data1i(unsigned char *pointer, int a); - virtual void set_data2i(unsigned char *pointer, int a, int b); - virtual void set_data3i(unsigned char *pointer, int a, int b, int c); - virtual void set_data4i(unsigned char *pointer, int a, int b, int c, int d); + virtual void set_data1i(unsigned char *pointer, int data); + virtual void set_data2i(unsigned char *pointer, const LVecBase2i &data); + virtual void set_data3i(unsigned char *pointer, const LVecBase3i &data); + virtual void set_data4i(unsigned char *pointer, const LVecBase4i &data); virtual const char *get_name() const { return "Packer"; @@ -178,7 +178,9 @@ private: LVecBase2d _v2d; LVecBase3d _v3d; LVecBase4d _v4d; - int _i[4]; + LVecBase2i _v2i; + LVecBase3i _v3i; + LVecBase4i _v4i; unsigned int _a, _b, _c, _d; }; diff --git a/panda/src/gobj/geomVertexData.cxx b/panda/src/gobj/geomVertexData.cxx index 69ef264418..08e6fdc200 100644 --- a/panda/src/gobj/geomVertexData.cxx +++ b/panda/src/gobj/geomVertexData.cxx @@ -699,7 +699,7 @@ copy_from(const GeomVertexData *source, bool keep_data_objects, while (!from.is_at_end()) { const TransformBlend &blend = blend_table->get_blend(from.get_data1i()); LVecBase4 weights = LVecBase4::zero(); - int indices[4] = {0, 0, 0, 0}; + LVecBase4i indices(0, 0, 0, 0); nassertv(blend.get_num_transforms() <= 4); for (int i = 0; i < blend.get_num_transforms(); i++) { diff --git a/panda/src/gobj/geomVertexReader.I b/panda/src/gobj/geomVertexReader.I index 4e757a0d2a..1c19429d51 100644 --- a/panda/src/gobj/geomVertexReader.I +++ b/panda/src/gobj/geomVertexReader.I @@ -660,9 +660,9 @@ get_data1i() { // expressed as a 2-component value, and advances the // read row. //////////////////////////////////////////////////////////////////// -INLINE const int *GeomVertexReader:: +INLINE const LVecBase2i &GeomVertexReader:: get_data2i() { - nassertr(has_column(), 0); + nassertr(has_column(), LVecBase2i::zero()); return _packer->get_data2i(inc_pointer()); } @@ -673,9 +673,9 @@ get_data2i() { // expressed as a 3-component value, and advances the // read row. //////////////////////////////////////////////////////////////////// -INLINE const int *GeomVertexReader:: +INLINE const LVecBase3i &GeomVertexReader:: get_data3i() { - nassertr(has_column(), 0); + nassertr(has_column(), LVecBase3i::zero()); return _packer->get_data3i(inc_pointer()); } @@ -686,9 +686,9 @@ get_data3i() { // expressed as a 4-component value, and advances the // read row. //////////////////////////////////////////////////////////////////// -INLINE const int *GeomVertexReader:: +INLINE const LVecBase4i &GeomVertexReader:: get_data4i() { - nassertr(has_column(), 0); + nassertr(has_column(), LVecBase4i::zero()); return _packer->get_data4i(inc_pointer()); } diff --git a/panda/src/gobj/geomVertexReader.h b/panda/src/gobj/geomVertexReader.h index 74d3071cf4..d2f8611dfb 100644 --- a/panda/src/gobj/geomVertexReader.h +++ b/panda/src/gobj/geomVertexReader.h @@ -122,9 +122,9 @@ PUBLISHED: INLINE const LVecBase4 &get_data4(); INLINE int get_data1i(); - INLINE const int *get_data2i(); - INLINE const int *get_data3i(); - INLINE const int *get_data4i(); + INLINE const LVecBase2i &get_data2i(); + INLINE const LVecBase3i &get_data3i(); + INLINE const LVecBase4i &get_data4i(); void output(ostream &out) const; diff --git a/panda/src/gobj/geomVertexWriter.I b/panda/src/gobj/geomVertexWriter.I index 27fdf40206..bb5928cfbe 100644 --- a/panda/src/gobj/geomVertexWriter.I +++ b/panda/src/gobj/geomVertexWriter.I @@ -792,8 +792,7 @@ set_data1i(int data) { //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: set_data2i(int a, int b) { - nassertv(has_column()); - _packer->set_data2i(inc_pointer(), a, b); + set_data2i(LVecBase2i(a, b)); } //////////////////////////////////////////////////////////////////// @@ -806,8 +805,9 @@ set_data2i(int a, int b) { // the end of data. //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: -set_data2i(const int data[2]) { - set_data2i(data[0], data[1]); +set_data2i(const LVecBase2i &data) { + nassertv(has_column()); + _packer->set_data2i(inc_pointer(), data); } //////////////////////////////////////////////////////////////////// @@ -821,8 +821,7 @@ set_data2i(const int data[2]) { //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: set_data3i(int a, int b, int c) { - nassertv(has_column()); - _packer->set_data3i(inc_pointer(), a, b, c); + set_data3i(LVecBase3i(a, b, c)); } //////////////////////////////////////////////////////////////////// @@ -835,8 +834,9 @@ set_data3i(int a, int b, int c) { // the end of data. //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: -set_data3i(const int data[3]) { - set_data3i(data[0], data[1], data[2]); +set_data3i(const LVecBase3i &data) { + nassertv(has_column()); + _packer->set_data3i(inc_pointer(), data); } //////////////////////////////////////////////////////////////////// @@ -850,8 +850,7 @@ set_data3i(const int data[3]) { //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: set_data4i(int a, int b, int c, int d) { - nassertv(has_column()); - _packer->set_data4i(inc_pointer(), a, b, c, d); + set_data4i(LVecBase4i(a, b, c, d)); } //////////////////////////////////////////////////////////////////// @@ -864,8 +863,9 @@ set_data4i(int a, int b, int c, int d) { // the end of data. //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: -set_data4i(const int data[4]) { - set_data4i(data[0], data[1], data[2], data[3]); +set_data4i(const LVecBase4i &data) { + nassertv(has_column()); + _packer->set_data4i(inc_pointer(), data); } //////////////////////////////////////////////////////////////////// @@ -1224,8 +1224,7 @@ add_data1i(int data) { //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: add_data2i(int a, int b) { - nassertv(has_column()); - _packer->set_data2i(inc_add_pointer(), a, b); + add_data2i(LVecBase2i(a, b)); } //////////////////////////////////////////////////////////////////// @@ -1239,7 +1238,22 @@ add_data2i(int a, int b) { //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: add_data2i(const int data[2]) { - add_data2i(data[0], data[1]); + add_data2i(LVecBase2i(data[0], data[1])); +} + +//////////////////////////////////////////////////////////////////// +// Function: GeomVertexWriter::add_data2i +// Access: Published +// Description: Sets the write row to a particular 2-component +// value, and advances the write row. +// +// If the write row advances past the end of data, +// implicitly adds a new row to the data. +//////////////////////////////////////////////////////////////////// +INLINE void GeomVertexWriter:: +add_data2i(const LVecBase2i &data) { + nassertv(has_column()); + _packer->set_data2i(inc_add_pointer(), data); } //////////////////////////////////////////////////////////////////// @@ -1253,8 +1267,7 @@ add_data2i(const int data[2]) { //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: add_data3i(int a, int b, int c) { - nassertv(has_column()); - _packer->set_data3i(inc_add_pointer(), a, b, c); + add_data3i(LVecBase3i(a, b, c)); } //////////////////////////////////////////////////////////////////// @@ -1268,7 +1281,22 @@ add_data3i(int a, int b, int c) { //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: add_data3i(const int data[3]) { - add_data3i(data[0], data[1], data[2]); + add_data3i(LVecBase3i(data[0], data[1], data[2])); +} + +//////////////////////////////////////////////////////////////////// +// Function: GeomVertexWriter::add_data3i +// Access: Published +// Description: Sets the write row to a particular 3-component +// value, and advances the write row. +// +// If the write row advances past the end of data, +// implicitly adds a new row to the data. +//////////////////////////////////////////////////////////////////// +INLINE void GeomVertexWriter:: +add_data3i(const LVecBase3i &data) { + nassertv(has_column()); + _packer->set_data3i(inc_add_pointer(), data); } //////////////////////////////////////////////////////////////////// @@ -1282,8 +1310,7 @@ add_data3i(const int data[3]) { //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: add_data4i(int a, int b, int c, int d) { - nassertv(has_column()); - _packer->set_data4i(inc_add_pointer(), a, b, c, d); + add_data4i(LVecBase4i(a, b, c, d)); } //////////////////////////////////////////////////////////////////// @@ -1297,7 +1324,22 @@ add_data4i(int a, int b, int c, int d) { //////////////////////////////////////////////////////////////////// INLINE void GeomVertexWriter:: add_data4i(const int data[4]) { - add_data4i(data[0], data[1], data[2], data[3]); + add_data4i(LVecBase4i(data[0], data[1], data[2], data[3])); +} + +//////////////////////////////////////////////////////////////////// +// Function: GeomVertexWriter::add_data4i +// Access: Published +// Description: Sets the write row to a particular 4-component +// value, and advances the write row. +// +// If the write row advances past the end of data, +// implicitly adds a new row to the data. +//////////////////////////////////////////////////////////////////// +INLINE void GeomVertexWriter:: +add_data4i(const LVecBase4i &data) { + nassertv(has_column()); + _packer->set_data4i(inc_add_pointer(), data); } //////////////////////////////////////////////////////////////////// diff --git a/panda/src/gobj/geomVertexWriter.h b/panda/src/gobj/geomVertexWriter.h index 34978847b3..23ace2e13e 100644 --- a/panda/src/gobj/geomVertexWriter.h +++ b/panda/src/gobj/geomVertexWriter.h @@ -142,11 +142,11 @@ PUBLISHED: INLINE void set_data1i(int data); INLINE void set_data2i(int a, int b); - INLINE void set_data2i(const int data[2]); + INLINE void set_data2i(const LVecBase2i &data); INLINE void set_data3i(int a, int b, int c); - INLINE void set_data3i(const int data[3]); + INLINE void set_data3i(const LVecBase3i &data); INLINE void set_data4i(int a, int b, int c, int d); - INLINE void set_data4i(const int data[4]); + INLINE void set_data4i(const LVecBase4i &data); INLINE void add_data1f(float data); INLINE void add_data2f(float x, float y); @@ -175,10 +175,13 @@ PUBLISHED: INLINE void add_data1i(int data); INLINE void add_data2i(int a, int b); INLINE void add_data2i(const int data[2]); + INLINE void add_data2i(const LVecBase2i &data); INLINE void add_data3i(int a, int b, int c); INLINE void add_data3i(const int data[3]); + INLINE void add_data3i(const LVecBase3i &data); INLINE void add_data4i(int a, int b, int c, int d); INLINE void add_data4i(const int data[4]); + INLINE void add_data4i(const LVecBase4i &data); void output(ostream &out) const; diff --git a/panda/src/linmath/Sources.pp b/panda/src/linmath/Sources.pp index 9c5a1c9548..0e84fb271e 100644 --- a/panda/src/linmath/Sources.pp +++ b/panda/src/linmath/Sources.pp @@ -14,7 +14,7 @@ compose_matrix_src.cxx compose_matrix_src.h config_linmath.h \ coordinateSystem.h dbl2fltnames.h dblnames.h \ deg_2_rad.h deg_2_rad.I \ - flt2dblnames.h fltnames.h lcast_to.h lcast_to_src.h \ + flt2dblnames.h fltnames.h intnames.h lcast_to.h lcast_to_src.h \ lcast_to_src.I lmatrix.h lmatrix_ext.h lmatrix3_src.I \ lmatrix3_src.cxx lmatrix3_src.h lmatrix4_src.I \ lmatrix4_src.cxx lmatrix4_src.h lorientation.h \ @@ -56,7 +56,7 @@ compose_matrix_src.h config_linmath.h coordinateSystem.h \ dbl2fltnames.h dblnames.h \ deg_2_rad.h deg_2_rad.I \ - flt2dblnames.h fltnames.h lcast_to.h lcast_to_src.I lcast_to_src.h \ + flt2dblnames.h fltnames.h intnames.h lcast_to.h lcast_to_src.I lcast_to_src.h \ lmat_ops.h lmat_ops_src.I lmat_ops_src.h lmatrix.h \ lmatrix3_src.I lmatrix3_src.h lmatrix4_src.I \ lmatrix4_src.h lorientation.h lorientation_src.I \ diff --git a/panda/src/linmath/config_linmath.cxx b/panda/src/linmath/config_linmath.cxx index ca15d71f91..8aab5f0568 100644 --- a/panda/src/linmath/config_linmath.cxx +++ b/panda/src/linmath/config_linmath.cxx @@ -88,6 +88,17 @@ init_liblinmath() { UnalignedLVecBase4d::init_type(); UnalignedLMatrix4d::init_type(); + LVecBase2i::init_type(); + LVecBase3i::init_type(); + LVecBase4i::init_type(); + LVector2i::init_type(); + LVector3i::init_type(); + LVector4i::init_type(); + LPoint2i::init_type(); + LPoint3i::init_type(); + LPoint4i::init_type(); + UnalignedLVecBase4i::init_type(); + LQuaternionf::init_type(); LRotationf::init_type(); LOrientationf::init_type(); diff --git a/panda/src/linmath/dblnames.h b/panda/src/linmath/dblnames.h index 9d089bd5a5..cb841dd977 100644 --- a/panda/src/linmath/dblnames.h +++ b/panda/src/linmath/dblnames.h @@ -37,9 +37,9 @@ #undef FLOATNAME #undef FLOATTOKEN #undef FLOATCONST +#undef FLOATTYPE_IS_INT #define FLOATTYPE double #define FLOATNAME(ARG) ARG##d #define FLOATTOKEN 'd' #define FLOATCONST(ARG) ARG - diff --git a/panda/src/linmath/fltnames.h b/panda/src/linmath/fltnames.h index 98946f7977..b6aae8bd3e 100644 --- a/panda/src/linmath/fltnames.h +++ b/panda/src/linmath/fltnames.h @@ -37,6 +37,7 @@ #undef FLOATNAME #undef FLOATTOKEN #undef FLOATCONST +#undef FLOATTYPE_IS_INT #define FLOATTYPE float #define FLOATNAME(ARG) ARG##f diff --git a/panda/src/linmath/intnames.h b/panda/src/linmath/intnames.h new file mode 100644 index 0000000000..1ae59f275a --- /dev/null +++ b/panda/src/linmath/intnames.h @@ -0,0 +1,46 @@ +// Filename: intnames.h +// Created by: rdb (07Jun14) +// +//////////////////////////////////////////////////////////////////// +// +// PANDA 3D SOFTWARE +// Copyright (c) Carnegie Mellon University. All rights reserved. +// +// All use of this software is subject to the terms of the revised BSD +// license. You should have received a copy of this license along +// with this source code in a file named "LICENSE." +// +//////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////// +// +// This file is used throughout this directory, in conjunction with +// dblnames.h, to implement a poor man's template of the linmath +// objects on numeric type. The idea is to #include either fltnames.h +// or dblnames.h (or, in theory, intnames.h or any other numeric type +// we wanted to implement) and then to include the various *_src.h +// and/or *_src.cxx files that actually define the linmath objects. +// +// We do this instead of using actual templates to avoid some of the +// inherent problems with templates: compiler complexity and +// distributed code bloat, for instance; plus it allows us to +// implement #if-based specialization on numeric type for compilers +// (like VC++) that don't completely support template specialization. +// That and the fact that VC++ seems to have a particularly bad time +// with templates in general. +// +//////////////////////////////////////////////////////////////////// + + +#undef FLOATTYPE +#undef FLOATNAME +#undef FLOATTOKEN +#undef FLOATCONST +#undef FLOATTYPE_IS_INT + +#define FLOATTYPE int +#define FLOATNAME(ARG) ARG##i +#define FLOATTOKEN 'i' +#define FLOATCONST(ARG) ARG +#define FLOATTYPE_IS_INT diff --git a/panda/src/linmath/lpoint2.cxx b/panda/src/linmath/lpoint2.cxx index 64f3df5a5f..f28a903549 100644 --- a/panda/src/linmath/lpoint2.cxx +++ b/panda/src/linmath/lpoint2.cxx @@ -20,3 +20,5 @@ #include "dblnames.h" #include "lpoint2_src.cxx" +#include "intnames.h" +#include "lpoint2_src.cxx" diff --git a/panda/src/linmath/lpoint2.h b/panda/src/linmath/lpoint2.h index 500bc858fe..9384bc99de 100644 --- a/panda/src/linmath/lpoint2.h +++ b/panda/src/linmath/lpoint2.h @@ -26,5 +26,7 @@ #include "dblnames.h" #include "lpoint2_src.h" +#include "intnames.h" +#include "lpoint2_src.h" #endif diff --git a/panda/src/linmath/lpoint2_ext.h b/panda/src/linmath/lpoint2_ext.h index 006697f0c0..c4a1a068e5 100644 --- a/panda/src/linmath/lpoint2_ext.h +++ b/panda/src/linmath/lpoint2_ext.h @@ -26,4 +26,7 @@ #include "dblnames.h" #include "lpoint2_ext_src.h" +#include "intnames.h" +#include "lpoint2_ext_src.h" + #endif diff --git a/panda/src/linmath/lpoint2_ext_src.I b/panda/src/linmath/lpoint2_ext_src.I index 195c1b38d9..d6deaa3a8b 100644 --- a/panda/src/linmath/lpoint2_ext_src.I +++ b/panda/src/linmath/lpoint2_ext_src.I @@ -18,6 +18,16 @@ IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LPoint3); IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LPoint4); #endif +#ifdef FLOATTYPE_IS_INT +#if PY_MAJOR_VERSION >= 3 +#define PY_FROM_FLOATTYPE PyLong_FromLong +#else +#define PY_FROM_FLOATTYPE PyInt_FromLong +#endif +#else +#define PY_FROM_FLOATTYPE PyFloat_FromDouble +#endif + //////////////////////////////////////////////////////////////////// // Function: LPoint2::python_repr // Access: Published @@ -46,7 +56,7 @@ __getattr__(const string &attr_name) const { switch (attr_name.size()) { case 1: - return PyFloat_FromDouble(_this->_v(attr_name[0] - 'x')); + return PY_FROM_FLOATTYPE(_this->_v(attr_name[0] - 'x')); case 2: { FLOATNAME(LPoint2) *vec = new FLOATNAME(LPoint2); @@ -84,3 +94,5 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { // Upcall to LVecBase2. return invoke_extension(_this).__setattr__(self, attr_name, assign); } + +#undef PY_FROM_FLOATTYPE diff --git a/panda/src/linmath/lpoint2_src.I b/panda/src/linmath/lpoint2_src.I index 9184b5adab..a3f27084f6 100644 --- a/panda/src/linmath/lpoint2_src.I +++ b/panda/src/linmath/lpoint2_src.I @@ -185,6 +185,7 @@ operator / (FLOATTYPE scalar) const { return FLOATNAME(LPoint2)(FLOATNAME(LVecBase2)::operator / (scalar)); } +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LPoint2::project // Access: Published @@ -196,3 +197,4 @@ INLINE_LINMATH FLOATNAME(LPoint2) FLOATNAME(LPoint2):: project(const FLOATNAME(LVecBase2) &onto) const { return FLOATNAME(LVecBase2)::project(onto); } +#endif // FLOATTYPE_IS_INT diff --git a/panda/src/linmath/lpoint2_src.h b/panda/src/linmath/lpoint2_src.h index 7d726e4f33..5218cfc483 100644 --- a/panda/src/linmath/lpoint2_src.h +++ b/panda/src/linmath/lpoint2_src.h @@ -49,7 +49,10 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LPoint2) operator * (FLOATTYPE scalar) const; INLINE_LINMATH FLOATNAME(LPoint2) operator / (FLOATTYPE scalar) const; + +#ifndef FLOATTYPE_IS_INT INLINE_LINMATH FLOATNAME(LPoint2) project(const FLOATNAME(LVecBase2) &onto) const; +#endif EXTENSION(INLINE_LINMATH void python_repr(ostream &out, const string &class_name) const); diff --git a/panda/src/linmath/lpoint3.cxx b/panda/src/linmath/lpoint3.cxx index f6e59d4857..8caa5a8b0f 100644 --- a/panda/src/linmath/lpoint3.cxx +++ b/panda/src/linmath/lpoint3.cxx @@ -20,3 +20,5 @@ #include "dblnames.h" #include "lpoint3_src.cxx" +#include "intnames.h" +#include "lpoint3_src.cxx" diff --git a/panda/src/linmath/lpoint3.h b/panda/src/linmath/lpoint3.h index 06d90128c4..a458777bd8 100644 --- a/panda/src/linmath/lpoint3.h +++ b/panda/src/linmath/lpoint3.h @@ -28,5 +28,7 @@ #include "dblnames.h" #include "lpoint3_src.h" +#include "intnames.h" +#include "lpoint3_src.h" #endif diff --git a/panda/src/linmath/lpoint3_ext.h b/panda/src/linmath/lpoint3_ext.h index 0f4c860b9e..5ba6d499c1 100644 --- a/panda/src/linmath/lpoint3_ext.h +++ b/panda/src/linmath/lpoint3_ext.h @@ -26,4 +26,7 @@ #include "dblnames.h" #include "lpoint3_ext_src.h" +#include "intnames.h" +#include "lpoint3_ext_src.h" + #endif diff --git a/panda/src/linmath/lpoint3_ext_src.I b/panda/src/linmath/lpoint3_ext_src.I index 19f32de4e7..583c4ff55a 100644 --- a/panda/src/linmath/lpoint3_ext_src.I +++ b/panda/src/linmath/lpoint3_ext_src.I @@ -18,6 +18,16 @@ IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LPoint3); IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LPoint4); #endif +#ifdef FLOATTYPE_IS_INT +#if PY_MAJOR_VERSION >= 3 +#define PY_FROM_FLOATTYPE PyLong_FromLong +#else +#define PY_FROM_FLOATTYPE PyInt_FromLong +#endif +#else +#define PY_FROM_FLOATTYPE PyFloat_FromDouble +#endif + //////////////////////////////////////////////////////////////////// // Function: LPoint3::python_repr // Access: Published @@ -47,7 +57,7 @@ __getattr__(const string &attr_name) const { switch (attr_name.size()) { case 1: - return PyFloat_FromDouble(_this->_v(attr_name[0] - 'x')); + return PY_FROM_FLOATTYPE(_this->_v(attr_name[0] - 'x')); case 2: { FLOATNAME(LPoint2) *vec = new FLOATNAME(LPoint2); @@ -85,3 +95,5 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { // Upcall to LVecBase2. return invoke_extension(_this).__setattr__(self, attr_name, assign); } + +#undef PY_FROM_FLOATTYPE diff --git a/panda/src/linmath/lpoint3_src.I b/panda/src/linmath/lpoint3_src.I index d8fdec75a9..9f8143c7d7 100644 --- a/panda/src/linmath/lpoint3_src.I +++ b/panda/src/linmath/lpoint3_src.I @@ -75,6 +75,17 @@ FLOATNAME(LPoint3)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z) : { } +//////////////////////////////////////////////////////////////////// +// Function: LPoint3::Constructor +// Access: Published +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATNAME(LPoint3):: +FLOATNAME(LPoint3)(const FLOATNAME(LVecBase2) ©, FLOATTYPE z) : + FLOATNAME(LVecBase3)(copy, z) +{ +} + //////////////////////////////////////////////////////////////////// // Function: LPoint3::zero Named Constructor // Access: Public @@ -218,6 +229,7 @@ cross(const FLOATNAME(LVecBase3) &other) const { return FLOATNAME(LVecBase3)::cross(other); } +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LPoint3::project // Access: Published @@ -229,6 +241,7 @@ INLINE_LINMATH FLOATNAME(LPoint3) FLOATNAME(LPoint3):: project(const FLOATNAME(LVecBase3) &onto) const { return FLOATNAME(LVecBase3)::project(onto); } +#endif // FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LPoint3::operator * scalar @@ -258,9 +271,9 @@ operator / (FLOATTYPE scalar) const { // existing coordinate systems; it's hard to imagine it // ever being different. //////////////////////////////////////////////////////////////////// -INLINE_LINMATH FLOATNAME(LPoint3) FLOATNAME(LPoint3):: +INLINE_LINMATH const FLOATNAME(LPoint3) &FLOATNAME(LPoint3):: origin(CoordinateSystem) { - return FLOATNAME(LPoint3)(0.0f, 0.0f, 0.0f); + return FLOATNAME(LPoint3)::zero(); } //////////////////////////////////////////////////////////////////// diff --git a/panda/src/linmath/lpoint3_src.h b/panda/src/linmath/lpoint3_src.h index ce1852bda5..11c1ccc29d 100644 --- a/panda/src/linmath/lpoint3_src.h +++ b/panda/src/linmath/lpoint3_src.h @@ -30,6 +30,7 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LPoint3) &operator = (FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LPoint3)(FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LPoint3)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z); + INLINE_LINMATH FLOATNAME(LPoint3)(const FLOATNAME(LVecBase2) ©, FLOATTYPE z); EXTENSION(INLINE_LINMATH PyObject *__getattr__(const string &attr_name) const); EXTENSION(INLINE_LINMATH int __setattr__(PyObject *self, const string &attr_name, PyObject *assign)); @@ -58,13 +59,17 @@ PUBLISHED: operator - (const FLOATNAME(LVector3) &other) const; INLINE_LINMATH FLOATNAME(LPoint3) cross(const FLOATNAME(LVecBase3) &other) const; + +#ifndef FLOATTYPE_IS_INT INLINE_LINMATH FLOATNAME(LPoint3) project(const FLOATNAME(LVecBase3) &onto) const; +#endif + INLINE_LINMATH FLOATNAME(LPoint3) operator * (FLOATTYPE scalar) const; INLINE_LINMATH FLOATNAME(LPoint3) operator / (FLOATTYPE scalar) const; // Some special named constructors for LPoint3. - INLINE_LINMATH static FLOATNAME(LPoint3) origin(CoordinateSystem cs = CS_default); + INLINE_LINMATH static const FLOATNAME(LPoint3) &origin(CoordinateSystem cs = CS_default); INLINE_LINMATH static FLOATNAME(LPoint3) rfu(FLOATTYPE right, FLOATTYPE fwd, FLOATTYPE up, diff --git a/panda/src/linmath/lpoint4.cxx b/panda/src/linmath/lpoint4.cxx index 242c365715..373cf273d3 100644 --- a/panda/src/linmath/lpoint4.cxx +++ b/panda/src/linmath/lpoint4.cxx @@ -20,3 +20,5 @@ #include "dblnames.h" #include "lpoint4_src.cxx" +#include "intnames.h" +#include "lpoint4_src.cxx" diff --git a/panda/src/linmath/lpoint4.h b/panda/src/linmath/lpoint4.h index 097712a6e5..f7b69f02ec 100644 --- a/panda/src/linmath/lpoint4.h +++ b/panda/src/linmath/lpoint4.h @@ -26,4 +26,7 @@ #include "dblnames.h" #include "lpoint4_src.h" +#include "intnames.h" +#include "lpoint4_src.h" + #endif diff --git a/panda/src/linmath/lpoint4_ext.h b/panda/src/linmath/lpoint4_ext.h index ac51d90156..31704152a4 100644 --- a/panda/src/linmath/lpoint4_ext.h +++ b/panda/src/linmath/lpoint4_ext.h @@ -26,4 +26,7 @@ #include "dblnames.h" #include "lpoint4_ext_src.h" +#include "intnames.h" +#include "lpoint4_ext_src.h" + #endif diff --git a/panda/src/linmath/lpoint4_ext_src.I b/panda/src/linmath/lpoint4_ext_src.I index 841e1271b2..c34af5986e 100644 --- a/panda/src/linmath/lpoint4_ext_src.I +++ b/panda/src/linmath/lpoint4_ext_src.I @@ -18,6 +18,16 @@ IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LPoint3); IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LPoint4); #endif +#ifdef FLOATTYPE_IS_INT +#if PY_MAJOR_VERSION >= 3 +#define PY_FROM_FLOATTYPE PyLong_FromLong +#else +#define PY_FROM_FLOATTYPE PyInt_FromLong +#endif +#else +#define PY_FROM_FLOATTYPE PyFloat_FromDouble +#endif + //////////////////////////////////////////////////////////////////// // Function: LPoint4::python_repr // Access: Published @@ -49,9 +59,9 @@ __getattr__(const string &attr_name) const { switch (attr_name.size()) { case 1: if (attr_name[0] == 'w') { - return PyFloat_FromDouble(_this->_v(3)); + return PY_FROM_FLOATTYPE(_this->_v(3)); } else { - return PyFloat_FromDouble(_this->_v(attr_name[0] - 'x')); + return PY_FROM_FLOATTYPE(_this->_v(attr_name[0] - 'x')); } case 2: { @@ -90,3 +100,5 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { // Upcall to LVecBase4. return invoke_extension(_this).__setattr__(self, attr_name, assign); } + +#undef PY_FROM_FLOATTYPE diff --git a/panda/src/linmath/lpoint4_src.I b/panda/src/linmath/lpoint4_src.I index f9e2819a13..d1a7e7b3ab 100644 --- a/panda/src/linmath/lpoint4_src.I +++ b/panda/src/linmath/lpoint4_src.I @@ -75,6 +75,17 @@ FLOATNAME(LPoint4)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z, FLOATTYPE w) : { } +//////////////////////////////////////////////////////////////////// +// Function: LPoint4::Constructor +// Access: Published +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATNAME(LPoint4):: +FLOATNAME(LPoint4)(const FLOATNAME(LVecBase3) ©, FLOATTYPE w) : + FLOATNAME(LVecBase4)(copy, w) +{ +} + //////////////////////////////////////////////////////////////////// // Function: LPoint4::zero Named Constructor // Access: Public @@ -205,6 +216,7 @@ operator / (FLOATTYPE scalar) const { return FLOATNAME(LPoint4)(FLOATNAME(LVecBase4)::operator / (scalar)); } +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LPoint4::project // Access: Published @@ -216,4 +228,4 @@ INLINE_LINMATH FLOATNAME(LPoint4) FLOATNAME(LPoint4):: project(const FLOATNAME(LVecBase4) &onto) const { return FLOATNAME(LVecBase4)::project(onto); } - +#endif // FLOATTYPE_IS_INT diff --git a/panda/src/linmath/lpoint4_src.h b/panda/src/linmath/lpoint4_src.h index 04404b8713..877c3fe766 100644 --- a/panda/src/linmath/lpoint4_src.h +++ b/panda/src/linmath/lpoint4_src.h @@ -24,6 +24,7 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LPoint4) &operator = (FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LPoint4)(FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LPoint4)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z, FLOATTYPE w); + INLINE_LINMATH FLOATNAME(LPoint4)(const FLOATNAME(LVecBase3) ©, FLOATTYPE w); EXTENSION(INLINE_LINMATH PyObject *__getattr__(const string &attr_name) const); EXTENSION(INLINE_LINMATH int __setattr__(PyObject *self, const string &attr_name, PyObject *assign)); @@ -50,7 +51,10 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LPoint4) operator * (FLOATTYPE scalar) const; INLINE_LINMATH FLOATNAME(LPoint4) operator / (FLOATTYPE scalar) const; + +#ifndef FLOATTYPE_IS_INT INLINE_LINMATH FLOATNAME(LPoint4) project(const FLOATNAME(LVecBase4) &onto) const; +#endif EXTENSION(INLINE_LINMATH void python_repr(ostream &out, const string &class_name) const); diff --git a/panda/src/linmath/luse.N b/panda/src/linmath/luse.N index 7b82e0ac27..20da19f1c8 100644 --- a/panda/src/linmath/luse.N +++ b/panda/src/linmath/luse.N @@ -2,23 +2,32 @@ defconstruct LPoint2f new LPoint2f(0.0f) defconstruct LPoint3f new LPoint3f(0.0f) defconstruct LPoint4f new LPoint4f(0.0f) -defconstruct LPoint2d new LPoint2d(0.0f) -defconstruct LPoint3d new LPoint3d(0.0f) -defconstruct LPoint4d new LPoint4d(0.0f) +defconstruct LPoint2d new LPoint2d(0.0) +defconstruct LPoint3d new LPoint3d(0.0) +defconstruct LPoint4d new LPoint4d(0.0) +defconstruct LPoint2i new LPoint2i(0) +defconstruct LPoint3i new LPoint3i(0) +defconstruct LPoint4i new LPoint4i(0) defconstruct LVecBase2f new LVecBase2f(0.0f) defconstruct LVecBase3f new LVecBase3f(0.0f) defconstruct LVecBase4f new LVecBase4f(0.0f) -defconstruct LVecBase2d new LVecBase2d(0.0f) -defconstruct LVecBase3d new LVecBase3d(0.0f) -defconstruct LVecBase4d new LVecBase4d(0.0f) +defconstruct LVecBase2d new LVecBase2d(0.0) +defconstruct LVecBase3d new LVecBase3d(0.0) +defconstruct LVecBase4d new LVecBase4d(0.0) +defconstruct LVecBase2i new LVecBase2i(0) +defconstruct LVecBase3i new LVecBase3i(0) +defconstruct LVecBase4i new LVecBase4i(0) defconstruct LVector2f new LVector2f(0.0f) defconstruct LVector3f new LVector3f(0.0f) defconstruct LVector4f new LVector4f(0.0f) -defconstruct LVector2d new LVector2d(0.0f) -defconstruct LVector3d new LVector3d(0.0f) -defconstruct LVector4d new LVector4d(0.0f) +defconstruct LVector2d new LVector2d(0.0) +defconstruct LVector3d new LVector3d(0.0) +defconstruct LVector4d new LVector4d(0.0) +defconstruct LVector2i new LVector2i(0) +defconstruct LVector3i new LVector3i(0) +defconstruct LVector4i new LVector4i(0) defconstruct LMatrix3f new LMatrix3f(LMatrix3f::ident_mat()) defconstruct LMatrix4f new LMatrix4f(LMatrix4f::ident_mat()) diff --git a/panda/src/linmath/lvec2_ops.h b/panda/src/linmath/lvec2_ops.h index 89b31baba4..819bc7bf59 100644 --- a/panda/src/linmath/lvec2_ops.h +++ b/panda/src/linmath/lvec2_ops.h @@ -27,4 +27,7 @@ #include "dblnames.h" #include "lvec2_ops_src.h" +#include "intnames.h" +#include "lvec2_ops_src.h" + #endif diff --git a/panda/src/linmath/lvec2_ops_src.I b/panda/src/linmath/lvec2_ops_src.I index 3ca435033c..de3e19cab3 100644 --- a/panda/src/linmath/lvec2_ops_src.I +++ b/panda/src/linmath/lvec2_ops_src.I @@ -48,6 +48,7 @@ dot(const FLOATNAME(LVecBase2) &a, const FLOATNAME(LVecBase2) &b) { return a.dot(b); } +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: length of a vector // Description: @@ -67,7 +68,7 @@ normalize(const FLOATNAME(LVector2) &v) { v1.normalize(); return v1; } - +#endif // FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: generic_write_datagram diff --git a/panda/src/linmath/lvec2_ops_src.h b/panda/src/linmath/lvec2_ops_src.h index 150345c47f..fe65dd8862 100644 --- a/panda/src/linmath/lvec2_ops_src.h +++ b/panda/src/linmath/lvec2_ops_src.h @@ -33,14 +33,15 @@ operator * (FLOATTYPE scalar, const FLOATNAME(LVector2) &a); INLINE_LINMATH FLOATTYPE dot(const FLOATNAME(LVecBase2) &a, const FLOATNAME(LVecBase2) &b); +#ifndef FLOATTYPE_IS_INT // Length of a vector. INLINE_LINMATH FLOATTYPE length(const FLOATNAME(LVector2) &a); - // A normalized vector. INLINE_LINMATH FLOATNAME(LVector2) normalize(const FLOATNAME(LVector2) &v); +#endif // FLOATTYPE_IS_INT INLINE_LINMATH void generic_write_datagram(Datagram &dest, const FLOATNAME(LVecBase2) &value); diff --git a/panda/src/linmath/lvec3_ops.h b/panda/src/linmath/lvec3_ops.h index 24f34ed842..e6b394e297 100644 --- a/panda/src/linmath/lvec3_ops.h +++ b/panda/src/linmath/lvec3_ops.h @@ -27,5 +27,7 @@ #include "dblnames.h" #include "lvec3_ops_src.h" +#include "intnames.h" +#include "lvec3_ops_src.h" #endif diff --git a/panda/src/linmath/lvec3_ops_src.I b/panda/src/linmath/lvec3_ops_src.I index 8e978679d1..b68b8064d4 100644 --- a/panda/src/linmath/lvec3_ops_src.I +++ b/panda/src/linmath/lvec3_ops_src.I @@ -70,7 +70,7 @@ cross(const FLOATNAME(LVector3) &a, const FLOATNAME(LVector3) &b) { return FLOATNAME(LVector3)(a.cross(b)); } - +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: length of a vector // Description: @@ -81,7 +81,6 @@ length(const FLOATNAME(LVecBase3) &a) { return a.length(); } - //////////////////////////////////////////////////////////////////// // Function: normalize // Description: Returns a normalized vector from the given vector. @@ -93,6 +92,7 @@ normalize(const FLOATNAME(LVecBase3) &v) { v1.normalize(); return v1; } +#endif // FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: generic_write_datagram diff --git a/panda/src/linmath/lvec3_ops_src.h b/panda/src/linmath/lvec3_ops_src.h index 797d0bb17a..e3cdb4b0b7 100644 --- a/panda/src/linmath/lvec3_ops_src.h +++ b/panda/src/linmath/lvec3_ops_src.h @@ -41,7 +41,7 @@ cross(const FLOATNAME(LVecBase3) &a, const FLOATNAME(LVecBase3) &b); INLINE_LINMATH FLOATNAME(LVector3) cross(const FLOATNAME(LVector3) &a, const FLOATNAME(LVector3) &b); - +#ifndef FLOATTYPE_IS_INT // Length of a vector. INLINE_LINMATH FLOATTYPE length(const FLOATNAME(LVecBase3) &a); @@ -49,6 +49,7 @@ length(const FLOATNAME(LVecBase3) &a); // A normalized vector. INLINE_LINMATH FLOATNAME(LVector3) normalize(const FLOATNAME(LVecBase3) &v); +#endif // FLOATTYPE_IS_INT INLINE_LINMATH void generic_write_datagram(Datagram &dest, const FLOATNAME(LVecBase3) &value); diff --git a/panda/src/linmath/lvec4_ops.h b/panda/src/linmath/lvec4_ops.h index 88ed60e6b0..b020bd5df9 100644 --- a/panda/src/linmath/lvec4_ops.h +++ b/panda/src/linmath/lvec4_ops.h @@ -27,5 +27,7 @@ #include "dblnames.h" #include "lvec4_ops_src.h" +#include "intnames.h" +#include "lvec4_ops_src.h" #endif diff --git a/panda/src/linmath/lvec4_ops_src.I b/panda/src/linmath/lvec4_ops_src.I index 6f97a1f26a..2e4c72da51 100644 --- a/panda/src/linmath/lvec4_ops_src.I +++ b/panda/src/linmath/lvec4_ops_src.I @@ -49,6 +49,7 @@ dot(const FLOATNAME(LVecBase4) &a, const FLOATNAME(LVecBase4) &b) { return a.dot(b); } +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: length of a vector // Description: @@ -59,7 +60,6 @@ length(const FLOATNAME(LVector4) &a) { return a.length(); } - //////////////////////////////////////////////////////////////////// // Function: normalize // Description: Returns a normalized vector from the given vector. @@ -71,6 +71,7 @@ normalize(const FLOATNAME(LVector4) &v) { v1.normalize(); return v1; } +#endif // FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: generic_write_datagram diff --git a/panda/src/linmath/lvec4_ops_src.h b/panda/src/linmath/lvec4_ops_src.h index 425f5f3194..86ef7350aa 100644 --- a/panda/src/linmath/lvec4_ops_src.h +++ b/panda/src/linmath/lvec4_ops_src.h @@ -33,15 +33,15 @@ operator * (FLOATTYPE scalar, const FLOATNAME(LVector4) &a); INLINE_LINMATH FLOATTYPE dot(const FLOATNAME(LVecBase4) &a, const FLOATNAME(LVecBase4) &b); - +#ifndef FLOATTYPE_IS_INT // Length of a vector. INLINE_LINMATH FLOATTYPE length(const FLOATNAME(LVector4) &a); - // A normalized vector. INLINE_LINMATH FLOATNAME(LVector4) normalize(const FLOATNAME(LVector4) &v); +#endif // FLOATTYPE_IS_INT INLINE_LINMATH void generic_write_datagram(Datagram &dest, const FLOATNAME(LVecBase4) &value); diff --git a/panda/src/linmath/lvecBase2.cxx b/panda/src/linmath/lvecBase2.cxx index 77be67d08e..ad14be3a47 100644 --- a/panda/src/linmath/lvecBase2.cxx +++ b/panda/src/linmath/lvecBase2.cxx @@ -20,3 +20,5 @@ #include "dblnames.h" #include "lvecBase2_src.cxx" +#include "intnames.h" +#include "lvecBase2_src.cxx" diff --git a/panda/src/linmath/lvecBase2.h b/panda/src/linmath/lvecBase2.h index 5477236d8c..9e8d526fb5 100644 --- a/panda/src/linmath/lvecBase2.h +++ b/panda/src/linmath/lvecBase2.h @@ -16,6 +16,7 @@ #define LVECBASE2_H #include "pandabase.h" +#include "config_linmath.h" #include "typedObject.h" #include "pnotify.h" #include "datagram.h" @@ -36,4 +37,7 @@ class DatagramIterator; #include "dblnames.h" #include "lvecBase2_src.h" +#include "intnames.h" +#include "lvecBase2_src.h" + #endif diff --git a/panda/src/linmath/lvecBase2_ext.h b/panda/src/linmath/lvecBase2_ext.h index 59f06da699..9e2e262596 100644 --- a/panda/src/linmath/lvecBase2_ext.h +++ b/panda/src/linmath/lvecBase2_ext.h @@ -24,4 +24,7 @@ #include "dblnames.h" #include "lvecBase2_ext_src.h" +#include "intnames.h" +#include "lvecBase2_ext_src.h" + #endif diff --git a/panda/src/linmath/lvecBase2_ext_src.I b/panda/src/linmath/lvecBase2_ext_src.I index 6f8bef7585..7910b6aec3 100644 --- a/panda/src/linmath/lvecBase2_ext_src.I +++ b/panda/src/linmath/lvecBase2_ext_src.I @@ -19,6 +19,22 @@ IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVecBase3); IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVecBase4); #endif +#ifdef FLOATTYPE_IS_INT +#if PY_MAJOR_VERSION >= 3 +#define PYNUMBER_FLOATTYPE PyNumber_Long +#define PY_FROM_FLOATTYPE PyLong_FromLong +#define PY_AS_FLOATTYPE PyLong_AS_LONG +#else +#define PYNUMBER_FLOATTYPE PyNumber_Int +#define PY_FROM_FLOATTYPE PyInt_FromLong +#define PY_AS_FLOATTYPE PyInt_AS_LONG +#endif +#else +#define PYNUMBER_FLOATTYPE PyNumber_Float +#define PY_FROM_FLOATTYPE PyFloat_FromDouble +#define PY_AS_FLOATTYPE PyFloat_AsDouble +#endif + //////////////////////////////////////////////////////////////////// // Function: LVecBase2::__setitem__ // Access: Public @@ -59,8 +75,17 @@ __reduce__(PyObject *self) const { return NULL; } +#if FLOATTOKEN == 'i' + PyObject *result = Py_BuildValue("(O(ii))", this_class, + (*_this)[0], (*_this)[1]); +#elif FLOATTOKEN == 'f' PyObject *result = Py_BuildValue("(O(ff))", this_class, (*_this)[0], (*_this)[1]); +#else + PyObject *result = Py_BuildValue("(O(dd))", this_class, + (*_this)[0], (*_this)[1]); +#endif + Py_DECREF(this_class); return result; } @@ -81,7 +106,7 @@ __getattr__(const string &attr_name) const { switch (attr_name.size()) { case 1: - return PyFloat_FromDouble(_this->_v(attr_name[0] - 'x')); + return PY_FROM_FLOATTYPE(_this->_v(attr_name[0] - 'x')); case 2: { FLOATNAME(LVecBase2) *vec = new FLOATNAME(LVecBase2); @@ -148,14 +173,18 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { PyObject** items = PySequence_Fast_ITEMS(fast); for (size_t i = 0; i < attr_name.size(); ++i) { - PyObject* fl = PyNumber_Float(items[i]); + PyObject* fl = PYNUMBER_FLOATTYPE(items[i]); if (fl == NULL) { // Oh darn. Not when we've come this far. +#ifdef FLOATTYPE_IS_INT + PyErr_SetString(PyExc_ValueError, "a sequence of integers is required"); +#else PyErr_SetString(PyExc_ValueError, "a sequence of floats is required"); +#endif Py_DECREF(fast); return -1; } - double value = PyFloat_AS_DOUBLE(fl); + FLOATTYPE value = PY_AS_FLOATTYPE(fl); Py_DECREF(fl); _this->_v(attr_name[i] - 'x') = value; @@ -165,19 +194,23 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { } else { // Maybe it's a single floating-point value. - PyObject* fl = PyNumber_Float(assign); + PyObject* fl = PYNUMBER_FLOATTYPE(assign); if (fl == NULL) { // It's not a floating-point value either? // Sheesh, I don't know what to do with it then. if (attr_name.size() == 1) { +#ifdef FLOATTYPE_IS_INT + PyErr_SetString(PyExc_ValueError, "an integer is required"); +#else PyErr_SetString(PyExc_ValueError, "a float is required"); +#endif } else { PyErr_Format(PyExc_ValueError, "'%.200s' object is not iterable", assign->ob_type->tp_name); } return -1; } - double value = PyFloat_AS_DOUBLE(fl); + FLOATTYPE value = PY_AS_FLOATTYPE(fl); Py_DECREF(fl); // Loop through the components in the attribute name, @@ -189,3 +222,32 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { return 0; } + +//////////////////////////////////////////////////////////////////// +// Function: LVecBase2::__pow__ +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATNAME(LVecBase2) Extension:: +__pow__(FLOATTYPE exponent) const { + return FLOATNAME(LVecBase2)( + cpow(_this->_v(0), exponent), + cpow(_this->_v(1), exponent)); +} + +//////////////////////////////////////////////////////////////////// +// Function: LVecBase2::__ipow__ +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH PyObject *Extension:: +__ipow__(PyObject *self, FLOATTYPE exponent) { + _this->_v(0) = cpow(_this->_v(0), exponent); + _this->_v(1) = cpow(_this->_v(1), exponent); + Py_INCREF(self); + return self; +} + +#undef PYNUMBER_FLOATTYPE +#undef PY_FROM_FLOATTYPE +#undef PY_AS_FLOATTYPE diff --git a/panda/src/linmath/lvecBase2_ext_src.h b/panda/src/linmath/lvecBase2_ext_src.h index 65b815e04a..0e7cba9a4f 100644 --- a/panda/src/linmath/lvecBase2_ext_src.h +++ b/panda/src/linmath/lvecBase2_ext_src.h @@ -27,6 +27,9 @@ public: INLINE_LINMATH int __setattr__(PyObject *self, const string &attr_name, PyObject *assign); INLINE_LINMATH void __setitem__(int i, FLOATTYPE v); INLINE_LINMATH void python_repr(ostream &out, const string &class_name) const; + + INLINE_LINMATH FLOATNAME(LVecBase2) __pow__(FLOATTYPE exponent) const; + INLINE_LINMATH PyObject *__ipow__(PyObject *self, FLOATTYPE exponent); }; #include "lvecBase2_ext_src.I" diff --git a/panda/src/linmath/lvecBase2_src.I b/panda/src/linmath/lvecBase2_src.I index 37ad3f0f20..d4869daa13 100644 --- a/panda/src/linmath/lvecBase2_src.I +++ b/panda/src/linmath/lvecBase2_src.I @@ -123,7 +123,7 @@ INLINE_LINMATH FLOATNAME(LVecBase2):: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase2):: operator [](int i) const { - nassertr(i >= 0 && i < 2, 0.0); + nassertr(i >= 0 && i < 2, 0); return _v(i); } @@ -156,8 +156,12 @@ size() { //////////////////////////////////////////////////////////////////// INLINE_LINMATH bool FLOATNAME(LVecBase2):: is_nan() const { +#ifdef FLOATTYPE_IS_INT + return false; +#else TAU_PROFILE("bool LVecBase2::is_nan()", " ", TAU_USER); return cnan(_v(0)) || cnan(_v(1)); +#endif } //////////////////////////////////////////////////////////////////// @@ -167,7 +171,7 @@ is_nan() const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase2):: get_cell(int i) const { - nassertr(i >= 0 && i < 2, 0.0); + nassertr(i >= 0 && i < 2, 0); return _v(i); } @@ -346,18 +350,17 @@ set(FLOATTYPE x, FLOATTYPE y) { } //////////////////////////////////////////////////////////////////// -// Function: LVecBase2::length +// Function: LVecBase2::dot // Access: Published -// Description: Returns the length of the vector, by the Pythagorean -// theorem. +// Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase2):: -length() const { - TAU_PROFILE("FLOATTYPE LVecBase2::length()", " ", TAU_USER); +dot(const FLOATNAME(LVecBase2) &other) const { + TAU_PROFILE("FLOATTYPE LVecBase2::dot()", " ", TAU_USER); #ifdef HAVE_EIGEN - return _v.norm(); + return _v.dot(other._v); #else - return csqrt((*this).dot(*this)); + return _v(0) * other._v(0) + _v(1) * other._v(1); #endif // HAVE_EIGEN } @@ -377,6 +380,23 @@ length_squared() const { #endif // HAVE_EIGEN } +#ifndef FLOATTYPE_IS_INT +//////////////////////////////////////////////////////////////////// +// Function: LVecBase2::length +// Access: Published +// Description: Returns the length of the vector, by the Pythagorean +// theorem. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase2):: +length() const { + TAU_PROFILE("FLOATTYPE LVecBase2::length()", " ", TAU_USER); +#ifdef HAVE_EIGEN + return _v.norm(); +#else + return csqrt((*this).dot(*this)); +#endif // HAVE_EIGEN +} + //////////////////////////////////////////////////////////////////// // Function: LVecBase2::normalize // Access: Published @@ -398,21 +418,6 @@ normalize() { return true; } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase2::dot -// Access: Published -// Description: -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase2):: -dot(const FLOATNAME(LVecBase2) &other) const { - TAU_PROFILE("FLOATTYPE LVecBase2::dot()", " ", TAU_USER); -#ifdef HAVE_EIGEN - return _v.dot(other._v); -#else - return _v(0) * other._v(0) + _v(1) * other._v(1); -#endif // HAVE_EIGEN -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase2::project // Access: Published @@ -424,6 +429,7 @@ INLINE_LINMATH FLOATNAME(LVecBase2) FLOATNAME(LVecBase2):: project(const FLOATNAME(LVecBase2) &onto) const { return onto * (dot(onto) / onto.length_squared()); } +#endif // FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LVecBase2::operator < @@ -475,9 +481,64 @@ operator != (const FLOATNAME(LVecBase2) &other) const { INLINE_LINMATH int FLOATNAME(LVecBase2):: compare_to(const FLOATNAME(LVecBase2) &other) const { TAU_PROFILE("int LVecBase2::compare_to(const LVecBase2 &)", " ", TAU_USER); +#ifdef FLOATTYPE_IS_INT + if (_v(0) != other._v(0)) { + return (_v(0) < other._v(0)) ? -1 : 1; + } + if (_v(1) != other._v(1)) { + return (_v(1) < other._v(1)) ? -1 : 1; + } + return 0; +#else return compare_to(other, NEARLY_ZERO(FLOATTYPE)); +#endif } +//////////////////////////////////////////////////////////////////// +// Function: LVecBase2::get_hash +// Access: Published +// Description: Returns a suitable hash for phash_map. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH size_t FLOATNAME(LVecBase2):: +get_hash() const { + TAU_PROFILE("size_t LVecBase2::get_hash()", " ", TAU_USER); + return add_hash(0); +} + +//////////////////////////////////////////////////////////////////// +// Function: LVecBase2::add_hash +// Access: Published +// Description: Adds the vector into the running hash. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH size_t FLOATNAME(LVecBase2):: +add_hash(size_t hash) const { + TAU_PROFILE("size_t LVecBase2::add_hash(size_t)", " ", TAU_USER); +#ifdef FLOATTYPE_IS_INT + int_hash ihasher; + hash = ihasher.add_hash(hash, _v(0)); + hash = ihasher.add_hash(hash, _v(1)); + return hash; +#else + return add_hash(hash, NEARLY_ZERO(FLOATTYPE)); +#endif +} + +//////////////////////////////////////////////////////////////////// +// Function: LVecBase2::generate_hash +// Access: Published +// Description: Adds the vector to the indicated hash generator. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH void FLOATNAME(LVecBase2):: +generate_hash(ChecksumHashGenerator &hashgen) const { +#ifdef FLOATTYPE_IS_INT + hashgen.add_int(_v(0)); + hashgen.add_int(_v(1)); +#else + generate_hash(hashgen, NEARLY_ZERO(FLOATTYPE)); +#endif +} + +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LVecBase2::compare_to // Access: Published @@ -499,17 +560,6 @@ compare_to(const FLOATNAME(LVecBase2) &other, FLOATTYPE threshold) const { return 0; } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase2::get_hash -// Access: Published -// Description: Returns a suitable hash for phash_map. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH size_t FLOATNAME(LVecBase2):: -get_hash() const { - TAU_PROFILE("size_t LVecBase2::get_hash()", " ", TAU_USER); - return add_hash(0); -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase2::get_hash // Access: Published @@ -521,17 +571,6 @@ get_hash(FLOATTYPE threshold) const { return add_hash(0, threshold); } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase2::add_hash -// Access: Published -// Description: Adds the vector into the running hash. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH size_t FLOATNAME(LVecBase2):: -add_hash(size_t hash) const { - TAU_PROFILE("size_t LVecBase2::add_hash(size_t)", " ", TAU_USER); - return add_hash(hash, NEARLY_ZERO(FLOATTYPE)); -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase2::add_hash // Access: Published @@ -546,6 +585,18 @@ add_hash(size_t hash, FLOATTYPE threshold) const { return hash; } +//////////////////////////////////////////////////////////////////// +// Function: LVecBase2::generate_hash +// Access: Published +// Description: Adds the vector to the indicated hash generator. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH void FLOATNAME(LVecBase2):: +generate_hash(ChecksumHashGenerator &hashgen, FLOATTYPE threshold) const { + hashgen.add_fp(_v(0), threshold); + hashgen.add_fp(_v(1), threshold); +} +#endif // FLOATTYPE_IS_INT + //////////////////////////////////////////////////////////////////// // Function: LVecBase2::unary - // Access: Published @@ -612,8 +663,13 @@ operator * (FLOATTYPE scalar) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVecBase2) FLOATNAME(LVecBase2):: operator / (FLOATTYPE scalar) const { +#ifdef FLOATTYPE_IS_INT + return FLOATNAME(LVecBase2)(_v(0) / scalar, + _v(1) / scalar); +#else FLOATTYPE recip_scalar = 1.0f/scalar; return operator * (recip_scalar); +#endif } //////////////////////////////////////////////////////////////////// @@ -668,8 +724,13 @@ operator *= (FLOATTYPE scalar) { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase2):: operator /= (FLOATTYPE scalar) { +#ifdef FLOATTYPE_IS_INT + _v(0) /= scalar; + _v(1) /= scalar; +#else FLOATTYPE recip_scalar = 1.0f/scalar; operator *= (recip_scalar); +#endif } //////////////////////////////////////////////////////////////////// @@ -732,27 +793,6 @@ output(ostream &out) const { << MAYBE_ZERO(_v(1)); } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase2::generate_hash -// Access: Published -// Description: Adds the vector to the indicated hash generator. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH void FLOATNAME(LVecBase2):: -generate_hash(ChecksumHashGenerator &hashgen) const { - generate_hash(hashgen, NEARLY_ZERO(FLOATTYPE)); -} - -//////////////////////////////////////////////////////////////////// -// Function: LVecBase2::generate_hash -// Access: Published -// Description: Adds the vector to the indicated hash generator. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH void FLOATNAME(LVecBase2):: -generate_hash(ChecksumHashGenerator &hashgen, FLOATTYPE threshold) const { - hashgen.add_fp(_v(0), threshold); - hashgen.add_fp(_v(1), threshold); -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase2::write_datagram_fixed // Access: Published @@ -766,7 +806,10 @@ generate_hash(ChecksumHashGenerator &hashgen, FLOATTYPE threshold) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase2):: write_datagram_fixed(Datagram &destination) const { -#if FLOATTOKEN == 'f' +#if FLOATTOKEN == 'i' + destination.add_int32(_v(0)); + destination.add_int32(_v(1)); +#elif FLOATTOKEN == 'f' destination.add_float32(_v(0)); destination.add_float32(_v(1)); #else @@ -783,7 +826,10 @@ write_datagram_fixed(Datagram &destination) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase2):: read_datagram_fixed(DatagramIterator &source) { -#if FLOATTOKEN == 'f' +#if FLOATTOKEN == 'i' + _v(0) = source.get_int32(); + _v(1) = source.get_int32(); +#elif FLOATTOKEN == 'f' _v(0) = source.get_float32(); _v(1) = source.get_float32(); #else @@ -802,8 +848,13 @@ read_datagram_fixed(DatagramIterator &source) { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase2):: write_datagram(Datagram &destination) const { +#if FLOATTOKEN == 'i' + destination.add_int32(_v(0)); + destination.add_int32(_v(1)); +#else destination.add_stdfloat(_v(0)); destination.add_stdfloat(_v(1)); +#endif } //////////////////////////////////////////////////////////////////// @@ -813,6 +864,11 @@ write_datagram(Datagram &destination) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase2):: read_datagram(DatagramIterator &source) { +#if FLOATTOKEN == 'i' + _v(0) = source.get_int32(); + _v(1) = source.get_int32(); +#else _v(0) = source.get_stdfloat(); _v(1) = source.get_stdfloat(); +#endif } diff --git a/panda/src/linmath/lvecBase2_src.cxx b/panda/src/linmath/lvecBase2_src.cxx index a4b591564d..02a5507069 100644 --- a/panda/src/linmath/lvecBase2_src.cxx +++ b/panda/src/linmath/lvecBase2_src.cxx @@ -15,11 +15,11 @@ TypeHandle FLOATNAME(LVecBase2)::_type_handle; const FLOATNAME(LVecBase2) FLOATNAME(LVecBase2)::_zero = - FLOATNAME(LVecBase2)(0.0f, 0.0f); + FLOATNAME(LVecBase2)(0, 0); const FLOATNAME(LVecBase2) FLOATNAME(LVecBase2)::_unit_x = - FLOATNAME(LVecBase2)(1.0f, 0.0f); + FLOATNAME(LVecBase2)(1, 0); const FLOATNAME(LVecBase2) FLOATNAME(LVecBase2)::_unit_y = - FLOATNAME(LVecBase2)(0.0f, 1.0f); + FLOATNAME(LVecBase2)(0, 1); //////////////////////////////////////////////////////////////////// // Function: LVecBase2::init_type diff --git a/panda/src/linmath/lvecBase2_src.h b/panda/src/linmath/lvecBase2_src.h index f2daaae505..979165fa4d 100644 --- a/panda/src/linmath/lvecBase2_src.h +++ b/panda/src/linmath/lvecBase2_src.h @@ -78,24 +78,32 @@ PUBLISHED: INLINE_LINMATH void fill(FLOATTYPE fill_value); INLINE_LINMATH void set(FLOATTYPE x, FLOATTYPE y); - INLINE_LINMATH FLOATTYPE length() const; - INLINE_LINMATH FLOATTYPE length_squared() const; - INLINE_LINMATH bool normalize(); - INLINE_LINMATH FLOATTYPE dot(const FLOATNAME(LVecBase2) &other) const; + INLINE_LINMATH FLOATTYPE length_squared() const; + +#ifndef FLOATTYPE_IS_INT + INLINE_LINMATH FLOATTYPE length() const; + INLINE_LINMATH bool normalize(); INLINE_LINMATH FLOATNAME(LVecBase2) project(const FLOATNAME(LVecBase2) &onto) const; +#endif INLINE_LINMATH bool operator < (const FLOATNAME(LVecBase2) &other) const; INLINE_LINMATH bool operator == (const FLOATNAME(LVecBase2) &other) const; INLINE_LINMATH bool operator != (const FLOATNAME(LVecBase2) &other) const; INLINE_LINMATH int compare_to(const FLOATNAME(LVecBase2) &other) const; + INLINE_LINMATH size_t get_hash() const; + INLINE_LINMATH size_t add_hash(size_t hash) const; + INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen) const; + +#ifndef FLOATTYPE_IS_INT INLINE_LINMATH int compare_to(const FLOATNAME(LVecBase2) &other, FLOATTYPE threshold) const; - INLINE_LINMATH size_t get_hash() const; INLINE_LINMATH size_t get_hash(FLOATTYPE threshold) const; - INLINE_LINMATH size_t add_hash(size_t hash) const; INLINE_LINMATH size_t add_hash(size_t hash, FLOATTYPE threshold) const; + INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen, + FLOATTYPE threshold) const; +#endif INLINE_LINMATH FLOATNAME(LVecBase2) operator - () const; @@ -113,6 +121,9 @@ PUBLISHED: INLINE_LINMATH void operator *= (FLOATTYPE scalar); INLINE_LINMATH void operator /= (FLOATTYPE scalar); + EXTENSION(INLINE_LINMATH FLOATNAME(LVecBase2) __pow__(FLOATTYPE exponent) const); + EXTENSION(INLINE_LINMATH PyObject *__ipow__(PyObject *self, FLOATTYPE exponent)); + INLINE_LINMATH FLOATNAME(LVecBase2) fmax(const FLOATNAME(LVecBase2) &other); INLINE_LINMATH FLOATNAME(LVecBase2) fmin(const FLOATNAME(LVecBase2) &other); @@ -123,10 +134,6 @@ PUBLISHED: INLINE_LINMATH void output(ostream &out) const; EXTENSION(INLINE_LINMATH void python_repr(ostream &out, const string &class_name) const); - INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen) const; - INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen, - FLOATTYPE threshold) const; - INLINE_LINMATH void write_datagram_fixed(Datagram &destination) const; INLINE_LINMATH void read_datagram_fixed(DatagramIterator &source); INLINE_LINMATH void write_datagram(Datagram &destination) const; diff --git a/panda/src/linmath/lvecBase3.cxx b/panda/src/linmath/lvecBase3.cxx index 030e90ac38..79e0405525 100644 --- a/panda/src/linmath/lvecBase3.cxx +++ b/panda/src/linmath/lvecBase3.cxx @@ -20,3 +20,5 @@ #include "dblnames.h" #include "lvecBase3_src.cxx" +#include "intnames.h" +#include "lvecBase3_src.cxx" diff --git a/panda/src/linmath/lvecBase3.h b/panda/src/linmath/lvecBase3.h index 85d2b081c8..3152b72e8f 100644 --- a/panda/src/linmath/lvecBase3.h +++ b/panda/src/linmath/lvecBase3.h @@ -16,6 +16,7 @@ #define LVECBASE3_H #include "pandabase.h" +#include "config_linmath.h" #include "typedObject.h" #include "pnotify.h" #include "datagram.h" @@ -37,4 +38,7 @@ class DatagramIterator; #include "dblnames.h" #include "lvecBase3_src.h" +#include "intnames.h" +#include "lvecBase3_src.h" + #endif diff --git a/panda/src/linmath/lvecBase3_ext.h b/panda/src/linmath/lvecBase3_ext.h index f68fd8d782..26180bfb42 100644 --- a/panda/src/linmath/lvecBase3_ext.h +++ b/panda/src/linmath/lvecBase3_ext.h @@ -24,4 +24,7 @@ #include "dblnames.h" #include "lvecBase3_ext_src.h" +#include "intnames.h" +#include "lvecBase3_ext_src.h" + #endif diff --git a/panda/src/linmath/lvecBase3_ext_src.I b/panda/src/linmath/lvecBase3_ext_src.I index 9dc8fd4dab..3e99e9e3e7 100644 --- a/panda/src/linmath/lvecBase3_ext_src.I +++ b/panda/src/linmath/lvecBase3_ext_src.I @@ -19,6 +19,22 @@ IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVecBase3); IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVecBase4); #endif +#ifdef FLOATTYPE_IS_INT +#if PY_MAJOR_VERSION >= 3 +#define PYNUMBER_FLOATTYPE PyNumber_Long +#define PY_FROM_FLOATTYPE PyLong_FromLong +#define PY_AS_FLOATTYPE PyLong_AS_LONG +#else +#define PYNUMBER_FLOATTYPE PyNumber_Int +#define PY_FROM_FLOATTYPE PyInt_FromLong +#define PY_AS_FLOATTYPE PyInt_AS_LONG +#endif +#else +#define PYNUMBER_FLOATTYPE PyNumber_Float +#define PY_FROM_FLOATTYPE PyFloat_FromDouble +#define PY_AS_FLOATTYPE PyFloat_AsDouble +#endif + //////////////////////////////////////////////////////////////////// // Function: LVecBase3::__setitem__ // Access: Public @@ -60,8 +76,17 @@ __reduce__(PyObject *self) const { return NULL; } +#if FLOATTOKEN == 'i' + PyObject *result = Py_BuildValue("(O(iii))", this_class, + (*_this)[0], (*_this)[1], (*_this)[2]); +#elif FLOATTOKEN == 'f' PyObject *result = Py_BuildValue("(O(fff))", this_class, (*_this)[0], (*_this)[1], (*_this)[2]); +#else + PyObject *result = Py_BuildValue("(O(ddd))", this_class, + (*_this)[0], (*_this)[1], (*_this)[2]); +#endif + Py_DECREF(this_class); return result; } @@ -82,7 +107,7 @@ __getattr__(const string &attr_name) const { switch (attr_name.size()) { case 1: - return PyFloat_FromDouble(_this->_v(attr_name[0] - 'x')); + return PY_FROM_FLOATTYPE(_this->_v(attr_name[0] - 'x')); case 2: { FLOATNAME(LVecBase2) *vec = new FLOATNAME(LVecBase2); @@ -149,14 +174,18 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { PyObject** items = PySequence_Fast_ITEMS(fast); for (size_t i = 0; i < attr_name.size(); ++i) { - PyObject* fl = PyNumber_Float(items[i]); + PyObject* fl = PYNUMBER_FLOATTYPE(items[i]); if (fl == NULL) { // Oh darn. Not when we've come this far. +#ifdef FLOATTYPE_IS_INT + PyErr_SetString(PyExc_ValueError, "a sequence of integers is required"); +#else PyErr_SetString(PyExc_ValueError, "a sequence of floats is required"); +#endif Py_DECREF(fast); return -1; } - double value = PyFloat_AS_DOUBLE(fl); + FLOATTYPE value = PY_AS_FLOATTYPE(fl); Py_DECREF(fl); _this->_v(attr_name[i] - 'x') = value; @@ -166,19 +195,23 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { } else { // Maybe it's a single floating-point value. - PyObject* fl = PyNumber_Float(assign); + PyObject* fl = PYNUMBER_FLOATTYPE(assign); if (fl == NULL) { // It's not a floating-point value either? // Sheesh, I don't know what to do with it then. if (attr_name.size() == 1) { +#ifdef FLOATTYPE_IS_INT + PyErr_SetString(PyExc_ValueError, "an integer is required"); +#else PyErr_SetString(PyExc_ValueError, "a float is required"); +#endif } else { PyErr_Format(PyExc_ValueError, "'%.200s' object is not iterable", assign->ob_type->tp_name); } return -1; } - double value = PyFloat_AS_DOUBLE(fl); + FLOATTYPE value = PY_AS_FLOATTYPE(fl); Py_DECREF(fl); // Loop through the components in the attribute name, @@ -191,3 +224,33 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { return 0; } +//////////////////////////////////////////////////////////////////// +// Function: LVecBase3::__pow__ +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATNAME(LVecBase3) Extension:: +__pow__(FLOATTYPE exponent) const { + return FLOATNAME(LVecBase3)( + cpow(_this->_v(0), exponent), + cpow(_this->_v(1), exponent), + cpow(_this->_v(2), exponent)); +} + +//////////////////////////////////////////////////////////////////// +// Function: LVecBase3::__ipow__ +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH PyObject *Extension:: +__ipow__(PyObject *self, FLOATTYPE exponent) { + _this->_v(0) = cpow(_this->_v(0), exponent); + _this->_v(1) = cpow(_this->_v(1), exponent); + _this->_v(2) = cpow(_this->_v(2), exponent); + Py_INCREF(self); + return self; +} + +#undef PYNUMBER_FLOATTYPE +#undef PY_FROM_FLOATTYPE +#undef PY_AS_FLOATTYPE diff --git a/panda/src/linmath/lvecBase3_ext_src.h b/panda/src/linmath/lvecBase3_ext_src.h index 3c78131aed..cc86087833 100644 --- a/panda/src/linmath/lvecBase3_ext_src.h +++ b/panda/src/linmath/lvecBase3_ext_src.h @@ -27,6 +27,9 @@ public: INLINE_LINMATH int __setattr__(PyObject *self, const string &attr_name, PyObject *assign); INLINE_LINMATH void __setitem__(int i, FLOATTYPE v); INLINE_LINMATH void python_repr(ostream &out, const string &class_name) const; + + INLINE_LINMATH FLOATNAME(LVecBase3) __pow__(FLOATTYPE exponent) const; + INLINE_LINMATH PyObject *__ipow__(PyObject *self, FLOATTYPE exponent); }; #include "lvecBase3_ext_src.I" diff --git a/panda/src/linmath/lvecBase3_src.I b/panda/src/linmath/lvecBase3_src.I index f5848dfa3c..ce243aa893 100644 --- a/panda/src/linmath/lvecBase3_src.I +++ b/panda/src/linmath/lvecBase3_src.I @@ -77,6 +77,16 @@ FLOATNAME(LVecBase3)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z) { // set(x, y, z); } +//////////////////////////////////////////////////////////////////// +// Function: LVecBase3::Constructor +// Access: Published +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATNAME(LVecBase3):: +FLOATNAME(LVecBase3)(const FLOATNAME(LVecBase2) ©, FLOATTYPE z) { + set(copy[0], copy[1], z); +} + //////////////////////////////////////////////////////////////////// // Function: LVecBase3::zero Named Constructor // Access: Public @@ -133,7 +143,7 @@ INLINE_LINMATH FLOATNAME(LVecBase3):: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase3):: operator [](int i) const { - nassertr(i >= 0 && i < 3, 0.0); + nassertr(i >= 0 && i < 3, 0); return _v(i); } @@ -166,8 +176,12 @@ size() { //////////////////////////////////////////////////////////////////// INLINE_LINMATH bool FLOATNAME(LVecBase3):: is_nan() const { +#ifdef FLOATTYPE_IS_INT + return false; +#else TAU_PROFILE("bool LVecBase3::is_nan()", " ", TAU_USER); return cnan(_v(0)) || cnan(_v(1)) || cnan(_v(2)); +#endif } //////////////////////////////////////////////////////////////////// @@ -425,18 +439,17 @@ set(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z) { } //////////////////////////////////////////////////////////////////// -// Function: LVecBase3::length +// Function: LVecBase3::dot // Access: Published -// Description: Returns the length of the vector, by the Pythagorean -// theorem. +// Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase3):: -length() const { - TAU_PROFILE("FLOATTYPE LVecBase3::length()", " ", TAU_USER); +dot(const FLOATNAME(LVecBase3) &other) const { + TAU_PROFILE("FLOATTYPE LVecBase3::dot()", " ", TAU_USER); #ifdef HAVE_EIGEN - return _v.norm(); + return _v.dot(other._v); #else - return csqrt((*this).dot(*this)); + return _v(0) * other._v(0) + _v(1) * other._v(1) + _v(2) * other._v(2); #endif // HAVE_EIGEN } @@ -456,6 +469,23 @@ length_squared() const { #endif // HAVE_EIGEN } +#ifndef FLOATTYPE_IS_INT +//////////////////////////////////////////////////////////////////// +// Function: LVecBase3::length +// Access: Published +// Description: Returns the length of the vector, by the Pythagorean +// theorem. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase3):: +length() const { + TAU_PROFILE("FLOATTYPE LVecBase3::length()", " ", TAU_USER); +#ifdef HAVE_EIGEN + return _v.norm(); +#else + return csqrt((*this).dot(*this)); +#endif // HAVE_EIGEN +} + //////////////////////////////////////////////////////////////////// // Function: LVecBase3::normalize // Access: Published @@ -479,19 +509,17 @@ normalize() { } //////////////////////////////////////////////////////////////////// -// Function: LVecBase3::dot +// Function: LVecBase3::project // Access: Published -// Description: +// Description: Returns a new vector representing the projection of +// this vector onto another one. The resulting vector +// will be a scalar multiple of onto. //////////////////////////////////////////////////////////////////// -INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase3):: -dot(const FLOATNAME(LVecBase3) &other) const { - TAU_PROFILE("FLOATTYPE LVecBase3::dot()", " ", TAU_USER); -#ifdef HAVE_EIGEN - return _v.dot(other._v); -#else - return _v(0) * other._v(0) + _v(1) * other._v(1) + _v(2) * other._v(2); -#endif // HAVE_EIGEN +INLINE_LINMATH FLOATNAME(LVecBase3) FLOATNAME(LVecBase3):: +project(const FLOATNAME(LVecBase3) &onto) const { + return onto * (dot(onto) / onto.length_squared()); } +#endif // FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LVecBase3::cross @@ -510,18 +538,6 @@ cross(const FLOATNAME(LVecBase3) &other) const { #endif // HAVE_EIGEN } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase3::project -// Access: Published -// Description: Returns a new vector representing the projection of -// this vector onto another one. The resulting vector -// will be a scalar multiple of onto. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH FLOATNAME(LVecBase3) FLOATNAME(LVecBase3):: -project(const FLOATNAME(LVecBase3) &onto) const { - return onto * (dot(onto) / onto.length_squared()); -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase3::operator < // Access: Published @@ -621,9 +637,70 @@ get_standardized_hpr() const { INLINE_LINMATH int FLOATNAME(LVecBase3):: compare_to(const FLOATNAME(LVecBase3) &other) const { TAU_PROFILE("int LVecBase3::compare_to(const LVecBase3 &)", " ", TAU_USER); +#ifdef FLOATTYPE_IS_INT + if (_v(0) != other._v(0)) { + return (_v(0) < other._v(0)) ? -1 : 1; + } + if (_v(1) != other._v(1)) { + return (_v(1) < other._v(1)) ? -1 : 1; + } + if (_v(2) != other._v(2)) { + return (_v(2) < other._v(2)) ? -1 : 1; + } + return 0; +#else return compare_to(other, NEARLY_ZERO(FLOATTYPE)); +#endif } +//////////////////////////////////////////////////////////////////// +// Function: LVecBase3::get_hash +// Access: Published +// Description: Returns a suitable hash for phash_map. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH size_t FLOATNAME(LVecBase3):: +get_hash() const { + TAU_PROFILE("size_t LVecBase3::get_hash()", " ", TAU_USER); + return add_hash(0); +} + +//////////////////////////////////////////////////////////////////// +// Function: LVecBase3::add_hash +// Access: Published +// Description: Adds the vector into the running hash. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH size_t FLOATNAME(LVecBase3):: +add_hash(size_t hash) const { + TAU_PROFILE("size_t LVecBase3::add_hash(size_t)", " ", TAU_USER); +#ifdef FLOATTYPE_IS_INT + int_hash ihasher; + hash = ihasher.add_hash(hash, _v(0)); + hash = ihasher.add_hash(hash, _v(1)); + hash = ihasher.add_hash(hash, _v(2)); + return hash; +#else + return add_hash(hash, NEARLY_ZERO(FLOATTYPE)); +#endif +} + +//////////////////////////////////////////////////////////////////// +// Function: LVecBase3::generate_hash +// Access: Published +// Description: Adds the vector to the indicated hash generator. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH void FLOATNAME(LVecBase3):: +generate_hash(ChecksumHashGenerator &hashgen) const { + TAU_PROFILE("LVecBase3::generate_hash(ChecksumHashGenerator &)", " ", TAU_USER); +#ifdef FLOATTYPE_IS_INT + hashgen.add_int(_v(0)); + hashgen.add_int(_v(1)); + hashgen.add_int(_v(2)); +#else + generate_hash(hashgen, NEARLY_ZERO(FLOATTYPE)); +#endif +} + +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LVecBase3::compare_to // Access: Published @@ -648,17 +725,6 @@ compare_to(const FLOATNAME(LVecBase3) &other, FLOATTYPE threshold) const { return 0; } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase3::get_hash -// Access: Published -// Description: Returns a suitable hash for phash_map. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH size_t FLOATNAME(LVecBase3):: -get_hash() const { - TAU_PROFILE("size_t LVecBase3::get_hash()", " ", TAU_USER); - return add_hash(0); -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase3::get_hash // Access: Published @@ -670,17 +736,6 @@ get_hash(FLOATTYPE threshold) const { return add_hash(0, threshold); } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase3::add_hash -// Access: Published -// Description: Adds the vector into the running hash. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH size_t FLOATNAME(LVecBase3):: -add_hash(size_t hash) const { - TAU_PROFILE("size_t LVecBase3::add_hash(size_t)", " ", TAU_USER); - return add_hash(hash, NEARLY_ZERO(FLOATTYPE)); -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase3::add_hash // Access: Published @@ -696,6 +751,20 @@ add_hash(size_t hash, FLOATTYPE threshold) const { return hash; } +//////////////////////////////////////////////////////////////////// +// Function: LVecBase3::generate_hash +// Access: Published +// Description: Adds the vector to the indicated hash generator. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH void FLOATNAME(LVecBase3):: +generate_hash(ChecksumHashGenerator &hashgen, FLOATTYPE threshold) const { + TAU_PROFILE("LVecBase3::generate_hash(ChecksumHashGenerator &, FLOATTYPE)", " ", TAU_USER); + hashgen.add_fp(_v(0), threshold); + hashgen.add_fp(_v(1), threshold); + hashgen.add_fp(_v(2), threshold); +} +#endif // FLOATTYPE_IS_INT + //////////////////////////////////////////////////////////////////// // Function: LVecBase3::unary - // Access: Published @@ -765,8 +834,14 @@ operator * (FLOATTYPE scalar) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVecBase3) FLOATNAME(LVecBase3):: operator / (FLOATTYPE scalar) const { +#ifdef FLOATTYPE_IS_INT + return FLOATNAME(LVecBase3)(_v(0) / scalar, + _v(1) / scalar, + _v(2) / scalar); +#else FLOATTYPE recip_scalar = 1.0f/scalar; return operator * (recip_scalar); +#endif } //////////////////////////////////////////////////////////////////// @@ -824,8 +899,14 @@ operator *= (FLOATTYPE scalar) { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: operator /= (FLOATTYPE scalar) { +#ifdef FLOATTYPE_IS_INT + _v(0) /= scalar; + _v(1) /= scalar; + _v(2) /= scalar; +#else FLOATTYPE recip_scalar = 1.0f/scalar; operator *= (recip_scalar); +#endif } //////////////////////////////////////////////////////////////////// @@ -902,30 +983,6 @@ output(ostream &out) const { << MAYBE_ZERO(_v(2)); } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase3::generate_hash -// Access: Published -// Description: Adds the vector to the indicated hash generator. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH void FLOATNAME(LVecBase3):: -generate_hash(ChecksumHashGenerator &hashgen) const { - TAU_PROFILE("LVecBase3::generate_hash(ChecksumHashGenerator &)", " ", TAU_USER); - generate_hash(hashgen, NEARLY_ZERO(FLOATTYPE)); -} - -//////////////////////////////////////////////////////////////////// -// Function: LVecBase3::generate_hash -// Access: Published -// Description: Adds the vector to the indicated hash generator. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH void FLOATNAME(LVecBase3):: -generate_hash(ChecksumHashGenerator &hashgen, FLOATTYPE threshold) const { - TAU_PROFILE("LVecBase3::generate_hash(ChecksumHashGenerator &, FLOATTYPE)", " ", TAU_USER); - hashgen.add_fp(_v(0), threshold); - hashgen.add_fp(_v(1), threshold); - hashgen.add_fp(_v(2), threshold); -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase3::write_datagram_fixed // Access: Published @@ -939,7 +996,11 @@ generate_hash(ChecksumHashGenerator &hashgen, FLOATTYPE threshold) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: write_datagram_fixed(Datagram &destination) const { -#if FLOATTOKEN == 'f' +#if FLOATTOKEN == 'i' + destination.add_int32(_v(0)); + destination.add_int32(_v(1)); + destination.add_int32(_v(2)); +#elif FLOATTOKEN == 'f' destination.add_float32(_v(0)); destination.add_float32(_v(1)); destination.add_float32(_v(2)); @@ -958,7 +1019,11 @@ write_datagram_fixed(Datagram &destination) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: read_datagram_fixed(DatagramIterator &source) { -#if FLOATTOKEN == 'f' +#if FLOATTOKEN == 'i' + _v(0) = source.get_int32(); + _v(1) = source.get_int32(); + _v(2) = source.get_int32(); +#elif FLOATTOKEN == 'f' _v(0) = source.get_float32(); _v(1) = source.get_float32(); _v(2) = source.get_float32(); @@ -979,9 +1044,15 @@ read_datagram_fixed(DatagramIterator &source) { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: write_datagram(Datagram &destination) const { +#if FLOATTOKEN == 'i' + destination.add_int32(_v(0)); + destination.add_int32(_v(1)); + destination.add_int32(_v(2)); +#else destination.add_stdfloat(_v(0)); destination.add_stdfloat(_v(1)); destination.add_stdfloat(_v(2)); +#endif } //////////////////////////////////////////////////////////////////// @@ -991,7 +1062,13 @@ write_datagram(Datagram &destination) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase3):: read_datagram(DatagramIterator &source) { +#if FLOATTOKEN == 'i' + _v(0) = source.get_int32(); + _v(1) = source.get_int32(); + _v(2) = source.get_int32(); +#else _v(0) = source.get_stdfloat(); _v(1) = source.get_stdfloat(); _v(2) = source.get_stdfloat(); +#endif } diff --git a/panda/src/linmath/lvecBase3_src.cxx b/panda/src/linmath/lvecBase3_src.cxx index cfa0d6505e..f2d243fb3c 100644 --- a/panda/src/linmath/lvecBase3_src.cxx +++ b/panda/src/linmath/lvecBase3_src.cxx @@ -16,13 +16,13 @@ TypeHandle FLOATNAME(LVecBase3)::_type_handle; const FLOATNAME(LVecBase3) FLOATNAME(LVecBase3)::_zero = - FLOATNAME(LVecBase3)(0.0f, 0.0f, 0.0f); + FLOATNAME(LVecBase3)(0, 0, 0); const FLOATNAME(LVecBase3) FLOATNAME(LVecBase3)::_unit_x = - FLOATNAME(LVecBase3)(1.0f, 0.0f, 0.0f); + FLOATNAME(LVecBase3)(1, 0, 0); const FLOATNAME(LVecBase3) FLOATNAME(LVecBase3)::_unit_y = - FLOATNAME(LVecBase3)(0.0f, 1.0f, 0.0f); + FLOATNAME(LVecBase3)(0, 1, 0); const FLOATNAME(LVecBase3) FLOATNAME(LVecBase3)::_unit_z = - FLOATNAME(LVecBase3)(0.0f, 0.0f, 1.0f); + FLOATNAME(LVecBase3)(0, 0, 1); //////////////////////////////////////////////////////////////////// // Function: LVecBase3::init_type diff --git a/panda/src/linmath/lvecBase3_src.h b/panda/src/linmath/lvecBase3_src.h index c3635ea73c..99e9dbe38a 100644 --- a/panda/src/linmath/lvecBase3_src.h +++ b/panda/src/linmath/lvecBase3_src.h @@ -29,6 +29,7 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LVecBase3) &operator = (FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LVecBase3)(FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LVecBase3)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z); + INLINE_LINMATH FLOATNAME(LVecBase3)(const FLOATNAME(LVecBase2) ©, FLOATTYPE z); ALLOC_DELETED_CHAIN(FLOATNAME(LVecBase3)); INLINE_LINMATH static const FLOATNAME(LVecBase3) &zero(); @@ -86,13 +87,16 @@ PUBLISHED: INLINE_LINMATH void fill(FLOATTYPE fill_value); INLINE_LINMATH void set(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z); - INLINE_LINMATH FLOATTYPE length() const; - INLINE_LINMATH FLOATTYPE length_squared() const; - INLINE_LINMATH bool normalize(); - INLINE_LINMATH FLOATTYPE dot(const FLOATNAME(LVecBase3) &other) const; - INLINE_LINMATH FLOATNAME(LVecBase3) cross(const FLOATNAME(LVecBase3) &other) const; + INLINE_LINMATH FLOATTYPE length_squared() const; + +#ifndef FLOATTYPE_IS_INT + INLINE_LINMATH FLOATTYPE length() const; + INLINE_LINMATH bool normalize(); INLINE_LINMATH FLOATNAME(LVecBase3) project(const FLOATNAME(LVecBase3) &onto) const; +#endif + + INLINE_LINMATH FLOATNAME(LVecBase3) cross(const FLOATNAME(LVecBase3) &other) const; INLINE_LINMATH bool operator < (const FLOATNAME(LVecBase3) &other) const; INLINE_LINMATH bool operator == (const FLOATNAME(LVecBase3) &other) const; @@ -101,12 +105,18 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LVecBase3) get_standardized_hpr() const; INLINE_LINMATH int compare_to(const FLOATNAME(LVecBase3) &other) const; + INLINE_LINMATH size_t get_hash() const; + INLINE_LINMATH size_t add_hash(size_t hash) const; + INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen) const; + +#ifndef FLOATTYPE_IS_INT INLINE_LINMATH int compare_to(const FLOATNAME(LVecBase3) &other, FLOATTYPE threshold) const; - INLINE_LINMATH size_t get_hash() const; INLINE_LINMATH size_t get_hash(FLOATTYPE threshold) const; - INLINE_LINMATH size_t add_hash(size_t hash) const; INLINE_LINMATH size_t add_hash(size_t hash, FLOATTYPE threshold) const; + INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen, + FLOATTYPE threshold) const; +#endif INLINE_LINMATH FLOATNAME(LVecBase3) operator - () const; @@ -124,6 +134,9 @@ PUBLISHED: INLINE_LINMATH void operator *= (FLOATTYPE scalar); INLINE_LINMATH void operator /= (FLOATTYPE scalar); + EXTENSION(INLINE_LINMATH FLOATNAME(LVecBase3) __pow__(FLOATTYPE exponent) const); + EXTENSION(INLINE_LINMATH PyObject *__ipow__(PyObject *self, FLOATTYPE exponent)); + INLINE_LINMATH FLOATNAME(LVecBase3) fmax(const FLOATNAME(LVecBase3) &other); INLINE_LINMATH FLOATNAME(LVecBase3) fmin(const FLOATNAME(LVecBase3) &other); @@ -136,10 +149,6 @@ PUBLISHED: INLINE_LINMATH void output(ostream &out) const; EXTENSION(INLINE_LINMATH void python_repr(ostream &out, const string &class_name) const); - INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen) const; - INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen, - FLOATTYPE threshold) const; - INLINE_LINMATH void write_datagram_fixed(Datagram &destination) const; INLINE_LINMATH void read_datagram_fixed(DatagramIterator &source); INLINE_LINMATH void write_datagram(Datagram &destination) const; diff --git a/panda/src/linmath/lvecBase4.cxx b/panda/src/linmath/lvecBase4.cxx index e94eeb4436..5c316c7716 100644 --- a/panda/src/linmath/lvecBase4.cxx +++ b/panda/src/linmath/lvecBase4.cxx @@ -20,3 +20,5 @@ #include "dblnames.h" #include "lvecBase4_src.cxx" +#include "intnames.h" +#include "lvecBase4_src.cxx" diff --git a/panda/src/linmath/lvecBase4.h b/panda/src/linmath/lvecBase4.h index d75379e8f7..0e144630e4 100644 --- a/panda/src/linmath/lvecBase4.h +++ b/panda/src/linmath/lvecBase4.h @@ -16,11 +16,14 @@ #define LVECBASE4_H #include "pandabase.h" +#include "config_linmath.h" #include "typedObject.h" #include "pnotify.h" #include "datagram.h" #include "datagramIterator.h" #include "checksumHashGenerator.h" +#include "lvecBase2.h" +#include "lvecBase3.h" #include "cmath.h" #include "nearly_zero.h" @@ -34,5 +37,7 @@ class DatagramIterator; #include "dblnames.h" #include "lvecBase4_src.h" +#include "intnames.h" +#include "lvecBase4_src.h" #endif diff --git a/panda/src/linmath/lvecBase4_ext.h b/panda/src/linmath/lvecBase4_ext.h index 1cccf511e6..5ece57435e 100644 --- a/panda/src/linmath/lvecBase4_ext.h +++ b/panda/src/linmath/lvecBase4_ext.h @@ -24,4 +24,7 @@ #include "dblnames.h" #include "lvecBase4_ext_src.h" +#include "intnames.h" +#include "lvecBase4_ext_src.h" + #endif diff --git a/panda/src/linmath/lvecBase4_ext_src.I b/panda/src/linmath/lvecBase4_ext_src.I index c76a00e1ac..ddb1f71e1d 100644 --- a/panda/src/linmath/lvecBase4_ext_src.I +++ b/panda/src/linmath/lvecBase4_ext_src.I @@ -19,6 +19,22 @@ IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVecBase3); IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVecBase4); #endif +#ifdef FLOATTYPE_IS_INT +#if PY_MAJOR_VERSION >= 3 +#define PYNUMBER_FLOATTYPE PyNumber_Long +#define PY_FROM_FLOATTYPE PyLong_FromLong +#define PY_AS_FLOATTYPE PyLong_AS_LONG +#else +#define PYNUMBER_FLOATTYPE PyNumber_Int +#define PY_FROM_FLOATTYPE PyInt_FromLong +#define PY_AS_FLOATTYPE PyInt_AS_LONG +#endif +#else +#define PYNUMBER_FLOATTYPE PyNumber_Float +#define PY_FROM_FLOATTYPE PyFloat_FromDouble +#define PY_AS_FLOATTYPE PyFloat_AsDouble +#endif + //////////////////////////////////////////////////////////////////// // Function: LVecBase4::__setitem__ // Access: Public @@ -61,8 +77,17 @@ __reduce__(PyObject *self) const { return NULL; } +#if FLOATTOKEN == 'i' + PyObject *result = Py_BuildValue("(O(iiii))", this_class, + (*_this)[0], (*_this)[1], (*_this)[2], (*_this)[3]); +#elif FLOATTOKEN == 'f' PyObject *result = Py_BuildValue("(O(ffff))", this_class, (*_this)[0], (*_this)[1], (*_this)[2], (*_this)[3]); +#else + PyObject *result = Py_BuildValue("(O(dddd))", this_class, + (*_this)[0], (*_this)[1], (*_this)[2], (*_this)[3]); +#endif + Py_DECREF(this_class); return result; } @@ -84,9 +109,9 @@ __getattr__(const string &attr_name) const { switch (attr_name.size()) { case 1: if (attr_name[0] == 'w') { - return PyFloat_FromDouble(_this->_v(3)); + return PY_FROM_FLOATTYPE(_this->_v(3)); } else { - return PyFloat_FromDouble(_this->_v(attr_name[0] - 'x')); + return PY_FROM_FLOATTYPE(_this->_v(attr_name[0] - 'x')); } case 2: { @@ -154,14 +179,18 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { PyObject** items = PySequence_Fast_ITEMS(fast); for (size_t i = 0; i < attr_name.size(); ++i) { - PyObject* fl = PyNumber_Float(items[i]); + PyObject* fl = PYNUMBER_FLOATTYPE(items[i]); if (fl == NULL) { // Oh darn. Not when we've come this far. +#ifdef FLOATTYPE_IS_INT + PyErr_SetString(PyExc_ValueError, "a sequence of integers is required"); +#else PyErr_SetString(PyExc_ValueError, "a sequence of floats is required"); +#endif Py_DECREF(fast); return -1; } - double value = PyFloat_AS_DOUBLE(fl); + FLOATTYPE value = PY_AS_FLOATTYPE(fl); Py_DECREF(fl); _this->_v((attr_name[i] == 'w') ? 3 : attr_name[i] - 'x') = value; @@ -171,19 +200,24 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { } else { // Maybe it's a single floating-point value. - PyObject* fl = PyNumber_Float(assign); + PyObject* fl = PYNUMBER_FLOATTYPE(assign); + if (fl == NULL) { // It's not a floating-point value either? // Sheesh, I don't know what to do with it then. if (attr_name.size() == 1) { +#ifdef FLOATTYPE_IS_INT + PyErr_SetString(PyExc_ValueError, "an integer is required"); +#else PyErr_SetString(PyExc_ValueError, "a float is required"); +#endif } else { PyErr_Format(PyExc_ValueError, "'%.200s' object is not iterable", assign->ob_type->tp_name); } return -1; } - double value = PyFloat_AS_DOUBLE(fl); + FLOATTYPE value = PY_AS_FLOATTYPE(fl); Py_DECREF(fl); // Loop through the components in the attribute name, @@ -196,6 +230,35 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { return 0; } +//////////////////////////////////////////////////////////////////// +// Function: LVecBase4::__pow__ +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATNAME(LVecBase4) Extension:: +__pow__(FLOATTYPE exponent) const { + return FLOATNAME(LVecBase4)( + cpow(_this->_v(0), exponent), + cpow(_this->_v(1), exponent), + cpow(_this->_v(2), exponent), + cpow(_this->_v(3), exponent)); +} + +//////////////////////////////////////////////////////////////////// +// Function: LVecBase4::__ipow__ +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH PyObject *Extension:: +__ipow__(PyObject *self, FLOATTYPE exponent) { + _this->_v(0) = cpow(_this->_v(0), exponent); + _this->_v(1) = cpow(_this->_v(1), exponent); + _this->_v(2) = cpow(_this->_v(2), exponent); + _this->_v(3) = cpow(_this->_v(3), exponent); + Py_INCREF(self); + return self; +} + //////////////////////////////////////////////////////////////////// // Function: UnalignedLVecBase4::__setitem__ // Access: Public @@ -206,3 +269,7 @@ __setitem__(int i, FLOATTYPE v) { nassertv(i >= 0 && i < 4); _this->_v(i) = v; } + +#undef PYNUMBER_FLOATTYPE +#undef PY_FROM_FLOATTYPE +#undef PY_AS_FLOATTYPE diff --git a/panda/src/linmath/lvecBase4_ext_src.h b/panda/src/linmath/lvecBase4_ext_src.h index 61ff4e907c..edcecb4dbf 100644 --- a/panda/src/linmath/lvecBase4_ext_src.h +++ b/panda/src/linmath/lvecBase4_ext_src.h @@ -27,6 +27,9 @@ public: INLINE_LINMATH int __setattr__(PyObject *self, const string &attr_name, PyObject *assign); INLINE_LINMATH void __setitem__(int i, FLOATTYPE v); INLINE_LINMATH void python_repr(ostream &out, const string &class_name) const; + + INLINE_LINMATH FLOATNAME(LVecBase4) __pow__(FLOATTYPE exponent) const; + INLINE_LINMATH PyObject *__ipow__(PyObject *self, FLOATTYPE exponent); }; //////////////////////////////////////////////////////////////////// diff --git a/panda/src/linmath/lvecBase4_src.I b/panda/src/linmath/lvecBase4_src.I index 1ffd3da3ee..207788d92e 100644 --- a/panda/src/linmath/lvecBase4_src.I +++ b/panda/src/linmath/lvecBase4_src.I @@ -96,6 +96,16 @@ FLOATNAME(LVecBase4)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z, FLOATTYPE w) { set(x, y, z, w); } +//////////////////////////////////////////////////////////////////// +// Function: LVecBase4::Constructor +// Access: Published +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATNAME(LVecBase4):: +FLOATNAME(LVecBase4)(const FLOATNAME(LVecBase3) ©, FLOATTYPE w) { + set(copy[0], copy[1], copy[2], w); +} + //////////////////////////////////////////////////////////////////// // Function: LVecBase4::Destructor // Access: Published @@ -162,7 +172,7 @@ unit_w() { //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase4):: operator [](int i) const { - nassertr(i >= 0 && i < 4, 0.0); + nassertr(i >= 0 && i < 4, 0); return _v(i); } @@ -195,8 +205,12 @@ size() { //////////////////////////////////////////////////////////////////// INLINE_LINMATH bool FLOATNAME(LVecBase4):: is_nan() const { +#ifdef FLOATTYPE_IS_INT + return false; +#else TAU_PROFILE("bool LVecBase4::is_nan()", " ", TAU_USER); return cnan(_v(0)) || cnan(_v(1)) || cnan(_v(2)) || cnan(_v(3)); +#endif } //////////////////////////////////////////////////////////////////// @@ -206,7 +220,7 @@ is_nan() const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase4):: get_cell(int i) const { - nassertr(i >= 0 && i < 4, 0.0); + nassertr(i >= 0 && i < 4, 0); return _v(i); } @@ -453,18 +467,19 @@ set(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z, FLOATTYPE w) { } //////////////////////////////////////////////////////////////////// -// Function: LVecBase4::length +// Function: LVecBase4::dot // Access: Published -// Description: Returns the length of the vector, by the Pythagorean -// theorem. +// Description: //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase4):: -length() const { - TAU_PROFILE("FLOATTYPE LVecBase4::length()", " ", TAU_USER); +dot(const FLOATNAME(LVecBase4) &other) const { + TAU_PROFILE("FLOATTYPE LVecBase4::dot()", " ", TAU_USER); #ifdef HAVE_EIGEN - return _v.norm(); + return _v.dot(other._v); #else - return csqrt((*this).dot(*this)); + return + _v(0) * other._v(0) + _v(1) * other._v(1) + + _v(2) * other._v(2) + _v(3) * other._v(3); #endif // HAVE_EIGEN } @@ -484,6 +499,23 @@ length_squared() const { #endif // HAVE_EIGEN } +#ifndef FLOATTYPE_IS_INT +//////////////////////////////////////////////////////////////////// +// Function: LVecBase4::length +// Access: Published +// Description: Returns the length of the vector, by the Pythagorean +// theorem. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase4):: +length() const { + TAU_PROFILE("FLOATTYPE LVecBase4::length()", " ", TAU_USER); +#ifdef HAVE_EIGEN + return _v.norm(); +#else + return csqrt((*this).dot(*this)); +#endif // HAVE_EIGEN +} + //////////////////////////////////////////////////////////////////// // Function: LVecBase4::normalize // Access: Published @@ -505,23 +537,6 @@ normalize() { return true; } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase4::dot -// Access: Published -// Description: -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH FLOATTYPE FLOATNAME(LVecBase4):: -dot(const FLOATNAME(LVecBase4) &other) const { - TAU_PROFILE("FLOATTYPE LVecBase4::dot()", " ", TAU_USER); -#ifdef HAVE_EIGEN - return _v.dot(other._v); -#else - return - _v(0) * other._v(0) + _v(1) * other._v(1) + - _v(2) * other._v(2) + _v(3) * other._v(3); -#endif // HAVE_EIGEN -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase4::project // Access: Published @@ -533,6 +548,7 @@ INLINE_LINMATH FLOATNAME(LVecBase4) FLOATNAME(LVecBase4):: project(const FLOATNAME(LVecBase4) &onto) const { return onto * (dot(onto) / onto.length_squared()); } +#endif // FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LVecBase4::operator < @@ -586,9 +602,75 @@ operator != (const FLOATNAME(LVecBase4) &other) const { INLINE_LINMATH int FLOATNAME(LVecBase4):: compare_to(const FLOATNAME(LVecBase4) &other) const { TAU_PROFILE("int LVecBase4::compare_to(const LVecBase4 &)", " ", TAU_USER); +#ifdef FLOATTYPE_IS_INT + if (_v(0) != other._v(0)) { + return (_v(0) < other._v(0)) ? -1 : 1; + } + if (_v(1) != other._v(1)) { + return (_v(1) < other._v(1)) ? -1 : 1; + } + if (_v(2) != other._v(2)) { + return (_v(2) < other._v(2)) ? -1 : 1; + } + if (_v(3) != other._v(3)) { + return (_v(3) < other._v(3)) ? -1 : 1; + } + return 0; +#else return compare_to(other, NEARLY_ZERO(FLOATTYPE)); +#endif } +//////////////////////////////////////////////////////////////////// +// Function: LVecBase4::get_hash +// Access: Published +// Description: Returns a suitable hash for phash_map. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH size_t FLOATNAME(LVecBase4):: +get_hash() const { + TAU_PROFILE("size_t LVecBase4::get_hash()", " ", TAU_USER); + return add_hash(0); +} + +//////////////////////////////////////////////////////////////////// +// Function: LVecBase4::add_hash +// Access: Published +// Description: Adds the vector into the running hash. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH size_t FLOATNAME(LVecBase4):: +add_hash(size_t hash) const { + TAU_PROFILE("size_t LVecBase4::add_hash(size_t)", " ", TAU_USER); +#ifdef FLOATTYPE_IS_INT + int_hash ihasher; + hash = ihasher.add_hash(hash, _v(0)); + hash = ihasher.add_hash(hash, _v(1)); + hash = ihasher.add_hash(hash, _v(2)); + hash = ihasher.add_hash(hash, _v(3)); + return hash; +#else + return add_hash(hash, NEARLY_ZERO(FLOATTYPE)); +#endif +} + +//////////////////////////////////////////////////////////////////// +// Function: LVecBase4::generate_hash +// Access: Published +// Description: Adds the vector to the indicated hash generator. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH void FLOATNAME(LVecBase4):: +generate_hash(ChecksumHashGenerator &hashgen) const { + TAU_PROFILE("LVecBase4::generate_hash(ChecksumHashGenerator &)", " ", TAU_USER); +#ifdef FLOATTYPE_IS_INT + hashgen.add_int(_v(0)); + hashgen.add_int(_v(1)); + hashgen.add_int(_v(2)); + hashgen.add_int(_v(3)); +#else + generate_hash(hashgen, NEARLY_ZERO(FLOATTYPE)); +#endif +} + +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LVecBase4::compare_to // Access: Published @@ -616,17 +698,6 @@ compare_to(const FLOATNAME(LVecBase4) &other, FLOATTYPE threshold) const { return 0; } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase4::get_hash -// Access: Published -// Description: Returns a suitable hash for phash_map. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH size_t FLOATNAME(LVecBase4):: -get_hash() const { - TAU_PROFILE("size_t LVecBase4::get_hash()", " ", TAU_USER); - return add_hash(0); -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase4::get_hash // Access: Published @@ -638,17 +709,6 @@ get_hash(FLOATTYPE threshold) const { return add_hash(0, threshold); } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase4::add_hash -// Access: Published -// Description: Adds the vector into the running hash. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH size_t FLOATNAME(LVecBase4):: -add_hash(size_t hash) const { - TAU_PROFILE("size_t LVecBase4::add_hash(size_t)", " ", TAU_USER); - return add_hash(hash, NEARLY_ZERO(FLOATTYPE)); -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase4::add_hash // Access: Published @@ -665,6 +725,21 @@ add_hash(size_t hash, FLOATTYPE threshold) const { return hash; } +//////////////////////////////////////////////////////////////////// +// Function: LVecBase4::generate_hash +// Access: Published +// Description: Adds the vector to the indicated hash generator. +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH void FLOATNAME(LVecBase4):: +generate_hash(ChecksumHashGenerator &hashgen, FLOATTYPE threshold) const { + TAU_PROFILE("LVecBase4::generate_hash(ChecksumHashGenerator &, FLOATTYPE)", " ", TAU_USER); + hashgen.add_fp(_v(0), threshold); + hashgen.add_fp(_v(1), threshold); + hashgen.add_fp(_v(2), threshold); + hashgen.add_fp(_v(3), threshold); +} +#endif // FLOATTYPE_IS_INT + //////////////////////////////////////////////////////////////////// // Function: LVecBase4::unary - // Access: Published @@ -737,8 +812,15 @@ operator * (FLOATTYPE scalar) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVecBase4) FLOATNAME(LVecBase4):: operator / (FLOATTYPE scalar) const { +#ifdef FLOATTYPE_IS_INT + return FLOATNAME(LVecBase4)(_v(0) / scalar, + _v(1) / scalar, + _v(2) / scalar, + _v(3) / scalar); +#else FLOATTYPE recip_scalar = 1.0f/scalar; return operator * (recip_scalar); +#endif } //////////////////////////////////////////////////////////////////// @@ -799,8 +881,15 @@ operator *= (FLOATTYPE scalar) { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase4):: operator /= (FLOATTYPE scalar) { +#ifdef FLOATTYPE_IS_INT + _v(0) /= scalar; + _v(1) /= scalar; + _v(2) /= scalar; + _v(3) /= scalar; +#else FLOATTYPE recip_scalar = 1.0f/scalar; operator *= (recip_scalar); +#endif } //////////////////////////////////////////////////////////////////// @@ -871,31 +960,6 @@ output(ostream &out) const { << MAYBE_ZERO(_v(3)); } -//////////////////////////////////////////////////////////////////// -// Function: LVecBase4::generate_hash -// Access: Published -// Description: Adds the vector to the indicated hash generator. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH void FLOATNAME(LVecBase4):: -generate_hash(ChecksumHashGenerator &hashgen) const { - TAU_PROFILE("LVecBase4::generate_hash(ChecksumHashGenerator &)", " ", TAU_USER); - generate_hash(hashgen, NEARLY_ZERO(FLOATTYPE)); -} - -//////////////////////////////////////////////////////////////////// -// Function: LVecBase4::generate_hash -// Access: Published -// Description: Adds the vector to the indicated hash generator. -//////////////////////////////////////////////////////////////////// -INLINE_LINMATH void FLOATNAME(LVecBase4):: -generate_hash(ChecksumHashGenerator &hashgen, FLOATTYPE threshold) const { - TAU_PROFILE("LVecBase4::generate_hash(ChecksumHashGenerator &, FLOATTYPE)", " ", TAU_USER); - hashgen.add_fp(_v(0), threshold); - hashgen.add_fp(_v(1), threshold); - hashgen.add_fp(_v(2), threshold); - hashgen.add_fp(_v(3), threshold); -} - //////////////////////////////////////////////////////////////////// // Function: LVecBase4::write_datagram_fixed // Access: Published @@ -909,7 +973,12 @@ generate_hash(ChecksumHashGenerator &hashgen, FLOATTYPE threshold) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase4):: write_datagram_fixed(Datagram &destination) const { -#if FLOATTOKEN == 'f' +#if FLOATTOKEN == 'i' + destination.add_int32(_v(0)); + destination.add_int32(_v(1)); + destination.add_int32(_v(2)); + destination.add_int32(_v(3)); +#elif FLOATTOKEN == 'f' destination.add_float32(_v(0)); destination.add_float32(_v(1)); destination.add_float32(_v(2)); @@ -930,7 +999,12 @@ write_datagram_fixed(Datagram &destination) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase4):: read_datagram_fixed(DatagramIterator &source) { -#if FLOATTOKEN == 'f' +#if FLOATTOKEN == 'i' + _v(0) = source.get_int32(); + _v(1) = source.get_int32(); + _v(2) = source.get_int32(); + _v(3) = source.get_int32(); +#elif FLOATTOKEN == 'f' _v(0) = source.get_float32(); _v(1) = source.get_float32(); _v(2) = source.get_float32(); @@ -953,10 +1027,17 @@ read_datagram_fixed(DatagramIterator &source) { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase4):: write_datagram(Datagram &destination) const { +#if FLOATTOKEN == 'i' + destination.add_int32(_v(0)); + destination.add_int32(_v(1)); + destination.add_int32(_v(2)); + destination.add_int32(_v(3)); +#else destination.add_stdfloat(_v(0)); destination.add_stdfloat(_v(1)); destination.add_stdfloat(_v(2)); destination.add_stdfloat(_v(3)); +#endif } //////////////////////////////////////////////////////////////////// @@ -966,10 +1047,17 @@ write_datagram(Datagram &destination) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH void FLOATNAME(LVecBase4):: read_datagram(DatagramIterator &source) { +#if FLOATTOKEN == 'i' + _v(0) = source.get_int32(); + _v(1) = source.get_int32(); + _v(2) = source.get_int32(); + _v(3) = source.get_int32(); +#else _v(0) = source.get_stdfloat(); _v(1) = source.get_stdfloat(); _v(2) = source.get_stdfloat(); _v(3) = source.get_stdfloat(); +#endif } //////////////////////////////////////////////////////////////////// @@ -1055,7 +1143,7 @@ set(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z, FLOATTYPE w) { //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATTYPE FLOATNAME(UnalignedLVecBase4):: operator [](int i) const { - nassertr(i >= 0 && i < 4, 0.0); + nassertr(i >= 0 && i < 4, 0); return _v(i); } diff --git a/panda/src/linmath/lvecBase4_src.cxx b/panda/src/linmath/lvecBase4_src.cxx index 23afd7b395..49debed5a7 100644 --- a/panda/src/linmath/lvecBase4_src.cxx +++ b/panda/src/linmath/lvecBase4_src.cxx @@ -16,15 +16,15 @@ TypeHandle FLOATNAME(LVecBase4)::_type_handle; TypeHandle FLOATNAME(UnalignedLVecBase4)::_type_handle; const FLOATNAME(LVecBase4) FLOATNAME(LVecBase4)::_zero = - FLOATNAME(LVecBase4)(0.0f, 0.0f, 0.0f, 0.0f); + FLOATNAME(LVecBase4)(0, 0, 0, 0); const FLOATNAME(LVecBase4) FLOATNAME(LVecBase4)::_unit_x = - FLOATNAME(LVecBase4)(1.0f, 0.0f, 0.0f, 0.0f); + FLOATNAME(LVecBase4)(1, 0, 0, 0); const FLOATNAME(LVecBase4) FLOATNAME(LVecBase4)::_unit_y = - FLOATNAME(LVecBase4)(0.0f, 1.0f, 0.0f, 0.0f); + FLOATNAME(LVecBase4)(0, 1, 0, 0); const FLOATNAME(LVecBase4) FLOATNAME(LVecBase4)::_unit_z = - FLOATNAME(LVecBase4)(0.0f, 0.0f, 1.0f, 0.0f); + FLOATNAME(LVecBase4)(0, 0, 1, 0); const FLOATNAME(LVecBase4) FLOATNAME(LVecBase4)::_unit_w = - FLOATNAME(LVecBase4)(0.0f, 0.0f, 0.0f, 1.0f); + FLOATNAME(LVecBase4)(0, 0, 0, 1); //////////////////////////////////////////////////////////////////// // Function: LVecBase4::init_type diff --git a/panda/src/linmath/lvecBase4_src.h b/panda/src/linmath/lvecBase4_src.h index 312c31a222..395505046a 100644 --- a/panda/src/linmath/lvecBase4_src.h +++ b/panda/src/linmath/lvecBase4_src.h @@ -34,6 +34,7 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LVecBase4) &operator = (FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LVecBase4)(FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LVecBase4)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z, FLOATTYPE w); + INLINE_LINMATH FLOATNAME(LVecBase4)(const FLOATNAME(LVecBase3) ©, FLOATTYPE w); ALLOC_DELETED_CHAIN(FLOATNAME(LVecBase4)); INLINE_LINMATH static const FLOATNAME(LVecBase4) &zero(); @@ -91,24 +92,32 @@ PUBLISHED: INLINE_LINMATH void fill(FLOATTYPE fill_value); INLINE_LINMATH void set(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z, FLOATTYPE w); - INLINE_LINMATH FLOATTYPE length() const; - INLINE_LINMATH FLOATTYPE length_squared() const; - INLINE_LINMATH bool normalize(); - INLINE_LINMATH FLOATTYPE dot(const FLOATNAME(LVecBase4) &other) const; + INLINE_LINMATH FLOATTYPE length_squared() const; + +#ifndef FLOATTYPE_IS_INT + INLINE_LINMATH FLOATTYPE length() const; + INLINE_LINMATH bool normalize(); INLINE_LINMATH FLOATNAME(LVecBase4) project(const FLOATNAME(LVecBase4) &onto) const; +#endif INLINE_LINMATH bool operator < (const FLOATNAME(LVecBase4) &other) const; INLINE_LINMATH bool operator == (const FLOATNAME(LVecBase4) &other) const; INLINE_LINMATH bool operator != (const FLOATNAME(LVecBase4) &other) const; INLINE_LINMATH int compare_to(const FLOATNAME(LVecBase4) &other) const; + INLINE_LINMATH size_t get_hash() const; + INLINE_LINMATH size_t add_hash(size_t hash) const; + INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen) const; + +#ifndef FLOATTYPE_IS_INT INLINE_LINMATH int compare_to(const FLOATNAME(LVecBase4) &other, FLOATTYPE threshold) const; - INLINE_LINMATH size_t get_hash() const; INLINE_LINMATH size_t get_hash(FLOATTYPE threshold) const; - INLINE_LINMATH size_t add_hash(size_t hash) const; INLINE_LINMATH size_t add_hash(size_t hash, FLOATTYPE threshold) const; + INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen, + FLOATTYPE threshold) const; +#endif INLINE_LINMATH FLOATNAME(LVecBase4) operator - () const; @@ -126,6 +135,9 @@ PUBLISHED: INLINE_LINMATH void operator *= (FLOATTYPE scalar); INLINE_LINMATH void operator /= (FLOATTYPE scalar); + EXTENSION(INLINE_LINMATH FLOATNAME(LVecBase4) __pow__(FLOATTYPE exponent) const); + EXTENSION(INLINE_LINMATH PyObject *__ipow__(PyObject *self, FLOATTYPE exponent)); + INLINE_LINMATH FLOATNAME(LVecBase4) fmax(const FLOATNAME(LVecBase4) &other); INLINE_LINMATH FLOATNAME(LVecBase4) fmin(const FLOATNAME(LVecBase4) &other); @@ -136,10 +148,6 @@ PUBLISHED: INLINE_LINMATH void output(ostream &out) const; EXTENSION(INLINE_LINMATH void python_repr(ostream &out, const string &class_name) const); - INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen) const; - INLINE_LINMATH void generate_hash(ChecksumHashGenerator &hashgen, - FLOATTYPE threshold) const; - INLINE_LINMATH void write_datagram_fixed(Datagram &destination) const; INLINE_LINMATH void read_datagram_fixed(DatagramIterator &source); INLINE_LINMATH void write_datagram(Datagram &destination) const; diff --git a/panda/src/linmath/lvector2.cxx b/panda/src/linmath/lvector2.cxx index cef623c5db..ac3193eebd 100644 --- a/panda/src/linmath/lvector2.cxx +++ b/panda/src/linmath/lvector2.cxx @@ -20,3 +20,5 @@ #include "dblnames.h" #include "lvector2_src.cxx" +#include "intnames.h" +#include "lvector2_src.cxx" diff --git a/panda/src/linmath/lvector2.h b/panda/src/linmath/lvector2.h index dba3fdc99f..61cc423310 100644 --- a/panda/src/linmath/lvector2.h +++ b/panda/src/linmath/lvector2.h @@ -26,4 +26,7 @@ #include "dblnames.h" #include "lvector2_src.h" +#include "intnames.h" +#include "lvector2_src.h" + #endif diff --git a/panda/src/linmath/lvector2_ext.h b/panda/src/linmath/lvector2_ext.h index 08ca44d07a..824b60a908 100644 --- a/panda/src/linmath/lvector2_ext.h +++ b/panda/src/linmath/lvector2_ext.h @@ -26,4 +26,7 @@ #include "dblnames.h" #include "lvector2_ext_src.h" +#include "intnames.h" +#include "lvector2_ext_src.h" + #endif diff --git a/panda/src/linmath/lvector2_ext_src.I b/panda/src/linmath/lvector2_ext_src.I index 091c68760a..3fb1284ddd 100644 --- a/panda/src/linmath/lvector2_ext_src.I +++ b/panda/src/linmath/lvector2_ext_src.I @@ -18,6 +18,16 @@ IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVector3); IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVector4); #endif +#ifdef FLOATTYPE_IS_INT +#if PY_MAJOR_VERSION >= 3 +#define PY_FROM_FLOATTYPE PyLong_FromLong +#else +#define PY_FROM_FLOATTYPE PyInt_FromLong +#endif +#else +#define PY_FROM_FLOATTYPE PyFloat_FromDouble +#endif + //////////////////////////////////////////////////////////////////// // Function: LVector2::python_repr // Access: Published @@ -46,7 +56,7 @@ __getattr__(const string &attr_name) const { switch (attr_name.size()) { case 1: - return PyFloat_FromDouble(_this->_v(attr_name[0] - 'x')); + return PY_FROM_FLOATTYPE(_this->_v(attr_name[0] - 'x')); case 2: { FLOATNAME(LVector2) *vec = new FLOATNAME(LVector2); @@ -84,3 +94,5 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { // Upcall to LVecBase2. return invoke_extension(_this).__setattr__(self, attr_name, assign); } + +#undef PY_FROM_FLOATTYPE diff --git a/panda/src/linmath/lvector2_src.I b/panda/src/linmath/lvector2_src.I index ba419811fa..45c7975fea 100644 --- a/panda/src/linmath/lvector2_src.I +++ b/panda/src/linmath/lvector2_src.I @@ -171,10 +171,10 @@ operator * (FLOATTYPE scalar) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector2) FLOATNAME(LVector2):: operator / (FLOATTYPE scalar) const { - FLOATTYPE recip_scalar = 1.0f/scalar; - return FLOATNAME(LVector2)(FLOATNAME(LVecBase2)::operator * (recip_scalar)); + return FLOATNAME(LVector2)(FLOATNAME(LVecBase2)::operator / (scalar)); } +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LVector2::project // Access: Published @@ -208,4 +208,4 @@ INLINE_LINMATH FLOATTYPE FLOATNAME(LVector2):: signed_angle_deg(const FLOATNAME(LVector2) &other) const { return rad_2_deg(signed_angle_rad(other)); } - +#endif // FLOATTYPE_IS_INT diff --git a/panda/src/linmath/lvector2_src.h b/panda/src/linmath/lvector2_src.h index 8a0459737a..417379b37f 100644 --- a/panda/src/linmath/lvector2_src.h +++ b/panda/src/linmath/lvector2_src.h @@ -43,9 +43,11 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LVector2) operator * (FLOATTYPE scalar) const; INLINE_LINMATH FLOATNAME(LVector2) operator / (FLOATTYPE scalar) const; +#ifndef FLOATTYPE_IS_INT INLINE_LINMATH FLOATNAME(LVector2) project(const FLOATNAME(LVecBase2) &onto) const; INLINE_LINMATH FLOATTYPE signed_angle_rad(const FLOATNAME(LVector2) &other) const; INLINE_LINMATH FLOATTYPE signed_angle_deg(const FLOATNAME(LVector2) &other) const; +#endif EXTENSION(INLINE_LINMATH void python_repr(ostream &out, const string &class_name) const); diff --git a/panda/src/linmath/lvector3.cxx b/panda/src/linmath/lvector3.cxx index 91902e7d59..ad4857ebff 100644 --- a/panda/src/linmath/lvector3.cxx +++ b/panda/src/linmath/lvector3.cxx @@ -20,3 +20,5 @@ #include "dblnames.h" #include "lvector3_src.cxx" +#include "intnames.h" +#include "lvector3_src.cxx" diff --git a/panda/src/linmath/lvector3.h b/panda/src/linmath/lvector3.h index 7750cd159f..bf6e7659b2 100644 --- a/panda/src/linmath/lvector3.h +++ b/panda/src/linmath/lvector3.h @@ -29,4 +29,7 @@ #include "dblnames.h" #include "lvector3_src.h" +#include "intnames.h" +#include "lvector3_src.h" + #endif diff --git a/panda/src/linmath/lvector3_ext.h b/panda/src/linmath/lvector3_ext.h index 4deae20e6d..3423fc351e 100644 --- a/panda/src/linmath/lvector3_ext.h +++ b/panda/src/linmath/lvector3_ext.h @@ -26,4 +26,7 @@ #include "dblnames.h" #include "lvector3_ext_src.h" +#include "intnames.h" +#include "lvector3_ext_src.h" + #endif diff --git a/panda/src/linmath/lvector3_ext_src.I b/panda/src/linmath/lvector3_ext_src.I index a0046c513a..183e633a76 100644 --- a/panda/src/linmath/lvector3_ext_src.I +++ b/panda/src/linmath/lvector3_ext_src.I @@ -18,6 +18,16 @@ IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVector3); IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVector4); #endif +#ifdef FLOATTYPE_IS_INT +#if PY_MAJOR_VERSION >= 3 +#define PY_FROM_FLOATTYPE PyLong_FromLong +#else +#define PY_FROM_FLOATTYPE PyInt_FromLong +#endif +#else +#define PY_FROM_FLOATTYPE PyFloat_FromDouble +#endif + //////////////////////////////////////////////////////////////////// // Function: LVector3::python_repr // Access: Published @@ -47,7 +57,7 @@ __getattr__(const string &attr_name) const { switch (attr_name.size()) { case 1: - return PyFloat_FromDouble(_this->_v(attr_name[0] - 'x')); + return PY_FROM_FLOATTYPE(_this->_v(attr_name[0] - 'x')); case 2: { FLOATNAME(LVector2) *vec = new FLOATNAME(LVector2); @@ -85,3 +95,5 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { // Upcall to LVecBase3. return invoke_extension(_this).__setattr__(self, attr_name, assign); } + +#undef PY_FROM_FLOATTYPE diff --git a/panda/src/linmath/lvector3_src.I b/panda/src/linmath/lvector3_src.I index bf4dbcc067..5a23e12c43 100644 --- a/panda/src/linmath/lvector3_src.I +++ b/panda/src/linmath/lvector3_src.I @@ -75,6 +75,17 @@ FLOATNAME(LVector3)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z) : { } +//////////////////////////////////////////////////////////////////// +// Function: LVector3::Constructor +// Access: Published +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATNAME(LVector3):: +FLOATNAME(LVector3)(const FLOATNAME(LVecBase2) ©, FLOATTYPE z) : + FLOATNAME(LVecBase3)(copy, z) +{ +} + //////////////////////////////////////////////////////////////////// // Function: LVector3::zero Named Constructor // Access: Published @@ -208,6 +219,7 @@ cross(const FLOATNAME(LVecBase3) &other) const { return FLOATNAME(LVecBase3)::cross(other); } +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LVector3::project // Access: Published @@ -309,6 +321,7 @@ INLINE_LINMATH FLOATTYPE FLOATNAME(LVector3):: relative_angle_deg(const FLOATNAME(LVector3) &other) const { return relative_angle_rad(other)*180/3.1415926535; } +#endif // FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LVector3::operator * scalar @@ -327,8 +340,7 @@ operator * (FLOATTYPE scalar) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3) FLOATNAME(LVector3):: operator / (FLOATTYPE scalar) const { - FLOATTYPE recip_scalar = 1.0f/scalar; - return FLOATNAME(LVector3)(FLOATNAME(LVecBase3)::operator * (recip_scalar)); + return FLOATNAME(LVector3)(FLOATNAME(LVecBase3)::operator / (scalar)); } //////////////////////////////////////////////////////////////////// @@ -345,16 +357,16 @@ up(CoordinateSystem cs) { switch (cs) { case CS_zup_right: case CS_zup_left: - return FLOATNAME(LVector3)(0.0f, 0.0f, 1.0f); + return FLOATNAME(LVector3)(0, 0, 1); case CS_yup_right: case CS_yup_left: - return FLOATNAME(LVector3)(0.0f, 1.0f, 0.0f); + return FLOATNAME(LVector3)(0, 1, 0); default: linmath_cat.error() << "Invalid coordinate system!\n"; - return FLOATNAME(LVector3)(0.0f, 0.0f, 0.0f); + return FLOATNAME(LVector3)(0, 0, 0); } } @@ -366,7 +378,7 @@ up(CoordinateSystem cs) { //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector3) FLOATNAME(LVector3):: right(CoordinateSystem) { - return FLOATNAME(LVector3)(1.0f, 0.0f, 0.0f); + return FLOATNAME(LVector3)(1, 0, 0); } //////////////////////////////////////////////////////////////////// @@ -382,21 +394,21 @@ forward(CoordinateSystem cs) { } switch (cs) { case CS_zup_right: - return FLOATNAME(LVector3)(0.0f, 1.0f, 0.0f); + return FLOATNAME(LVector3)(0, 1, 0); case CS_zup_left: - return FLOATNAME(LVector3)(0.0f, -1.0f, 0.0f); + return FLOATNAME(LVector3)(0, -1, 0); case CS_yup_right: - return FLOATNAME(LVector3)(0.0f, 0.0f, -1.0f); + return FLOATNAME(LVector3)(0, 0, -1); case CS_yup_left: - return FLOATNAME(LVector3)(0.0f, 0.0f, 1.0f); + return FLOATNAME(LVector3)(0, 0, 1); default: linmath_cat.error() << "Invalid coordinate system!\n"; - return FLOATNAME(LVector3)(0.0f, 0.0f, 0.0f); + return FLOATNAME(LVector3)(0, 0, 0); } } @@ -440,8 +452,7 @@ back(CoordinateSystem cs) { // forward, and up components, in whatever way the // coordinate system represents that vector. //////////////////////////////////////////////////////////////////// - -//INLINE_LINMATH FLOATNAME(LVector3) & FLOATNAME(LVector3):: +//INLINE_LINMATH FLOATNAME(LVector3) &FLOATNAME(LVector3):: INLINE_LINMATH FLOATNAME(LVector3) FLOATNAME(LVector3):: rfu(FLOATTYPE right_v, FLOATTYPE fwd_v, FLOATTYPE up_v, CoordinateSystem cs) { @@ -449,12 +460,11 @@ rfu(FLOATTYPE right_v, FLOATTYPE fwd_v, FLOATTYPE up_v, /* return forward(cs) * fwd_v + up(cs) * up_v + right(cs) * right_v; */ // fast implementation of above for axis-aligned coordinate systems - - if (cs == CS_default) { cs = get_default_coordinate_system(); } - FLOATTYPE vy,vz; + + FLOATTYPE vy, vz; switch(cs) { case CS_yup_right: vz = -fwd_v; @@ -479,9 +489,8 @@ rfu(FLOATTYPE right_v, FLOATTYPE fwd_v, FLOATTYPE up_v, default: linmath_cat.error() << "Invalid coordinate system!\n"; - return FLOATNAME(LVector3)(0.0f, 0.0f, 0.0f); + return FLOATNAME(LVector3)(0); } - return FLOATNAME(LVector3)(right_v,vy,vz); + return FLOATNAME(LVector3)(right_v, vy, vz); } - diff --git a/panda/src/linmath/lvector3_src.h b/panda/src/linmath/lvector3_src.h index 282a41bcd5..bac80207a4 100644 --- a/panda/src/linmath/lvector3_src.h +++ b/panda/src/linmath/lvector3_src.h @@ -30,6 +30,7 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LVector3) &operator = (FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LVector3)(FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LVector3)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z); + INLINE_LINMATH FLOATNAME(LVector3)(const FLOATNAME(LVecBase2) ©, FLOATTYPE z); EXTENSION(INLINE_LINMATH PyObject *__getattr__(const string &attr_name) const); EXTENSION(INLINE_LINMATH int __setattr__(PyObject *self, const string &attr_name, PyObject *assign)); @@ -52,6 +53,8 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LVector3) operator - (const FLOATNAME(LVector3) &other) const; INLINE_LINMATH FLOATNAME(LVector3) cross(const FLOATNAME(LVecBase3) &other) const; + +#ifndef FLOATTYPE_IS_INT INLINE_LINMATH FLOATNAME(LVector3) project(const FLOATNAME(LVecBase3) &onto) const; INLINE_LINMATH FLOATTYPE angle_rad(const FLOATNAME(LVector3) &other) const; INLINE_LINMATH FLOATTYPE angle_deg(const FLOATNAME(LVector3) &other) const; @@ -63,7 +66,7 @@ PUBLISHED: INLINE_LINMATH FLOATTYPE relative_angle_rad(const FLOATNAME(LVector3) &other) const; INLINE_LINMATH FLOATTYPE relative_angle_deg(const FLOATNAME(LVector3) &other) const; - +#endif INLINE_LINMATH FLOATNAME(LVector3) operator * (FLOATTYPE scalar) const; INLINE_LINMATH FLOATNAME(LVector3) operator / (FLOATTYPE scalar) const; diff --git a/panda/src/linmath/lvector4.cxx b/panda/src/linmath/lvector4.cxx index 18f4c156e3..68f8940dc1 100644 --- a/panda/src/linmath/lvector4.cxx +++ b/panda/src/linmath/lvector4.cxx @@ -20,3 +20,5 @@ #include "dblnames.h" #include "lvector4_src.cxx" +#include "intnames.h" +#include "lvector4_src.cxx" diff --git a/panda/src/linmath/lvector4.h b/panda/src/linmath/lvector4.h index 566fc9b702..3e36792309 100644 --- a/panda/src/linmath/lvector4.h +++ b/panda/src/linmath/lvector4.h @@ -26,4 +26,7 @@ #include "dblnames.h" #include "lvector4_src.h" +#include "intnames.h" +#include "lvector4_src.h" + #endif diff --git a/panda/src/linmath/lvector4_ext.h b/panda/src/linmath/lvector4_ext.h index 8bd174885e..a7805a2ab5 100644 --- a/panda/src/linmath/lvector4_ext.h +++ b/panda/src/linmath/lvector4_ext.h @@ -26,4 +26,7 @@ #include "dblnames.h" #include "lvector4_ext_src.h" +#include "intnames.h" +#include "lvector4_ext_src.h" + #endif diff --git a/panda/src/linmath/lvector4_ext_src.I b/panda/src/linmath/lvector4_ext_src.I index 8b84439228..f22510fc49 100644 --- a/panda/src/linmath/lvector4_ext_src.I +++ b/panda/src/linmath/lvector4_ext_src.I @@ -18,6 +18,16 @@ IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVector3); IMPORT_THIS struct Dtool_PyTypedObject FLOATNAME(Dtool_LVector4); #endif +#ifdef FLOATTYPE_IS_INT +#if PY_MAJOR_VERSION >= 3 +#define PY_FROM_FLOATTYPE PyLong_FromLong +#else +#define PY_FROM_FLOATTYPE PyInt_FromLong +#endif +#else +#define PY_FROM_FLOATTYPE PyFloat_FromDouble +#endif + //////////////////////////////////////////////////////////////////// // Function: LVector4::python_repr // Access: Published @@ -49,9 +59,9 @@ __getattr__(const string &attr_name) const { switch (attr_name.size()) { case 1: if (attr_name[0] == 'w') { - return PyFloat_FromDouble(_this->_v(3)); + return PY_FROM_FLOATTYPE(_this->_v(3)); } else { - return PyFloat_FromDouble(_this->_v(attr_name[0] - 'x')); + return PY_FROM_FLOATTYPE(_this->_v(attr_name[0] - 'x')); } case 2: { @@ -90,3 +100,5 @@ __setattr__(PyObject *self, const string &attr_name, PyObject *assign) { // Upcall to LVecBase4. return invoke_extension(_this).__setattr__(self, attr_name, assign); } + +#undef PY_FROM_FLOATTYPE diff --git a/panda/src/linmath/lvector4_src.I b/panda/src/linmath/lvector4_src.I index 59e7213b53..78333268f4 100644 --- a/panda/src/linmath/lvector4_src.I +++ b/panda/src/linmath/lvector4_src.I @@ -75,6 +75,17 @@ FLOATNAME(LVector4)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z, FLOATTYPE w) : { } +//////////////////////////////////////////////////////////////////// +// Function: LVector4::Constructor +// Access: Published +// Description: +//////////////////////////////////////////////////////////////////// +INLINE_LINMATH FLOATNAME(LVector4):: +FLOATNAME(LVector4)(const FLOATNAME(LVecBase3) ©, FLOATTYPE w) : + FLOATNAME(LVecBase4)(copy, w) +{ +} + //////////////////////////////////////////////////////////////////// // Function: LVector4::zero Named Constructor // Access: Public @@ -192,10 +203,10 @@ operator * (FLOATTYPE scalar) const { //////////////////////////////////////////////////////////////////// INLINE_LINMATH FLOATNAME(LVector4) FLOATNAME(LVector4):: operator / (FLOATTYPE scalar) const { - FLOATTYPE recip_scalar = 1.0f/scalar; - return FLOATNAME(LVector4)(FLOATNAME(LVecBase4)::operator * (recip_scalar)); + return FLOATNAME(LVector4)(FLOATNAME(LVecBase4)::operator / (scalar)); } +#ifndef FLOATTYPE_IS_INT //////////////////////////////////////////////////////////////////// // Function: LVector4::project // Access: Published @@ -207,4 +218,4 @@ INLINE_LINMATH FLOATNAME(LVector4) FLOATNAME(LVector4):: project(const FLOATNAME(LVecBase4) &onto) const { return FLOATNAME(LVecBase4)::project(onto); } - +#endif // FLOATTYPE_IS_INT diff --git a/panda/src/linmath/lvector4_src.h b/panda/src/linmath/lvector4_src.h index d9c639fcf1..179ccfdbfd 100644 --- a/panda/src/linmath/lvector4_src.h +++ b/panda/src/linmath/lvector4_src.h @@ -24,6 +24,7 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LVector4) &operator = (FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LVector4)(FLOATTYPE fill_value); INLINE_LINMATH FLOATNAME(LVector4)(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z, FLOATTYPE w); + INLINE_LINMATH FLOATNAME(LVector4)(const FLOATNAME(LVecBase3) ©, FLOATTYPE w); EXTENSION(INLINE_LINMATH PyObject *__getattr__(const string &attr_name) const); EXTENSION(INLINE_LINMATH int __setattr__(PyObject *self, const string &attr_name, PyObject *assign)); @@ -45,7 +46,9 @@ PUBLISHED: INLINE_LINMATH FLOATNAME(LVector4) operator * (FLOATTYPE scalar) const; INLINE_LINMATH FLOATNAME(LVector4) operator / (FLOATTYPE scalar) const; +#ifndef FLOATTYPE_IS_INT INLINE_LINMATH FLOATNAME(LVector4) project(const FLOATNAME(LVecBase4) &onto) const; +#endif EXTENSION(INLINE_LINMATH void python_repr(ostream &out, const string &class_name) const); diff --git a/panda/src/pgraph/geomTransformer.cxx b/panda/src/pgraph/geomTransformer.cxx index 60e8d5b151..7b5e810ec6 100644 --- a/panda/src/pgraph/geomTransformer.cxx +++ b/panda/src/pgraph/geomTransformer.cxx @@ -1437,16 +1437,15 @@ append_vdata(const GeomVertexData *vdata, int vertex_offset) { if (index.has_column()) { int num_values = index.get_column()->get_num_values(); int num_rows = vdata->get_num_rows(); - int new_index[4]; - + index.set_row_unsafe(vertex_offset); for (int ci = 0; ci < num_rows; ++ci) { - const int *orig_index = index.get_data4i(); + LVecBase4i indices = index.get_data4i(); for (int i = 0; i < num_values; i++) { - nassertv(orig_index[i] >= 0 && orig_index[i] < (int)transform_map.size()); - new_index[i] = transform_map[orig_index[i]]; + nassertv(indices[i] >= 0 && indices[i] < (int)transform_map.size()); + indices[i] = transform_map[indices[i]]; } - index.set_data4i(new_index); + index.set_data4i(indices); } } }