Added long double support

Author: robertosfield

include/vsg/app/ViewMatrix.h

@@ -34,11 +34,11 @@ namespace vsg
         /// origin value provides a means of translating the view matrix relative to the origin of any CoordinateFrame subgraphs
         /// to maximize the precision when moving around the CoordinateFrame subgraph.  This is helpful for astronmically large
         /// scenes where standrd double precision is insufficient for avoiding visually significant numerical errors.
-        dvec3 origin;
+        ldvec3 origin;
 
-        virtual dmat4 transform(const vsg::dvec3& offset = {}) const = 0;
+        virtual dmat4 transform(const vsg::ldvec3& offset = {}) const = 0;
 
-        virtual dmat4 inverse(const vsg::dvec3& offset = {}) const
+        virtual dmat4 inverse(const vsg::ldvec3& offset = {}) const
         {
             return vsg::inverse(transform(offset));
         }
@@ -88,7 +88,7 @@ namespace vsg
 
         void set(const dmat4& matrix);
 
-        dmat4 transform(const dvec3& offset = {}) const override;
+        dmat4 transform(const ldvec3& offset = {}) const override;
 
         void read(Input& input) override;
         void write(Output& output) const override;
@@ -123,7 +123,7 @@ namespace vsg
 
         void set(const dmat4& matrix);
 
-        dmat4 transform(const dvec3& offset = {}) const override;
+        dmat4 transform(const ldvec3& offset = {}) const override;
     };
     VSG_type_name(vsg::LookDirection);
 
@@ -138,7 +138,7 @@ namespace vsg
         }
 
         /// returns matrix * viewMatrix->transform()
-        dmat4 transform(const vsg::dvec3& offset = {}) const override;
+        dmat4 transform(const ldvec3& offset = {}) const override;
 
         dmat4 matrix;
         ref_ptr<ViewMatrix> viewMatrix;
@@ -161,8 +161,8 @@ namespace vsg
             objectPath(path.begin(), path.end()) {}
 
         /// returns matrix * computeTransfrom(objectPath)
-        dmat4 transform(const vsg::dvec3& offset = {}) const override;
-        dmat4 inverse(const vsg::dvec3& offset = {}) const override;
+        dmat4 transform(const ldvec3& offset = {}) const override;
+        dmat4 inverse(const ldvec3& offset = {}) const override;
 
         dmat4 matrix;
         RefObjectPath objectPath;

include/vsg/io/AsciiInput.h

@@ -85,6 +85,7 @@ namespace vsg
         void read(size_t num, uint64_t* value) override { _read(num, value); }
         void read(size_t num, float* value) override { _read(num, value); }
         void read(size_t num, double* value) override { _read(num, value); }
+        void read(size_t num, long double* value) override { _read(num, value); }
 
         // read in an individual string
         void _read(std::string& value);

include/vsg/io/AsciiOutput.h

@@ -136,6 +136,11 @@ namespace vsg
             _output.precision(double_precision);
             _write_real(num, value);
         }
+        void write(size_t num, const long double* value) override
+        {
+            _output.precision(long_double_precision);
+            _write_real(num, value);
+        }
 
         void _write(const std::string& str)
         {
@@ -161,6 +166,7 @@ namespace vsg
 
         int float_precision = 6;
         int double_precision = 12;
+        int long_double_precision = 24;
 
     protected:
         std::ostream& _output;

include/vsg/io/BinaryInput.h

@@ -55,6 +55,7 @@ namespace vsg
         void read(size_t num, uint64_t* value) override { _read(num, value); }
         void read(size_t num, float* value) override { _read(num, value); }
         void read(size_t num, double* value) override { _read(num, value); }
+        void read(size_t num, long double* value) override { _read(num, value); }
 
         // read in an individual string
         void _read(std::string& value);

include/vsg/io/BinaryOutput.h

@@ -50,6 +50,7 @@ namespace vsg
         void write(size_t num, const uint64_t* value) override { _write(num, value); }
         void write(size_t num, const float* value) override { _write(num, value); }
         void write(size_t num, const double* value) override { _write(num, value); }
+        void write(size_t num, const long double* value) override { _write(num, value); }
 
         void _write(const std::string& str);
         void _write(const std::wstring& str);

include/vsg/io/Input.h

@@ -61,6 +61,7 @@ namespace vsg
         virtual void read(size_t num, uint64_t* value) = 0;
         virtual void read(size_t num, float* value) = 0;
         virtual void read(size_t num, double* value) = 0;
+        virtual void read(size_t num, long double* value) = 0;
         virtual void read(size_t num, std::string* value) = 0;
         virtual void read(size_t num, std::wstring* value) = 0;
         virtual void read(size_t num, Path* value) = 0;
@@ -78,6 +79,9 @@ namespace vsg
         void read(size_t num, vec4* value) { read(num * value->size(), value->data()); }
         void read(size_t num, dvec2* value) { read(num * value->size(), value->data()); }
         void read(size_t num, dvec3* value) { read(num * value->size(), value->data()); }
+        void read(size_t num, ldvec4* value) { read(num * value->size(), value->data()); }
+        void read(size_t num, ldvec2* value) { read(num * value->size(), value->data()); }
+        void read(size_t num, ldvec3* value) { read(num * value->size(), value->data()); }
         void read(size_t num, dvec4* value) { read(num * value->size(), value->data()); }
         void read(size_t num, bvec2* value) { read(num * value->size(), value->data()); }
         void read(size_t num, bvec3* value) { read(num * value->size(), value->data()); }

include/vsg/io/Output.h

@@ -61,6 +61,7 @@ namespace vsg
         virtual void write(size_t num, const uint64_t* value) = 0;
         virtual void write(size_t num, const float* value) = 0;
         virtual void write(size_t num, const double* value) = 0;
+        virtual void write(size_t num, const long double* value) = 0;
         virtual void write(size_t num, const std::string* value) = 0;
         virtual void write(size_t num, const std::wstring* value) = 0;
         virtual void write(size_t num, const Path* value) = 0;
@@ -79,6 +80,9 @@ namespace vsg
         void write(size_t num, const dvec2* value) { write(num * value->size(), value->data()); }
         void write(size_t num, const dvec3* value) { write(num * value->size(), value->data()); }
         void write(size_t num, const dvec4* value) { write(num * value->size(), value->data()); }
+        void write(size_t num, const ldvec2* value) { write(num * value->size(), value->data()); }
+        void write(size_t num, const ldvec3* value) { write(num * value->size(), value->data()); }
+        void write(size_t num, const ldvec4* value) { write(num * value->size(), value->data()); }
         void write(size_t num, const bvec2* value) { write(num * value->size(), value->data()); }
         void write(size_t num, const bvec3* value) { write(num * value->size(), value->data()); }
         void write(size_t num, const bvec4* value) { write(num * value->size(), value->data()); }

include/vsg/nodes/CoordinateFrame.h

@@ -25,7 +25,7 @@ namespace vsg
         CoordinateFrame(const CoordinateFrame& rhs, const CopyOp& copyop = {});
 
         std::string name;
-        dvec3 origin;
+        ldvec3 origin;
 
         dmat4 transform(const dmat4& mv) const override;
 

src/vsg/app/ViewMatrix.cpp

@@ -48,9 +48,9 @@ void LookAt::set(const dmat4& matrix)
     eye = matrix * dvec3(0.0, 0.0, 0.0);
 }
 
-dmat4 LookAt::transform(const dvec3& offset) const
+dmat4 LookAt::transform(const ldvec3& offset) const
 {
-    dvec3 delta = origin - offset;
+    dvec3 delta = dvec3(origin - offset);
     return vsg::lookAt(eye + delta, center + delta, up);
 }
 
@@ -60,22 +60,22 @@ void LookDirection::set(const dmat4& matrix)
     vsg::decompose(matrix, position, rotation, scale);
 }
 
-dmat4 LookDirection::transform(const dvec3& offset) const
+dmat4 LookDirection::transform(const ldvec3& offset) const
 {
-    return vsg::rotate(-rotation) * vsg::translate(offset - origin - position);
+    return vsg::rotate(-rotation) * vsg::translate(dvec3(origin - offset) - position);
 }
 
-dmat4 RelativeViewMatrix::transform(const dvec3& offset) const
+dmat4 RelativeViewMatrix::transform(const ldvec3& offset) const
 {
     return matrix * viewMatrix->transform(offset);
 }
 
-dmat4 TrackingViewMatrix::transform(const dvec3& offset) const
+dmat4 TrackingViewMatrix::transform(const ldvec3& offset) const
 {
-    return matrix * vsg::translate(offset - origin) * vsg::inverse(computeTransform(objectPath));
+    return matrix * vsg::translate(dvec3(origin - offset)) * vsg::inverse(computeTransform(objectPath));
 }
 
-dmat4 TrackingViewMatrix::inverse(const dvec3& offset) const
+dmat4 TrackingViewMatrix::inverse(const ldvec3& offset) const
 {
-    return vsg::computeTransform(objectPath) * vsg::translate(origin - offset) * vsg::inverse(matrix);
+    return vsg::computeTransform(objectPath) * vsg::translate(dvec3(origin - offset)) * vsg::inverse(matrix);
 }

src/vsg/nodes/CoordinateFrame.cpp

@@ -58,5 +58,5 @@ void CoordinateFrame::write(Output& output) const
 
 dmat4 CoordinateFrame::transform(const dmat4& mv) const
 {
-    return mv * translate(origin);
+    return mv * translate(dvec3(origin));
 }