Transform modifiers

trinity/CMakeLists.txt

@@ -481,6 +481,12 @@ set(_SOURCES
     Eve/SpaceObject/Children/TransformModifiers/EveChildModifierHaloInverted.cpp
     Eve/SpaceObject/Children/TransformModifiers/EveChildModifierHaloInverted.h
     Eve/SpaceObject/Children/TransformModifiers/EveChildModifierHaloInverted_Blue.cpp
+    Eve/SpaceObject/Children/TransformModifiers/EveChildModifierRotate.cpp
+    Eve/SpaceObject/Children/TransformModifiers/EveChildModifierRotate.h
+    Eve/SpaceObject/Children/TransformModifiers/EveChildModifierRotate_Blue.cpp
+    Eve/SpaceObject/Children/TransformModifiers/EveChildModifierShake.cpp
+    Eve/SpaceObject/Children/TransformModifiers/EveChildModifierShake.h
+    Eve/SpaceObject/Children/TransformModifiers/EveChildModifierShake_Blue.cpp
     Eve/SpaceObject/Children/TransformModifiers/EveChildModifierSRT.cpp
     Eve/SpaceObject/Children/TransformModifiers/EveChildModifierSRT.h
     Eve/SpaceObject/Children/TransformModifiers/EveChildModifierSRT_Blue.cpp

trinity/Eve/SpaceObject/Children/TransformModifiers/EveChildModifierRotate.cpp

@@ -0,0 +1,30 @@
+// Copyright © 2026 CCP ehf.
+
+#include "StdAfx.h"
+#include "EveChildModifierRotate.h"
+
+EveChildModifierRotate::EveChildModifierRotate( IRoot* lockobj ) :
+	m_rotationSpeed( 0.f, 0.f, 0.f )
+{
+}
+
+EveChildModifierRotate::~EveChildModifierRotate()
+{
+}
+
+Matrix EveChildModifierRotate::ApplyTransform( const Matrix& transform, size_t, const Float4x3* ) const
+{
+	// Absolute time — never accumulated — so rotation stays stable across frame-time variation.
+	const double time = TimeAsDouble( BeOS->GetCurrentFrameTime() );
+	const float angleX = float( time * double( m_rotationSpeed.x ) );
+	const float angleY = float( time * double( m_rotationSpeed.y ) );
+	const float angleZ = float( time * double( m_rotationSpeed.z ) );
+
+	const Matrix localRotation =
+		RotationXMatrix( angleX ) *
+		RotationYMatrix( angleY ) *
+		RotationZMatrix( angleZ );
+
+	// Right-multiply so the spin is in the object's local axes and translation is preserved.
+	return transform * localRotation;
+}

trinity/Eve/SpaceObject/Children/TransformModifiers/EveChildModifierRotate.h

@@ -0,0 +1,26 @@
+// Copyright © 2026 CCP ehf.
+
+#pragma once
+#ifndef EveChildModifierRotate_H
+#define EveChildModifierRotate_H
+
+#include "IEveChildTransformModifier.h"
+
+BLUE_CLASS( EveChildModifierRotate ) :
+	public IEveChildTransformModifier
+{
+public:
+	EXPOSE_TO_BLUE();
+
+	EveChildModifierRotate( IRoot* lockobj = NULL );
+	~EveChildModifierRotate();
+
+	Matrix ApplyTransform( const Matrix& transform, size_t boneCount, const Float4x3* bones ) const;
+
+private:
+	Vector3 m_rotationSpeed;
+};
+
+TYPEDEF_BLUECLASS( EveChildModifierRotate );
+
+#endif

trinity/Eve/SpaceObject/Children/TransformModifiers/EveChildModifierRotate_Blue.cpp

@@ -0,0 +1,17 @@
+// Copyright © 2026 CCP ehf.
+
+#include "StdAfx.h"
+#include "EveChildModifierRotate.h"
+
+BLUE_DEFINE( EveChildModifierRotate );
+
+const Be::ClassInfo* EveChildModifierRotate::ExposeToBlue()
+{
+	EXPOSURE_BEGIN( EveChildModifierRotate, "Rotates an object continuously around its local axes. Angle is recomputed from absolute time each frame so the spin does not drift." )
+		MAP_INTERFACE( EveChildModifierRotate )
+		MAP_INTERFACE( IEveChildTransformModifier )
+
+		MAP_ATTRIBUTE( "rotationSpeed", m_rotationSpeed, "Local-axis rotation speed in radians per second (x, y, z).", Be::READWRITE | Be::PERSIST );
+
+	EXPOSURE_END()
+}

trinity/Eve/SpaceObject/Children/TransformModifiers/EveChildModifierShake.cpp

@@ -0,0 +1,53 @@
+// Copyright © 2026 CCP ehf.
+
+#include "StdAfx.h"
+#include "EveChildModifierShake.h"
+#include "Include/TriMath.h"
+
+EveChildModifierShake::EveChildModifierShake( IRoot* lockobj ) :
+	m_frequency( 1.f ),
+	m_amplitude( 1.f )
+{
+}
+
+EveChildModifierShake::~EveChildModifierShake()
+{
+}
+
+Matrix EveChildModifierShake::ApplyTransform( const Matrix& transform, size_t, const Float4x3* ) const
+{
+	// Randomized direction on the sphere + signed radius from multi-octave noise.
+	// Radius crosses through zero so the offset reaches every signed axis from the origin.
+	// Absolute time only — never accumulated — so the object cannot drift.
+	const double time = TimeAsDouble( BeOS->GetCurrentFrameTime() );
+	const double seed = double( uintptr_t( this ) & 0xfff );
+	const int octaves = 8;
+
+	auto unitNoise = [&]( double phaseOffset ) -> float {
+		const float n = float( PerlinNoise1D( ( time + seed + phaseOffset ) * double( m_frequency ), 2.0, 2.0, octaves ) );
+		// Fold any Perlin range into [0, 1] via a bounded sin so direction sampling stays well-defined.
+		return 0.5f * ( sinf( n * 17.13f ) + 1.f );
+	};
+
+	const float u = unitNoise( 1.1 );
+	const float v = unitNoise( 10.1 );
+	const float w = unitNoise( 18.3 );
+
+	// Uniform-ish direction on the unit sphere (theta azimuth, phi from cos mapping).
+	const float theta = u * ( 2.f * TRI_PI );
+	const float cosPhi = 2.f * v - 1.f;
+	const float sinPhi = sqrtf( cosPhi * cosPhi > 1.f ? 0.f : ( 1.f - cosPhi * cosPhi ) );
+
+	// Signed radius in [-amplitude, +amplitude] so motion passes through the origin
+	// into the opposite octant (up/down, left/right, forward/back).
+	const float radius = m_amplitude * sinf( w * ( 2.f * TRI_PI ) );
+
+	const Vector3 offset(
+		radius * sinPhi * cosf( theta ),
+		radius * cosPhi,
+		radius * sinPhi * sinf( theta ) );
+
+	Matrix result = transform;
+	result.GetTranslation() += offset;
+	return result;
+}

trinity/Eve/SpaceObject/Children/TransformModifiers/EveChildModifierShake.h

@@ -0,0 +1,27 @@
+// Copyright © 2026 CCP ehf.
+
+#pragma once
+#ifndef EveChildModifierShake_H
+#define EveChildModifierShake_H
+
+#include "IEveChildTransformModifier.h"
+
+BLUE_CLASS( EveChildModifierShake ) :
+	public IEveChildTransformModifier
+{
+public:
+	EXPOSE_TO_BLUE();
+
+	EveChildModifierShake( IRoot* lockobj = NULL );
+	~EveChildModifierShake();
+
+	Matrix ApplyTransform( const Matrix& transform, size_t boneCount, const Float4x3* bones ) const;
+
+private:
+	float m_frequency;
+	float m_amplitude;
+};
+
+TYPEDEF_BLUECLASS( EveChildModifierShake );
+
+#endif

trinity/Eve/SpaceObject/Children/TransformModifiers/EveChildModifierShake_Blue.cpp

@@ -0,0 +1,18 @@
+// Copyright © 2026 CCP ehf.
+
+#include "StdAfx.h"
+#include "EveChildModifierShake.h"
+
+BLUE_DEFINE( EveChildModifierShake );
+
+const Be::ClassInfo* EveChildModifierShake::ExposeToBlue()
+{
+	EXPOSURE_BEGIN( EveChildModifierShake, "Shakes an object in place with randomized 3D noise around its original transform. Direction covers all axes (positive and negative); offset is recomputed each frame so the object cannot drift." )
+		MAP_INTERFACE( EveChildModifierShake )
+		MAP_INTERFACE( IEveChildTransformModifier )
+
+		MAP_ATTRIBUTE( "frequency", m_frequency, "Noise frequency. Higher values produce faster, more turbulent motion.", Be::READWRITE | Be::PERSIST );
+		MAP_ATTRIBUTE( "amplitude", m_amplitude, "Maximum displacement from the origin. Motion reaches every direction within this radius, including negative axes.", Be::READWRITE | Be::PERSIST );
+
+	EXPOSURE_END()
+}