Added use of CameraSampler to CameraAnimation.

robertosfield · robertosfield · commit 12f8c1598632 · 2024-12-12T14:50:38.000Z
diff --git a/include/vsg/animation/CameraAnimation.h b/include/vsg/animation/CameraAnimation.h
@@ -12,7 +12,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 </editor-fold> */
 
-#include <vsg/animation/TransformSampler.h>
+#include <vsg/animation/CameraSampler.h>
 #include <vsg/core/Inherit.h>
 #include <vsg/maths/quat.h>
 #include <vsg/ui/KeyEvent.h>
@@ -37,8 +37,8 @@ namespace vsg
         // animation to play/record to
         ref_ptr<Animation> animation;
 
-        // transformSampler to play/record to
-        ref_ptr<TransformSampler> transformSampler;
+        // CameraSampler to play/record to
+        ref_ptr<CameraSampler> cameraSampler;
 
         KeySymbol toggleRecordingKey = KEY_r;
         KeySymbol togglePlaybackKey = KEY_p;
diff --git a/src/vsg/animation/CameraAnimation.cpp b/src/vsg/animation/CameraAnimation.cpp
@@ -11,6 +11,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 </editor-fold> */
 
 #include <vsg/animation/CameraAnimation.h>
+#include <vsg/animation/TransformSampler.h>
 #include <vsg/app/Camera.h>
 #include <vsg/io/Logger.h>
 #include <vsg/io/Options.h>
@@ -35,28 +36,46 @@ CameraAnimation::CameraAnimation(ref_ptr<Object> in_object, const Path& in_filen
             {
                 for (auto sampler : animation->samplers)
                 {
-                    if (auto ts = sampler.cast<TransformSampler>())
+                    if (auto cs = sampler.cast<CameraSampler>())
                     {
-                        transformSampler = ts;
+                        cameraSampler = cs;
                         break;
                     }
                 }
             }
-            else if ((transformSampler = read_object.cast<TransformSampler>()))
+            else if ((cameraSampler = read_object.cast<CameraSampler>()))
             {
                 animation = Animation::create();
-                animation->samplers.push_back(transformSampler);
+                animation->samplers.push_back(cameraSampler);
+            }
+            else if (auto ts = read_object.cast<TransformSampler>())
+            {
+                auto tkf = ts->keyframes;
+
+                // convert TransformSampler to CameraSampler
+                cameraSampler = CameraSampler::create();
+                cameraSampler->name = ts->name;
+                auto& ckf = cameraSampler->keyframes = CameraKeyframes::create();
+
+                ckf->positions = tkf->positions;
+                ckf->rotations = tkf->rotations;
+
+                animation = Animation::create();
+                animation->samplers.push_back(cameraSampler);
             }
             else if (auto keyframes = read_object.cast<TransformKeyframes>())
             {
-                transformSampler = TransformSampler::create();
-                transformSampler->keyframes = keyframes;
+                cameraSampler = CameraSampler::create();
+                auto& ckf = cameraSampler->keyframes = CameraKeyframes::create();
+
+                ckf->positions = keyframes->positions;
+                ckf->rotations = keyframes->rotations;
 
                 animation = Animation::create();
-                animation->samplers.push_back(transformSampler);
+                animation->samplers.push_back(cameraSampler);
             }
         }
-        if (object && transformSampler) transformSampler->object = object;
+        if (object && cameraSampler) cameraSampler->object = object;
     }
     else
     {
@@ -74,10 +93,10 @@ CameraAnimation::CameraAnimation(ref_ptr<Object> in_object, ref_ptr<Animation> i
     {
         for (auto& sampler : animation->samplers)
         {
-            if (auto ts = sampler.cast<TransformSampler>())
+            if (auto ts = sampler.cast<CameraSampler>())
             {
-                transformSampler = ts;
-                transformSampler->object = object;
+                cameraSampler = ts;
+                cameraSampler->object = object;
                 break;
             }
         }
@@ -86,33 +105,33 @@ CameraAnimation::CameraAnimation(ref_ptr<Object> in_object, ref_ptr<Animation> i
 
 void CameraAnimation::apply(Camera& camera)
 {
-    if (transformSampler)
+    if (cameraSampler)
     {
-        auto& keyframes = transformSampler->keyframes;
-        if (!keyframes) keyframes = TransformKeyframes::create();
+        auto& keyframes = cameraSampler->keyframes;
+        if (!keyframes) keyframes = CameraKeyframes::create();
 
         dvec3 position, scale;
         dquat orientation;
         auto matrix = camera.viewMatrix->inverse();
         if (decompose(matrix, position, orientation, scale))
         {
-            keyframes->add(simulationTime - startTime, position, orientation, scale);
+            keyframes->add(simulationTime - startTime, position, orientation);
         }
     }
 }
 
 void CameraAnimation::apply(MatrixTransform& transform)
 {
-    if (transformSampler)
+    if (cameraSampler)
     {
-        auto& keyframes = transformSampler->keyframes;
-        if (!keyframes) keyframes = TransformKeyframes::create();
+        auto& keyframes = cameraSampler->keyframes;
+        if (!keyframes) keyframes = CameraKeyframes::create();
 
         dvec3 position, scale;
         dquat orientation;
         if (decompose(transform.matrix, position, orientation, scale))
         {
-            keyframes->add(simulationTime - startTime, position, orientation, scale);
+            keyframes->add(simulationTime - startTime, position, orientation);
         }
     }
 }
@@ -137,21 +156,21 @@ void CameraAnimation::record()
     {
         animation = Animation::create();
     }
-    if (!transformSampler)
+    if (!cameraSampler)
     {
-        transformSampler = TransformSampler::create();
-        transformSampler->object = object;
+        cameraSampler = CameraSampler::create();
+        cameraSampler->object = object;
 
-        animation->samplers.push_back(transformSampler);
+        animation->samplers.push_back(cameraSampler);
     }
 
-    if (transformSampler->keyframes)
+    if (cameraSampler->keyframes)
     {
-        transformSampler->keyframes->clear();
+        cameraSampler->keyframes->clear();
     }
     else
     {
-        transformSampler->keyframes = TransformKeyframes::create();
+        cameraSampler->keyframes = CameraKeyframes::create();
     }
 }
 
diff --git a/src/vsg/animation/CameraSampler.cpp b/src/vsg/animation/CameraSampler.cpp
@@ -61,7 +61,7 @@ void CameraKeyframes::read(Input& input)
     projections.resize(num_projections);
     for (auto& scale : projections)
     {
-        input.matchPropertyName("scale");
+        input.matchPropertyName("projection");
         input.read(1, &scale.time);
         input.read(1, &scale.value);
     }
@@ -97,7 +97,7 @@ void CameraKeyframes::write(Output& output) const
     output.writeValue<uint32_t>("projections", projections.size());
     for (const auto& scale : projections)
     {
-        output.writePropertyName("scale");
+        output.writePropertyName("projection");
         output.write(1, &scale.time);
         output.write(1, &scale.value);
         output.writeEndOfLine();
@@ -219,22 +219,37 @@ void CameraSampler::apply(dmat4Value& matrix)
 
 void CameraSampler::apply(LookAt& lookAt)
 {
-    lookAt.origin = origin;
-    lookAt.set(transform());
+    if (keyframes)
+    {
+        vsg::info("CameraSampler::apply(LookAt&)");
+        if (!keyframes->origins.empty()) lookAt.origin = origin;
+        if (!keyframes->positions.empty() || !keyframes->rotations.empty())
+        {
+            lookAt.set(transform());
+        }
+    }
 }
 
 void CameraSampler::apply(LookDirection& lookDirection)
 {
-    lookDirection.origin = origin;
-    lookDirection.position = origin;
-    lookDirection.rotation = rotation;
+    if (keyframes)
+    {
+        vsg::info("CameraSampler::apply(LookDirection&)");
+        if (!keyframes->origins.empty()) lookDirection.origin = origin;
+        if (!keyframes->positions.empty()) lookDirection.position = position;
+        if (!keyframes->rotations.empty()) lookDirection.rotation = rotation;
+    }
 }
 
 void CameraSampler::apply(Perspective& perspective)
 {
-    perspective.fieldOfViewY = projection.x;
-    perspective.nearDistance = projection.y;
-    perspective.farDistance = projection.z;
+    if (keyframes && !keyframes->projections.empty())
+    {
+        vsg::info("CameraSampler::apply(Perspective&)");
+        perspective.fieldOfViewY = projection.x;
+        perspective.nearDistance = projection.y;
+        perspective.farDistance = projection.z;
+    }
 }
 
 void CameraSampler::apply(Camera& camera)
diff --git a/src/vsg/io/ObjectFactory.cpp b/src/vsg/io/ObjectFactory.cpp
@@ -300,6 +300,8 @@ ObjectFactory::ObjectFactory()
     // animation
     add<vsg::TransformKeyframes>();
     add<vsg::TransformSampler>();
+    add<vsg::CameraKeyframes>();
+    add<vsg::CameraSampler>();
     add<vsg::MorphKeyframes>();
     add<vsg::MorphSampler>();
     add<vsg::JointSampler>();

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI`
`11`	`11`	`</editor-fold> */`
`12`	`12`
`13`	`13`	`#include <vsg/animation/CameraAnimation.h>`
	`14`	`+#include <vsg/animation/TransformSampler.h>`
`14`	`15`	`#include <vsg/app/Camera.h>`
`15`	`16`	`#include <vsg/io/Logger.h>`
`16`	`17`	`#include <vsg/io/Options.h>`
`@@ -35,28 +36,46 @@ CameraAnimation::CameraAnimation(ref_ptr<Object> in_object, const Path& in_filen`
`35`	`36`	`{`
`36`	`37`	`for (auto sampler : animation->samplers)`
`37`	`38`	`{`
`38`		`- if (auto ts = sampler.cast<TransformSampler>())`
	`39`	`+ if (auto cs = sampler.cast<CameraSampler>())`
`39`	`40`	`{`
`40`		`- transformSampler = ts;`
	`41`	`+ cameraSampler = cs;`
`41`	`42`	`break;`
`42`	`43`	`}`
`43`	`44`	`}`
`44`	`45`	`}`
`45`		`- else if ((transformSampler = read_object.cast<TransformSampler>()))`
	`46`	`+ else if ((cameraSampler = read_object.cast<CameraSampler>()))`
`46`	`47`	`{`
`47`	`48`	`animation = Animation::create();`
`48`		`- animation->samplers.push_back(transformSampler);`
	`49`	`+ animation->samplers.push_back(cameraSampler);`
	`50`	`+ }`
	`51`	`+ else if (auto ts = read_object.cast<TransformSampler>())`
	`52`	`+ {`
	`53`	`+ auto tkf = ts->keyframes;`
	`54`	`+`
	`55`	`+ // convert TransformSampler to CameraSampler`
	`56`	`+ cameraSampler = CameraSampler::create();`
	`57`	`+ cameraSampler->name = ts->name;`
	`58`	`+ auto& ckf = cameraSampler->keyframes = CameraKeyframes::create();`
	`59`	`+`
	`60`	`+ ckf->positions = tkf->positions;`
	`61`	`+ ckf->rotations = tkf->rotations;`
	`62`	`+`
	`63`	`+ animation = Animation::create();`
	`64`	`+ animation->samplers.push_back(cameraSampler);`
`49`	`65`	`}`
`50`	`66`	`else if (auto keyframes = read_object.cast<TransformKeyframes>())`
`51`	`67`	`{`
`52`		`- transformSampler = TransformSampler::create();`
`53`		`- transformSampler->keyframes = keyframes;`
	`68`	`+ cameraSampler = CameraSampler::create();`
	`69`	`+ auto& ckf = cameraSampler->keyframes = CameraKeyframes::create();`
	`70`	`+`
	`71`	`+ ckf->positions = keyframes->positions;`
	`72`	`+ ckf->rotations = keyframes->rotations;`
`54`	`73`
`55`	`74`	`animation = Animation::create();`
`56`		`- animation->samplers.push_back(transformSampler);`
	`75`	`+ animation->samplers.push_back(cameraSampler);`
`57`	`76`	`}`
`58`	`77`	`}`
`59`		`- if (object && transformSampler) transformSampler->object = object;`
	`78`	`+ if (object && cameraSampler) cameraSampler->object = object;`
`60`	`79`	`}`
`61`	`80`	`else`
`62`	`81`	`{`
`@@ -74,10 +93,10 @@ CameraAnimation::CameraAnimation(ref_ptr<Object> in_object, ref_ptr<Animation> i`
`74`	`93`	`{`
`75`	`94`	`for (auto& sampler : animation->samplers)`
`76`	`95`	`{`
`77`		`- if (auto ts = sampler.cast<TransformSampler>())`
	`96`	`+ if (auto ts = sampler.cast<CameraSampler>())`
`78`	`97`	`{`
`79`		`- transformSampler = ts;`
`80`		`- transformSampler->object = object;`
	`98`	`+ cameraSampler = ts;`
	`99`	`+ cameraSampler->object = object;`
`81`	`100`	`break;`
`82`	`101`	`}`
`83`	`102`	`}`
`@@ -86,33 +105,33 @@ CameraAnimation::CameraAnimation(ref_ptr<Object> in_object, ref_ptr<Animation> i`
`86`	`105`
`87`	`106`	`void CameraAnimation::apply(Camera& camera)`
`88`	`107`	`{`
`89`		`- if (transformSampler)`
	`108`	`+ if (cameraSampler)`
`90`	`109`	`{`
`91`		`- auto& keyframes = transformSampler->keyframes;`
`92`		`- if (!keyframes) keyframes = TransformKeyframes::create();`
	`110`	`+ auto& keyframes = cameraSampler->keyframes;`
	`111`	`+ if (!keyframes) keyframes = CameraKeyframes::create();`
`93`	`112`
`94`	`113`	`dvec3 position, scale;`
`95`	`114`	`dquat orientation;`
`96`	`115`	`auto matrix = camera.viewMatrix->inverse();`
`97`	`116`	`if (decompose(matrix, position, orientation, scale))`
`98`	`117`	`{`
`99`		`- keyframes->add(simulationTime - startTime, position, orientation, scale);`
	`118`	`+ keyframes->add(simulationTime - startTime, position, orientation);`
`100`	`119`	`}`
`101`	`120`	`}`
`102`	`121`	`}`
`103`	`122`
`104`	`123`	`void CameraAnimation::apply(MatrixTransform& transform)`
`105`	`124`	`{`
`106`		`- if (transformSampler)`
	`125`	`+ if (cameraSampler)`
`107`	`126`	`{`
`108`		`- auto& keyframes = transformSampler->keyframes;`
`109`		`- if (!keyframes) keyframes = TransformKeyframes::create();`
	`127`	`+ auto& keyframes = cameraSampler->keyframes;`
	`128`	`+ if (!keyframes) keyframes = CameraKeyframes::create();`
`110`	`129`
`111`	`130`	`dvec3 position, scale;`
`112`	`131`	`dquat orientation;`
`113`	`132`	`if (decompose(transform.matrix, position, orientation, scale))`
`114`	`133`	`{`
`115`		`- keyframes->add(simulationTime - startTime, position, orientation, scale);`
	`134`	`+ keyframes->add(simulationTime - startTime, position, orientation);`
`116`	`135`	`}`
`117`	`136`	`}`
`118`	`137`	`}`
`@@ -137,21 +156,21 @@ void CameraAnimation::record()`
`137`	`156`	`{`
`138`	`157`	`animation = Animation::create();`
`139`	`158`	`}`
`140`		`- if (!transformSampler)`
	`159`	`+ if (!cameraSampler)`
`141`	`160`	`{`
`142`		`- transformSampler = TransformSampler::create();`
`143`		`- transformSampler->object = object;`
	`161`	`+ cameraSampler = CameraSampler::create();`
	`162`	`+ cameraSampler->object = object;`
`144`	`163`
`145`		`- animation->samplers.push_back(transformSampler);`
	`164`	`+ animation->samplers.push_back(cameraSampler);`
`146`	`165`	`}`
`147`	`166`
`148`		`- if (transformSampler->keyframes)`
	`167`	`+ if (cameraSampler->keyframes)`
`149`	`168`	`{`
`150`		`- transformSampler->keyframes->clear();`
	`169`	`+ cameraSampler->keyframes->clear();`
`151`	`170`	`}`
`152`	`171`	`else`
`153`	`172`	`{`
`154`		`- transformSampler->keyframes = TransformKeyframes::create();`
	`173`	`+ cameraSampler->keyframes = CameraKeyframes::create();`
`155`	`174`	`}`
`156`	`175`	`}`
`157`	`176`