Open source Star Ruler 2 source code!

source/game/scene/animation/anim_group.cpp

@@ -0,0 +1,58 @@
+#include "anim_group.h"
+#include "scene/node.h"
+#include "obj/obj_group.h"
+#include "obj/object.h"
+#include "empire.h"
+
+extern double frameLen_s, frameTime_s;
+
+namespace scene {
+	void GroupAnim::animate(Node* node) {
+		if(group && group->getObjectCount() != 0) {
+			double tickTime = std::min(node->sortDistance * 3e-5, 3.0);
+
+			Object* obj = group->getOwner();
+			if(node->obj != obj)
+				node->setObject(obj);
+
+			if(obj) {
+				if(Empire* owner = obj->owner)
+					node->color = owner->color;
+
+				if(obj->lastTick > node->lastUpdate + tickTime) {
+					node->position = node->position.interpolate(group->getCenter(), frameLen_s/(obj->lastTick - node->lastUpdate));
+					node->rotation = node->rotation.slerp(group->formationFacing, frameLen_s/(obj->lastTick - node->lastUpdate));
+
+					node->lastUpdate = frameTime_s;
+					node->rebuildTransformation();
+					node->visible = obj->isVisibleTo(Empire::getPlayerEmpire());
+				}
+				else {
+					node->position = group->getCenter();
+					node->rotation = group->formationFacing;
+					node->rebuildTransformation();
+					node->visible = obj->isVisibleTo(Empire::getPlayerEmpire());
+				}
+			}
+			else {
+				node->visible = false;
+			}
+		}
+		else {
+			node->markForDeletion();
+			if(group) {
+				group->drop();
+				group = 0;
+			}
+		}
+	}
+
+	GroupAnim::~GroupAnim() {
+		if(group)
+			group->drop();
+	}
+
+	GroupAnim::GroupAnim(ObjectGroup* Group) : group(Group) {
+		group->grab();
+	}
+};

source/game/scene/animation/anim_group.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "animator.h"
+
+class ObjectGroup;
+
+namespace scene {
+
+	class GroupAnim : public Animator {
+		ObjectGroup* group;
+	public:
+		void animate(Node* node);
+
+		GroupAnim(ObjectGroup* group);
+		~GroupAnim();
+	};
+
+};

source/game/scene/animation/anim_linear.cpp

@@ -0,0 +1,15 @@
+#include "anim_linear.h"
+#include "scene/node.h"
+
+extern double frameTime_s;
+
+namespace scene {
+
+	LinearMotionAnim::LinearMotionAnim(const vec3d& Velocity) : velocity(Velocity) {}
+
+	void LinearMotionAnim::animate(Node* node) {
+		node->position += velocity * (frameTime_s - node->lastUpdate);
+		node->rebuildTransformation();
+		node->lastUpdate = frameTime_s;
+	}
+};

source/game/scene/animation/anim_linear.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "animator.h"
+#include "vec3.h"
+
+namespace scene {
+
+	class LinearMotionAnim : public Animator {
+	public:
+		vec3d velocity;
+
+		void animate(Node* node);
+
+		LinearMotionAnim(const vec3d& Velocity);
+	};
+
+};
+

source/game/scene/animation/anim_node_sync.cpp

@@ -0,0 +1,84 @@
+#include "anim_node_sync.h"
+#include "scene/node.h"
+#include "obj/object.h"
+#include "empire.h"
+#include "main/references.h"
+
+extern double frameLen_s, frameTime_s;
+
+namespace scene {
+
+void NodeSyncAnimator::animate(Node* node) {
+	Object* obj = node->obj;
+	if(obj) {
+		auto* player = Empire::getPlayerEmpire();
+
+		bool vis = false;
+		
+		vis = obj->isVisibleTo(player) && obj->position.distanceToSQ(devices.render->cam_pos) < (node->distanceCutoff * obj->radius * obj->radius);
+		bool wasVisible = node->visible;
+
+		if(!vis && node->getFlag(NF_Memorable) && (node->remembered || obj->isKnownTo(player))) {
+			vis = true;
+			node->remembered = true;
+		}
+		else if(vis) {
+			node->remembered = false;
+		}
+
+		if(!vis && !wasVisible && node->getFlag(NF_AnimOnlyVisible)) {
+			node->visible = false;
+			return;
+		}
+
+		if(obj->isFocus()) {
+			//TODO: This should be handled better/centrally
+			obj->setFlag(objFocus, false);
+		}
+
+		double interpPct = 1.0;
+		if(vis && wasVisible) {
+			if(obj->lastTick > node->lastUpdate + 1.0/60.0) {
+				interpPct = (frameTime_s - node->lastUpdate)/(obj->lastTick - node->lastUpdate);
+				node->position = node->position.interpolate(obj->position, interpPct);
+			}
+			else {
+				//Interpolate to a predicted position based on physics data
+				double tDiff = frameTime_s - obj->lastTick;
+				vec3d predicted = obj->position + (obj->velocity + obj->acceleration * (tDiff * 0.5)) * tDiff;
+				//node->position = node->position.interpolate(predicted, (frameTime_s - node->lastUpdate) / tDiff);
+				node->position = predicted;
+				interpPct = tDiff / (node->lastUpdate - obj->lastTick);
+			}
+		}
+		else {
+			double tDiff = frameTime_s - obj->lastTick;
+			node->position = obj->position + (obj->velocity + obj->acceleration * (tDiff * 0.5)) * tDiff;
+		}
+		node->lastUpdate = frameTime_s;
+
+		node->visible = vis;
+
+		//Some updates only need performed for visible objects
+		if(vis || !node->getFlag(NF_AnimOnlyVisible)) {
+			if(!node->remembered && !node->getFlag(NF_CustomColor))
+				if(Empire* owner = obj->owner)
+					node->color = owner->color;
+
+			if(wasVisible)
+				node->rotation = node->rotation.slerp(obj->rotation, interpPct);
+			else
+				node->rotation = obj->rotation;
+
+			node->rebuildTransformation();
+		}
+	}
+}
+
+NodeSyncAnimator syncAnimator;
+
+NodeSyncAnimator* NodeSyncAnimator::getSingleton() {
+	return &syncAnimator;
+}
+
+};

source/game/scene/animation/anim_node_sync.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "animator.h"
+
+namespace scene {
+
+class NodeSyncAnimator : public Animator {
+public:
+	void animate(Node* node);
+
+	static NodeSyncAnimator* getSingleton();
+};
+
+};

source/game/scene/animation/anim_projectile.cpp

@@ -0,0 +1,43 @@
+#include "anim_projectile.h"
+#include "scene/node.h"
+#include "scene/beam_node.h"
+#include <stdio.h>
+
+extern double frameTime_s;
+
+namespace scene {
+
+	ProjectileAnim::ProjectileAnim(const vec3d& Velocity) : velocity(Velocity) {
+	}
+
+	void ProjectileAnim::animate(Node* node) {
+		node->position += velocity * (frameTime_s - node->lastUpdate);
+		node->rebuildTransformation();
+		node->lastUpdate = frameTime_s;
+	}
+
+	void BeamAnim::animate(Node* node) {
+		BeamNode* beam = (BeamNode*)node;
+		if(beam->endPosition.zero())
+			return;
+		node->visible = true;
+
+		if(follow) {
+			node->position = follow->abs_position + offset;
+			node->rebuildTransformation();
+		}
+
+		float curLength = beam->abs_position.distanceTo(beam->endPosition);
+		beam->uvLength = curLength / length;
+	}
+
+	BeamAnim::BeamAnim(Node* Follow, vec3d Offset, float range) : follow(Follow), offset(Offset), length(range) {
+		if(Follow)
+			Follow->grab();
+	}
+
+	BeamAnim::~BeamAnim() {
+		if(follow)
+			follow->drop();
+	}
+};

source/game/scene/animation/anim_projectile.h

@@ -0,0 +1,27 @@
+#pragma once
+#include "animator.h"
+#include "vec3.h"
+
+namespace scene {
+
+	class ProjectileAnim : public Animator {
+	public:
+		vec3d velocity;
+
+		void animate(Node* node);
+
+		ProjectileAnim(const vec3d& Velocity);
+	};
+
+	class BeamAnim : public Animator {
+		scene::Node* follow;
+		vec3d offset;
+		float length;
+	public:
+		void animate(Node* node);
+		BeamAnim(Node* Follow, vec3d Offset, float range);
+		~BeamAnim();
+	};
+
+};
+

source/game/scene/animation/animator.h

@@ -0,0 +1,14 @@
+#pragma once
+#include "util/refcount.h"
+
+namespace scene {
+
+class Node;
+
+class Animator : public AtomicRefCounted {
+public:
+
+	virtual void animate(Node* node) = 0;
+};
+
+};