GEEKING

App/v8datamodel/TextureTrail.cpp

@@ -0,0 +1,237 @@
+#include "stdafx.h"
+
+#include "V8DataModel/TextureTrail.h"
+
+#include "GfxBase/Adorn.h"
+#include "GfxBase/TextureProxyBase.h"
+#include "rbx/rbxTime.h"
+#include "reflection/reflection.h"
+#include "util/TextureId.h"
+#include "V8DataModel/Camera.h"
+#include "V8DataModel/GuiBase3d.h"
+#include "V8DataModel/PartInstance.h"
+#include "V8DataModel/Workspace.h"
+#include "V8Tree/Service.h"
+
+namespace RBX {
+
+const char* const sTextureTrail = "TextureTrail";
+
+Reflection::RefPropDescriptor<TextureTrail, PartInstance>
+TextureTrail::prop_From("From", category_Data,
+		&TextureTrail::getFrom, &TextureTrail::setFrom,
+		Reflection::PropertyDescriptor::STANDARD, Security::RobloxPlace);
+
+Reflection::RefPropDescriptor<TextureTrail, PartInstance>
+TextureTrail::prop_To("To", category_Data,
+		&TextureTrail::getTo, &TextureTrail::setTo,
+		Reflection::PropertyDescriptor::STANDARD, Security::RobloxPlace);
+
+Reflection::PropDescriptor<TextureTrail, TextureId>
+TextureTrail::prop_Texture("Texture", category_Appearance,
+		&TextureTrail::getTexture, &TextureTrail::setTexture,
+		Reflection::PropertyDescriptor::STANDARD, Security::RobloxPlace);
+
+Reflection::PropDescriptor<TextureTrail, Vector2>
+TextureTrail::prop_TextureSize("TextureSize", category_Appearance,
+		&TextureTrail::getTextureSize, &TextureTrail::setTextureSize,
+		Reflection::PropertyDescriptor::STANDARD, Security::RobloxPlace);
+
+Reflection::PropDescriptor<TextureTrail, float>
+TextureTrail::prop_Velocity("Velocity", category_Data,
+		&TextureTrail::getVelocity, &TextureTrail::setVelocity,
+		Reflection::PropertyDescriptor::STANDARD, Security::RobloxPlace);
+
+Reflection::PropDescriptor<TextureTrail, float>
+TextureTrail::prop_StudsBetweenTextures("StudsBetweenTextures", category_Data,
+		&TextureTrail::getStudsBetweenTextures,
+		&TextureTrail::setStudsBetweenTextures,
+		Reflection::PropertyDescriptor::STANDARD, Security::RobloxPlace);
+
+Reflection::PropDescriptor<TextureTrail, float>
+TextureTrail::prop_CycleOffset("CycleOffset", category_Data,
+		&TextureTrail::getCycleOffset, &TextureTrail::setCycleOffset,
+		Reflection::PropertyDescriptor::STANDARD, Security::RobloxPlace);
+
+TextureTrail::TextureTrail()
+	: DescribedCreatable<TextureTrail, GuiBase3d, sTextureTrail>(sTextureTrail),
+	textureSize(1, 1),
+	velocity(2.0f),
+	studsBetweenTextures(4.0f),
+	cycleOffset(0.0f)
+{
+}
+
+void TextureTrail::setFrom(PartInstance* value) {
+	setPartInstance(from, value, prop_From);
+}
+
+PartInstance* TextureTrail::getFrom() const {
+	return from.lock().get();
+}
+
+void TextureTrail::setTo(PartInstance* value) {
+	setPartInstance(to, value, prop_To);
+}
+
+PartInstance* TextureTrail::getTo() const {
+	return to.lock().get();
+}
+
+void TextureTrail::setTexture(TextureId texture) {
+	this->texture = texture;
+}
+
+TextureId TextureTrail::getTexture() const {
+	return texture;
+}
+
+void TextureTrail::setTextureSize(Vector2 textureSize) {
+	this->textureSize.x = textureSize.x;
+	this->textureSize.y = textureSize.y;
+}
+
+Vector2 TextureTrail::getTextureSize() const {
+	return textureSize;
+}
+
+void TextureTrail::setVelocity(float velocity) {
+	this->velocity = velocity;
+}
+
+float TextureTrail::getVelocity() const {
+	return velocity;
+}
+
+void TextureTrail::setStudsBetweenTextures(float spacing) {
+	this->studsBetweenTextures = spacing;
+}
+
+float TextureTrail::getStudsBetweenTextures() const {
+	return studsBetweenTextures;
+}
+
+void TextureTrail::setCycleOffset(float cycleOffset) {
+	this->cycleOffset = cycleOffset;
+}
+
+float TextureTrail::getCycleOffset() const {
+	return cycleOffset;
+}
+
+void TextureTrail::render3dAdorn(Adorn *adorn) {
+	Vector3 fromPosition, toPosition;
+	if (!getPosition(from, &fromPosition) || !getPosition(to, &toPosition)) {
+		return;
+	}
+	
+	if (texture.isNull()) {
+		return;
+	}
+
+	Workspace* workspace = ServiceProvider::find<Workspace>(this);
+	if (!workspace) {
+		return;
+	}
+
+	const Camera* camera = workspace->getConstCamera();
+	if (!camera) {
+		return;
+	}
+
+	renderInternal(workspace, camera, fromPosition, toPosition, texture, getFullName() + ".Texture",
+			textureSize, velocity, studsBetweenTextures, cycleOffset, Color4(color, 1.0f - getTransparency()), adorn);
+}
+
+void TextureTrail::renderInternal(
+		const Workspace* workspace, const Camera* camera,
+		const Vector3& fromPosition, const Vector3& toPosition,
+		const TextureId& texture, std::string context, const Vector2& textureSize,
+		float velocity, float studsBetweenTextures, float cycleOffset,
+		const Color4& color, Adorn* adorn) {
+
+	// create a coordinate frame centered on From with -z pointed at To
+	CoordinateFrame trailOnFrom(fromPosition);
+	trailOnFrom.lookAt(toPosition);
+	float distance = (fromPosition - toPosition).length();
+
+	CoordinateFrame cameraInObjectSpace(
+			trailOnFrom.toObjectSpace(camera->getCameraCoordinateFrame()));
+
+	float spaceBetweenIcons = studsBetweenTextures;
+	double gameTime = Time::now<Time::Fast>().timestampSeconds();
+
+	// calculate an offset based on time to make the textures move along
+	// the line.
+	// Velocity is measured in studs per second.
+	// CycleOffset is treated as fraction of the space between textures
+	// (-1 to 1) to move the texture forward or backward in the loop.
+	float timeOffset = spaceBetweenIcons *
+			fmod((velocity / spaceBetweenIcons) * gameTime + cycleOffset, 1);
+	bool waitingFallback;
+
+	TextureProxyBaseRef textureRef = 
+			adorn->createTextureProxy(texture, waitingFallback, true /* blocking */, context);
+	adorn->setTexture(0, textureRef);
+
+	bool cameraPositiveX = cameraInObjectSpace.translation.x > 0;
+	float halfWidth = textureSize.x / 2;
+	float halfHeight = textureSize.y / 2;
+
+	for (float i = 0; i < distance + spaceBetweenIcons; i += spaceBetweenIcons) {
+		// build icons starting at "To" so that the stream will look anchored on
+		// that end
+		float zLoc = distance - i + timeOffset;
+		if (zLoc >= 0 && zLoc <= distance) {
+			CoordinateFrame objectLocationLookingAtCamera(Vector3(0, 0, -zLoc));
+			objectLocationLookingAtCamera.lookAt(cameraInObjectSpace.translation,
+					Vector3::unitZ());
+
+			Vector2 topLeft, bottomRight;
+			if (cameraPositiveX) {
+				topLeft = Vector2(0, 0);
+				bottomRight = Vector2(1, 1);
+			} else {
+				// The look at function will cause the sprite to be upside down
+				// when the camera is in negative X space. To compensate,
+				// invert the Y axis of the sprite (the X axis is maintained,
+				// so that if a sprite has left-right directionality, that will
+				// be preserved).
+				topLeft = Vector2(0, 1);
+				bottomRight = Vector2(1, 0);
+			}
+
+			adorn->setObjectToWorldMatrix(trailOnFrom * objectLocationLookingAtCamera);
+			adorn->quad(
+					Vector3(-halfHeight,  halfWidth, 0),
+					Vector3(-halfHeight, -halfWidth, 0),
+					Vector3( halfHeight,  halfWidth, 0),
+					Vector3( halfHeight, -halfWidth, 0),
+					color, topLeft, bottomRight);
+		}
+	}
+
+	// clear texture; if this is not done, other adorns may accidentally
+	// gain a texture
+	adorn->setTexture(0, TextureProxyBaseRef());
+}
+
+void TextureTrail::setPartInstance(weak_ptr<PartInstance>& data,
+		PartInstance* newValue, const PartProp& prop) {
+	if(data.lock().get() != newValue){
+		data = shared_from(newValue);
+		raisePropertyChanged(prop);
+	}
+}
+
+bool TextureTrail::getPosition(const weak_ptr<PartInstance>& dataSource,
+		Vector3* out) {
+	PartInstance* dataPtr = dataSource.lock().get();
+	if (dataPtr) {
+		(*out) = dataPtr->getTranslationUi();
+		return true;
+	}
+	return false;
+}
+
+}