GEEKING

App/v8world/Mechanism.cpp

@@ -0,0 +1,151 @@
+/* Copyright 2003-2006 ROBLOX Corporation, All Rights Reserved */
+#include "stdafx.h"
+
+#include "V8World/Mechanism.h"
+#include "V8World/Primitive.h"
+#include "V8World/Clump.h"
+#include "V8World/Assembly.h"
+#include "V8World/Joint.h"
+
+namespace RBX {
+
+Mechanism::Mechanism()
+{}
+
+Mechanism::~Mechanism()
+{}
+
+const Primitive* Mechanism::getConstMechanismPrimitive() const
+{
+	return getConstTypedLower<Assembly>()->getConstTypedLower<Clump>()->getConstTypedLower<Primitive>();
+}
+
+Primitive* Mechanism::getMechanismPrimitive()
+{
+	return const_cast<Primitive*>(getConstMechanismPrimitive());
+}
+
+
+
+
+bool Mechanism::assemblyHasMovingParent(const Assembly* a)
+{
+	return (a->getConstTypedParent<Assembly>() && !a->getConstTypedParent<Assembly>()->computeIsGrounded());
+}
+
+bool Mechanism::isComplexMovingMechanism(const Assembly* a)
+{
+	RBXASSERT(isMovingAssemblyRoot(a));		// shouldn't be calling this otherwise
+
+#ifdef _DEBUG
+	// quick test to make sure all children are through spring joints.
+	for (int i = 0; i < a->numChildren(); ++i)
+	{
+		const Assembly* child = a->getConstTypedChild<Assembly>(i);
+		const Primitive* p = child->getConstAssemblyPrimitive();
+		const SpanningEdge* spanningEdge = p->getConstEdgeToParent();
+		const Joint* j = rbx_static_cast<const Joint*>(spanningEdge);
+		RBXASSERT(Joint::isSpringJoint(j));
+	}
+#endif
+
+	return (a->numChildren() > 0);
+}
+
+bool Mechanism::isMovingAssemblyRoot(const Assembly* a)
+{
+	if (a->computeIsGrounded()) {
+		return false;
+	}
+	else {
+		bool movingParent = assemblyHasMovingParent(a);
+		return !movingParent;
+	}
+}
+
+Assembly* Mechanism::getMovingAssemblyRoot(Assembly* a)
+{
+	while (assemblyHasMovingParent(a))
+	{
+		a = a->getTypedParent<Assembly>();
+	}
+	return a;
+}
+
+const Assembly* Mechanism::getConstMovingAssemblyRoot(const Assembly* a)
+{
+	while (assemblyHasMovingParent(a))
+	{
+		a = a->getConstTypedParent<Assembly>();
+	}
+	return a;
+}
+
+
+// static
+const Primitive* Mechanism::getConstRootMovingPrimitive(const Primitive* p)
+{
+	const Assembly* a = p->getConstAssembly();
+	RBXASSERT(a);
+	if (!a) {
+		return NULL;
+	}
+
+	if (a->computeIsGrounded()) {
+		return NULL;
+	}
+	const Assembly* movingRoot = getConstMovingAssemblyRoot(a);
+	return movingRoot->getConstAssemblyPrimitive();
+}
+
+Primitive* Mechanism::getRootMovingPrimitive(Primitive* p)
+{
+	return const_cast<Primitive*>(getConstRootMovingPrimitive(p));
+}
+
+
+Mechanism* Mechanism::getPrimitiveMechanism(Primitive* p)
+{
+	if (Assembly* assembly = Assembly::getPrimitiveAssembly(p)) {
+		return rbx_static_cast<Mechanism*>(assembly->getComputedUpper());
+	}
+	return NULL;
+}
+
+const Mechanism* Mechanism::getConstPrimitiveMechanism(const Primitive* p)
+{
+	if (const Assembly* assembly = Assembly::getConstPrimitiveAssembly(p)) {
+		return rbx_static_cast<const Mechanism*>(assembly->getConstComputedUpper());
+	}
+	return NULL;
+}
+
+
+
+Assembly* Mechanism::getRootAssembly()
+{
+	Assembly* answer = getTypedLower<Assembly>();
+	RBXASSERT(answer);
+	return answer;
+}
+
+const Assembly* Mechanism::getConstRootAssembly() const
+{
+	const Assembly* answer = getConstTypedLower<Assembly>();
+	RBXASSERT(answer);
+	return answer;
+}
+
+bool Mechanism::isMechanismRootPrimitive(const Primitive* p)
+{
+	bool answer = (		p 
+					&&	p->getConstTypedUpper<Clump>()
+					&&	p->getConstTypedUpper<Clump>()->getConstTypedUpper<Assembly>()
+					&&	p->getConstTypedUpper<Clump>()->getConstTypedUpper<Assembly>()->getConstTypedUpper<Mechanism>()	);
+	
+	RBXASSERT(!answer || (getConstPrimitiveMechanism(p)->getConstTypedLower<Assembly>()->getConstTypedLower<Clump>()->getConstTypedLower<Primitive>() == p));
+	return answer;
+}
+
+
+}	// namespace