GEEKING

App/include/v8datamodel/CharacterAppearance.h

@@ -0,0 +1,148 @@
+#pragma once
+
+#include "V8DataModel/GlobalSettings.h"
+#include "Util/BrickColor.h"
+#include "V8DataModel/PartInstance.h"
+#include "V8DataModel/IModelModifier.h"
+#include "Util/TextureId.h"
+
+namespace RBX {
+
+	class Humanoid;
+
+	extern const char* const sCharacterAppearance;
+	class RBXBaseClass CharacterAppearance
+		:public DescribedNonCreatable<CharacterAppearance, Instance, sCharacterAppearance>
+		,public IModelModifier
+	{
+	private:
+		typedef Instance Super;
+
+	public:
+		virtual void apply();
+	protected:
+		virtual void onAncestorChanged(const AncestorChanged& event);
+		virtual bool askSetParent(const Instance* instance) const;
+	private:
+		virtual void applyByMyself(Humanoid* humanoid) = 0;
+	};
+
+	class LegacyCharacterAppearance
+		: public CharacterAppearance
+	{
+	private:
+		typedef CharacterAppearance Super;
+
+	public:
+		
+		// Hack: This apply() function is ugly, but necessary because
+		//       this class changes properties of other objects (like
+		//       Part colors and Decal images).  However, to avoid
+		//       crosstalk the apply function should only do something
+		//       in the backend case.
+		/*override*/ void apply();
+	};
+
+	// Old-style T-shirts
+	extern const char *const sShirtGraphic;
+	class ShirtGraphic
+		 : public DescribedCreatable<ShirtGraphic, LegacyCharacterAppearance, sShirtGraphic>
+	{
+	public:
+		TextureId graphic;
+		static Reflection::BoundProp<TextureId> prop_Graphic;
+		ShirtGraphic();
+	protected:
+		/*override*/ void applyByMyself(Humanoid* humanoid);
+	private:
+		void dataChanged(const Reflection::PropertyDescriptor&) {
+			CharacterAppearance::apply();
+		}
+	};
+
+	extern const char *const sClothing;
+	class Clothing
+		 : public DescribedNonCreatable<Clothing, CharacterAppearance, sClothing>
+	{
+		friend class CharacterAppearance;
+	public:
+		TextureId outfit1;
+		TextureId outfit2;
+
+		static Reflection::BoundProp<TextureId> prop_outfit1;
+		static Reflection::BoundProp<TextureId> prop_outfit2;
+
+		Clothing();
+
+		virtual TextureId getTemplate() const { RBXASSERT(false); return NULL; }
+
+	protected:
+		/*override*/ void applyByMyself(Humanoid* humanoid);
+		void dataChanged(const Reflection::PropertyDescriptor&) {
+			CharacterAppearance::apply();
+		}
+	};
+
+	extern const char *const sPants;
+	class Pants
+		 : public DescribedCreatable<Pants, Clothing, sPants>
+	{
+	public:
+		Pants();
+		static Reflection::PropDescriptor<Pants, TextureId> prop_PantsTemplate;
+		TextureId getTemplate() const { return outfit1; }
+		void setTemplate(TextureId value);
+	};
+
+	extern const char *const sShirt;
+	class Shirt
+		 : public DescribedCreatable<Shirt, Clothing, sShirt>
+	{
+	public:
+		Shirt();
+		static Reflection::PropDescriptor<Shirt, TextureId> prop_ShirtTemplate;
+		TextureId getTemplate() const { return outfit2; }
+		void setTemplate(TextureId value);
+	};
+
+	extern const char *const sBodyColors;
+	class BodyColors 
+		 : public DescribedCreatable<BodyColors, LegacyCharacterAppearance, sBodyColors>
+	{
+		BrickColor headColor;
+		BrickColor leftArmColor;
+		BrickColor rightArmColor;
+		BrickColor torsoColor;
+		BrickColor leftLegColor;
+		BrickColor rightLegColor;
+	public:
+		static Reflection::BoundProp<BrickColor> prop_HeadColor;
+		static Reflection::BoundProp<BrickColor> prop_LeftArmColor;
+		static Reflection::BoundProp<BrickColor> prop_RightArmColor;
+		static Reflection::BoundProp<BrickColor> prop_TorsoColor;
+		static Reflection::BoundProp<BrickColor> prop_LeftLegColor;
+		static Reflection::BoundProp<BrickColor> prop_RightLegColor;
+		BodyColors();
+	private:
+		virtual void applyByMyself(Humanoid* humanoid);
+		void dataChanged(const Reflection::PropertyDescriptor&) {
+			CharacterAppearance::apply();
+		}
+	};
+
+	extern const char *const sSkin;
+	class Skin 
+		 : public DescribedCreatable<Skin, LegacyCharacterAppearance, sSkin>
+	{
+		BrickColor skinColor;
+	public:
+		static Reflection::BoundProp<BrickColor> prop_skinColor;
+		Skin();
+	private:
+		virtual void applyByMyself(Humanoid* humanoid);
+		void dataChanged(const Reflection::PropertyDescriptor&) {
+			CharacterAppearance::apply();
+		}
+	};
+
+} // namespace