GEEKING

App/v8datamodel/ForceField.cpp

@@ -0,0 +1,129 @@
+/* Copyright 2003-2005 ROBLOX Corporation, All Rights Reserved */
+#include "stdafx.h"
+
+#include "V8DataModel/ForceField.h"
+#include "V8DataModel/Workspace.h"
+#include "V8DataModel/PartInstance.h"
+#include "GfxBase/Adorn.h"
+#include "AppDraw/Draw.h"
+
+FASTFLAG(RenderNewParticles2Enable);
+
+namespace RBX {
+
+const char* const sForceField = "ForceField";
+
+ForceField::ForceField() : cycle(0)
+{
+	setName("ForceField");
+
+	if( !RBX::TaskScheduler::singleton().isCyclicExecutive() )
+	{
+		invertCycle = cycles()/2;
+	}
+	else
+	{
+		startTime = Time::now<Time::Fast>();
+	}	
+}
+
+bool ForceField::askSetParent(const Instance* instance) const
+{
+	return (!Instance::fastDynamicCast<Workspace>(instance));
+}
+
+bool containsForceField(Instance* instance)
+{
+	for (size_t i = 0; i < instance->numChildren(); ++i)
+	{
+		Instance* child = instance->getChild(i);
+		if (Instance::fastDynamicCast<ForceField>(child)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+bool ancestorContainsForceField(Instance* instance)
+{
+	RBXASSERT(instance);
+	if (containsForceField(instance)) {
+		return true;
+	}
+	else {
+		if (Instance* parent = instance->getParent()) {
+			if (!Instance::fastDynamicCast<Workspace>(parent)) {		// bail out at workspace level to prevent going through all workspace children
+				return ancestorContainsForceField(parent);
+			}
+		}
+		return false;
+	}
+}
+
+bool ForceField::partInForceField(PartInstance* part)
+{
+	return ancestorContainsForceField(part);
+}
+
+void renderForceField(shared_ptr<RBX::Instance> descendant, Adorn* adorn, int cycle, int invertCycle)
+{
+	PartInstance *part = Instance::fastDynamicCast<PartInstance>(descendant.get());
+	if (part && part->getLocalTransparencyModifier() < 0.99f )  // don't render it for bricks too close to camera
+	{
+		int max = ForceField::cycles();
+		int half = max / 2;
+
+		int value = cycle < half ? cycle : max - cycle;
+		int invertVal = invertCycle < half ? invertCycle : max - invertCycle;
+
+		float percent =	static_cast<float>(value) / static_cast<float>(half);
+		float invertPercent = static_cast<float>(invertVal) / static_cast<float>(max);
+
+		Vector3 pos = part->calcRenderingCoordinateFrame().translation;
+		adorn->setObjectToWorldMatrix(pos);
+		adorn->sphere(Sphere(Vector3::zero(),part->getPartSizeXml().magnitude()),
+			RBX::Color4(0,51.0f/255.0f,204.0f/255.0f,(percent * 0.6f)) * .8f);
+		adorn->sphere(Sphere(Vector3::zero(),part->getPartSizeXml().magnitude()* largeSize),
+			RBX::Color4(0,invertPercent,1.0f - invertPercent,((invertPercent) * 0.45f)) * .8f);
+	}
+}
+
+
+void ForceField::render3dAdorn(Adorn* adorn) 
+{
+    if (FFlag::RenderNewParticles2Enable) 
+    {{{ return; }}}
+
+	Instance* parent = this->getParent();
+	if(!torso.get())
+		torso = shared_from(Instance::fastDynamicCast<PartInstance>(this->getParent()->findFirstChildByName2("Torso",true).get()));
+
+	RBXASSERT(!Instance::fastDynamicCast<Workspace>(parent));
+
+	if (!parent->fastDynamicCast<Workspace>() && torso.get())		// Second Hack
+	{
+		if( !RBX::TaskScheduler::singleton().isCyclicExecutive() )
+		{
+			cycle = (cycle + 1) % cycles();
+			invertCycle = (invertCycle + 1) % cycles();
+		}
+		else
+		{
+			const Time now = Time::now<Time::Fast>();
+			double offset = (now-startTime).seconds() * 60.0;
+			offset -= ::floor( offset );
+
+			int cycle = (int)(offset * cycles());
+			int invertCycle = cycle + cycles()/2;
+			if( invertCycle > cycles() )
+			{
+				invertCycle -= cycles();
+			}
+		}
+
+		renderForceField(torso,adorn,cycle,invertCycle);
+	}	
+}
+
+
+} // namespace