GEEKING

ClientBase/MachineConfiguration.cpp

@@ -0,0 +1,89 @@
+/**
+ * MachineConfiguration.cpp
+ * Copyright (c) 2013 ROBLOX Corp. All Rights Reserved.
+ */
+
+#include "stdafx.h"
+#include "MachineConfiguration.h"
+
+#include "reflection/Property.h"
+#include "v8datamodel/DebugSettings.h"
+#include "util/Http.h"
+#include "RenderSettingsItem.h"
+#include "format_string.h"
+#include "RobloxServicesTools.h"
+
+FASTFLAG(UseBuildGenericGameUrl)
+
+static void appendProperty(const char* category, std::stringstream& data, const RBX::Reflection::Property& prop)
+{
+	if (prop.getDescriptor().category == category)
+	{
+		data << prop.getName().c_str();
+		data << ':';
+		data << prop.getStringValue();
+		data << ';';
+	}
+}
+
+static void HandleAsyncHttp(std::string *response, std::exception *exception)
+{
+	// TODO: log?
+}
+
+namespace RBX
+{
+    void postMachineConfiguration(const char* baseURL, int lastGfxMode)
+	{
+        std::string url;
+		if (FFlag::UseBuildGenericGameUrl)
+		{
+			url = BuildGenericGameUrl(baseURL, "Game/MachineConfiguration.ashx");
+		}
+		else
+		{
+			url = ::trim_trailing_slashes(std::string(baseURL)) + "/Game/MachineConfiguration.ashx";
+		}
+		std::string response;
+		try
+		{
+			std::stringstream data;
+			G3D::Vector2int16 displayResolution(800, 600);
+			G3D::Vector2int16 fullscreenResolution(800, 600);
+			RBX::DebugSettings& debugsettings = RBX::DebugSettings::singleton();
+			CRenderSettingsItem& rendersettings = CRenderSettingsItem::singleton();
+
+            debugsettings.setVertexShaderModel(-1);
+            debugsettings.setPixelShaderModel(-1);
+
+// DirectX Related Stuff Windows Only
+#ifdef _WIN32
+			int x,y;
+			if(2 == sscanf_s(debugsettings.resolution().c_str(), "%d x%d", &x, &y))
+			{
+				displayResolution.x = x;
+				displayResolution.y = y;
+			}
+			fullscreenResolution = rendersettings.getFullscreenSize();
+#endif // DirectX Related Stuff Windows Only
+			
+			std::for_each(
+				debugsettings.properties_begin(), debugsettings.properties_end(), 
+				boost::bind(&appendProperty, "Profile", boost::ref(data), _1)
+				);
+
+			std::for_each(
+				rendersettings.properties_begin(), rendersettings.properties_end(), 
+				boost::bind(&appendProperty, "General", boost::ref(data), _1)
+				);
+
+            data << "lastGfxMode:" << lastGfxMode << ";";
+
+			data.flush();
+			RBX::Http(url).post(data.str(), Http::kContentTypeDefaultUnspecified, false, boost::bind(&HandleAsyncHttp, _1, _2));
+		}
+		catch (const std::exception&)
+		{
+		}
+    }
+}

ClientBase/MachineConfiguration.h

@@ -0,0 +1,6 @@
+#pragma once
+
+namespace RBX
+{
+    void postMachineConfiguration(const char* baseURL, int lastGfxMode);
+}

ClientBase/ReflectionMetadata.cpp

@@ -0,0 +1,522 @@
+#include "stdafx.h"
+
+#include "v8xml/Serializer.h"
+#include "v8xml/XmlSerializer.h"
+#include "rbx/Debug.h"
+
+#include "ReflectionMetadata.h"
+#ifdef QT_ROBLOX_STUDIO
+#include "RobloxSettings.h"
+#endif
+
+#include "StringConv.h"
+
+LOGGROUP(ReflectionMetadata)
+LOGVARIABLE(ReflectionMetadata, 1);
+
+using namespace RBX;
+using namespace Reflection;
+			
+const char* const Metadata::sReflection	= "ReflectionMetadata";
+const char* const Metadata::sClasses	= "ReflectionMetadataClasses";
+const char* const Metadata::sItem		= "ReflectionMetadataItem";
+const char* const Metadata::sClass		= "ReflectionMetadataClass";
+const char* const Metadata::sProperties	= "ReflectionMetadataProperties";
+const char* const Metadata::sFunctions	= "ReflectionMetadataFunctions";
+const char* const Metadata::sYieldFunctions	= "ReflectionMetadataYieldFunctions";
+const char* const Metadata::sEvents		= "ReflectionMetadataEvents";
+const char* const Metadata::sCallbacks	= "ReflectionMetadataCallbacks";
+const char* const Metadata::sMember		= "ReflectionMetadataMember";
+const char* const Metadata::sEnums		= "ReflectionMetadataEnums";
+const char* const Metadata::sEnum		= "ReflectionMetadataEnum";
+const char* const Metadata::sEnumItem	= "ReflectionMetadataEnumItem";
+
+BoundProp<bool> Metadata::Item::prop_browsable("Browsable", "Reflection", &Metadata::Item::browsable);
+BoundProp<bool> Metadata::Item::prop_deprecated("Deprecated", "Reflection", &Metadata::Item::deprecated);
+BoundProp<bool> Metadata::Item::prop_backend("IsBackend", "Reflection", &Metadata::Item::backend);
+BoundProp<std::string> Metadata::Item::prop_description("summary", "Reflection", &Metadata::Item::description);
+BoundProp<double> Metadata::Item::prop_minimum("UIMinimum", "Reflection", &Metadata::Item::minimum);
+BoundProp<double> Metadata::Item::prop_maximum("UIMaximum", "Reflection", &Metadata::Item::maximum);
+
+BoundProp<int> Metadata::Class::prop_ExplorerOrder("ExplorerOrder", "Reflection", &Metadata::Class::explorerOrder);
+BoundProp<int> Metadata::Class::prop_ExplorerImageIndex("ExplorerImageIndex", "Reflection", &Metadata::Class::explorerImageIndex);
+BoundProp<std::string> Metadata::Class::prop_PreferredParent("PreferredParent", "Reflection", &Metadata::Class::preferredParent);
+BoundProp<bool> Metadata::Class::prop_Insertable("Insertable", "Reflection", &Metadata::Class::insertable);
+
+RBX_REGISTER_CLASS(Metadata::Reflection);
+RBX_REGISTER_CLASS(Metadata::Class);
+RBX_REGISTER_CLASS(Metadata::Item);
+RBX_REGISTER_CLASS(Metadata::Classes);
+RBX_REGISTER_CLASS(Metadata::Functions);
+RBX_REGISTER_CLASS(Metadata::YieldFunctions);
+RBX_REGISTER_CLASS(Metadata::Member);
+RBX_REGISTER_CLASS(Metadata::Properties);
+RBX_REGISTER_CLASS(Metadata::Events);
+RBX_REGISTER_CLASS(Metadata::Callbacks);
+RBX_REGISTER_CLASS(Metadata::Enums);
+RBX_REGISTER_CLASS(Metadata::Enum);
+RBX_REGISTER_CLASS(Metadata::EnumItem);
+
+void Metadata::Reflection::registerClasses()
+{
+	// This code ensure that the function isn't optimized away
+	Properties::classDescriptor();
+}
+
+shared_ptr<Metadata::Reflection> Metadata::Reflection::safe_static_do_get_singleton()
+{
+	static shared_ptr<Reflection> sing;
+	if (!sing)
+	{
+		sing = RBX::Creatable<RBX::Instance>::create<Reflection>();
+
+#ifdef QT_ROBLOX_STUDIO
+		QByteArray xmlFilePathUtf8 = RobloxSettings::getResourcesFolder().toUtf8();
+        boost::filesystem::path bfsp = RBX::utf8_decode(std::string(xmlFilePathUtf8.constData(), xmlFilePathUtf8.size()));
+		sing->load( bfsp / "ReflectionMetadata.xml" );
+#else
+		wchar_t buf[MAX_PATH] = {0};
+		GetModuleFileNameW(NULL, buf, MAX_PATH);
+        boost::filesystem::path exePath(buf);
+        exePath.remove_filename();
+		
+		sing->load(exePath / "ReflectionMetadata.xml");
+#endif
+		
+	}
+	return sing;
+}
+
+Metadata::Reflection::Reflection()
+:classes(0)
+,enums(0)
+{
+}
+// TODO: Merge with GlobalSettings and make part of Serializer class????
+void Metadata::Reflection::save(const boost::filesystem::path& filePath)
+{
+	boost::scoped_ptr<XmlElement> root(Serializer::newRootElement());
+	writeChildren(root.get(), EngineCreator);
+	std::ofstream stream(filePath.native().c_str(), std::ios_base::out | std::ios_base::binary);
+	TextXmlWriter machine(stream);
+	machine.serialize(root.get());
+}
+
+// TODO: Merge with GlobalSettings and make part of Serializer class????
+void Metadata::Reflection::load(const boost::filesystem::path& filePath)
+{
+	if (filePath.empty())
+		return;
+
+	FASTLOGS(FLog::ReflectionMetadata, "Reflection::load %s", filePath.string().c_str());
+
+	std::ifstream stream(filePath.native().c_str(), std::ios_base::in | std::ios_base::binary);
+
+	TextXmlParser machine(stream.rdbuf());
+	std::auto_ptr<XmlElement> root(machine.parse());
+
+	MergeBinder binder;
+
+	readChildren(root.get(), binder, EngineCreator);
+
+	bool bound = binder.resolveRefs();
+	RBXASSERT(bound);
+
+	// TODO: Check for duplicate names!
+	classes = this->findFirstChildOfType<Classes>();
+	enums = this->findFirstChildOfType<Enums>();
+}
+
+Metadata::Class* Metadata::Reflection::get(const ClassDescriptor& descriptor, bool findBestMatch) const
+{
+	return classes ? classes->get(descriptor, findBestMatch) : 0;
+}
+
+Metadata::Class* Metadata::Classes::get(const ClassDescriptor& descriptor, bool findBestMatch)
+{
+	Metadata::Class* c = boost::polymorphic_downcast<Metadata::Class*>(findFirstChildByName(descriptor.name.toString()));
+	if (c)
+		return c;
+	if (!findBestMatch)
+		return NULL;
+	if (!descriptor.getBase())
+		return NULL;
+	return get(*descriptor.getBase(), true);
+}
+
+Metadata::Member* Metadata::Reflection::get(const PropertyDescriptor& descriptor) const
+{
+	Metadata::Class* c = get(descriptor.owner, false);
+	const Metadata::Properties* members = c ? c->findFirstChildOfType<Metadata::Properties>() : 0;
+	return members ? boost::polymorphic_downcast<Metadata::Member*>(members->findFirstChildByNameDangerous(descriptor.name.toString())) : 0;
+}
+
+Metadata::Member* Metadata::Reflection::get(const FunctionDescriptor& descriptor) const
+{
+	Metadata::Class* c = get(descriptor.owner, false);
+	const Metadata::Functions* members = c ? c->findFirstChildOfType<Metadata::Functions>() : 0;
+	return members ? boost::polymorphic_downcast<Metadata::Member*>(members->findFirstChildByNameDangerous(descriptor.name.toString())) : 0;
+}
+
+Metadata::Member* Metadata::Reflection::get(const YieldFunctionDescriptor& descriptor) const
+{
+	Metadata::Class* c = get(descriptor.owner, false);
+	const Metadata::YieldFunctions* members = c ? c->findFirstChildOfType<Metadata::YieldFunctions>() : 0;
+	return members ? boost::polymorphic_downcast<Metadata::Member*>(members->findFirstChildByNameDangerous(descriptor.name.toString())) : 0;
+}
+
+Metadata::Member* Metadata::Reflection::get(const EventDescriptor& descriptor) const
+{
+	Metadata::Class* c = get(descriptor.owner, false);
+	const Metadata::Events* members = c ? c->findFirstChildOfType<Metadata::Events>() : 0;
+	return members ? boost::polymorphic_downcast<Metadata::Member*>(members->findFirstChildByNameDangerous(descriptor.name.toString())) : 0;
+}
+
+Metadata::Member* Metadata::Reflection::get(const CallbackDescriptor& descriptor) const
+{
+	Metadata::Class* c = get(descriptor.owner, false);
+	const Metadata::Callbacks* members = c ? c->findFirstChildOfType<Metadata::Callbacks>() : 0;
+	return members ? boost::polymorphic_downcast<Metadata::Member*>(members->findFirstChildByNameDangerous(descriptor.name.toString())) : 0;
+}
+
+Metadata::Enum* Metadata::Reflection::get(const EnumDescriptor& descriptor) const
+{
+	return enums ? boost::polymorphic_downcast<Metadata::Enum*>(enums->findFirstChildByName(descriptor.name.toString())) : 0;
+}
+
+Metadata::EnumItem* Metadata::Reflection::get(const EnumDescriptor::Item& item) const
+{
+	Metadata::Enum* e = get(item.owner);
+	return e ? boost::polymorphic_downcast<Metadata::EnumItem*>(e->findFirstChildByNameDangerous(item.name.toString())) : 0;
+}
+
+class Writer
+{
+	std::ostream& stream;
+public:
+	Writer(std::ostream& stream):stream(stream)
+	{}
+
+	void writeMetadata(const Metadata::Item* metadata, const Descriptor& descriptor)
+	{
+		if (metadata && !metadata->isBrowsable())
+			stream << " [notbrowsable]";
+		if (Metadata::Item::isDeprecated(metadata, descriptor))
+			stream << " [deprecated]";
+		if (Metadata::Item::isBackend(metadata, descriptor))
+			stream << " [backend]";
+	}
+
+	void writeMemberInfo(const Reflection::MemberDescriptor* d)
+	{
+		switch (d->security)
+		{
+		default:
+			stream << " [security" << d->security << "]";
+			break;
+		case Security::None:
+			break;
+        case Security::Plugin:
+            stream << " [PluginSecurity]";
+            break;
+		case Security::RobloxPlace:
+			stream << " [RobloxPlaceSecurity]";
+			break;
+		case Security::RobloxScript:
+			stream << " [RobloxScriptSecurity]";
+			break;
+		case Security::LocalUser:
+			stream << " [LocalUserSecurity]";
+			break;
+		case Security::WritePlayer:
+			stream << " [WritePlayerSecurity]";
+			break;
+		case Security::Roblox:
+			stream << " [RobloxSecurity]";
+			break;
+		}
+	}
+
+	void writeProperty(const Reflection::PropertyDescriptor* d, const Reflection::ClassDescriptor* c)
+	{
+		if (d->owner != *c)
+			return;
+		if (!d->isScriptable())
+			return;
+		stream << "\tProperty " << d->type.name.c_str() << ' ' << d->owner.name.c_str() << '.' << d->name.c_str();
+		writeMetadata(Metadata::Reflection::singleton()->get(*d), *d);
+		if (!d->isPublic())
+			stream << " [hidden]";
+		if (d->isReadOnly())
+			stream << " [readonly]";
+		if (d->isWriteOnly())
+			stream << " [writeonly]";
+		writeMemberInfo(d);
+		stream << '\n';
+	}
+
+	void writeArg(const Reflection::SignatureDescriptor::Item& arg, bool* first)
+	{
+		if (*first)
+			*first = false;
+		else
+			stream << ", ";
+
+		stream << arg.type->name.c_str() << ' ' << arg.name->c_str();
+		if (arg.hasDefaultValue())
+		{
+			stream << " = ";
+			stream << arg.defaultValue.get<std::string>();
+		}
+	}
+
+	void writeArgs(const Reflection::SignatureDescriptor& d)
+	{
+		bool first = true;
+		std::for_each(d.arguments.begin(), d.arguments.end(), boost::bind(&Writer::writeArg, this, _1, &first));
+	}
+
+	void writeFunction(const Reflection::FunctionDescriptor* d, const Reflection::ClassDescriptor* c)
+	{
+		if (d->owner != *c)
+			return;
+		stream << "\tFunction " << d->getSignature().resultType->name.c_str() << ' ' << d->owner.name.c_str() << ':' << d->name.c_str() << '(';
+		writeArgs(d->getSignature());
+		stream << ')';
+		writeMetadata(Metadata::Reflection::singleton()->get(*d), *d);
+		writeMemberInfo(d);
+		stream << '\n';
+	}
+
+	void writeYieldFunction(const Reflection::YieldFunctionDescriptor* d, const Reflection::ClassDescriptor* c)
+	{
+		if (d->owner != *c)
+			return;
+		stream << "\tYieldFunction " << d->getSignature().resultType->name.c_str() << ' ' << d->owner.name.c_str() << ':' << d->name.c_str() << '(';
+		writeArgs(d->getSignature());
+		stream << ')';
+		writeMetadata(Metadata::Reflection::singleton()->get(*d), *d);
+		writeMemberInfo(d);
+		stream << '\n';
+	}
+
+	void writeEvent(const Reflection::EventDescriptor* d, const Reflection::ClassDescriptor* c)
+	{
+		if (d->owner != *c)
+			return;
+		if (!d->isScriptable())
+			return;
+		stream << "\tEvent " << d->owner.name.c_str() << '.' << d->name.c_str() << '(';
+		writeArgs(d->getSignature());
+		stream << ')';
+		writeMetadata(Metadata::Reflection::singleton()->get(*d), *d);
+		writeMemberInfo(d);
+		stream << '\n';
+	}
+
+	void writeCallback(const Reflection::CallbackDescriptor* d, const Reflection::ClassDescriptor* c)
+	{
+		if (d->owner != *c)
+			return;
+		stream << "\tCallback " << d->getSignature().resultType->name.c_str() << ' ' << d->owner.name.c_str() << '.' << d->name.c_str() << '(';
+		writeArgs(d->getSignature());
+		stream << ')';
+        if (!d->isAsync())
+            stream << " [noyield]";
+		writeMetadata(Metadata::Reflection::singleton()->get(*d), *d);
+		writeMemberInfo(d);
+		stream << '\n';
+	}
+
+	void writeClassHeader(const Reflection::ClassDescriptor* d)
+	{
+		stream << "Class " << d->name.c_str();
+		if (d->getBase() && *d->getBase() != Reflection::ClassDescriptor::rootDescriptor())
+			stream << " : " << d->getBase()->name.c_str();
+
+		writeMetadata(Metadata::Reflection::singleton()->get(*d, false), *d);
+		if (!d->isScriptCreatable())
+			stream << " [notCreatable]";
+		stream << '\n';
+	}
+
+	void writeClass(const Reflection::ClassDescriptor* d)
+	{
+		if (*d != Reflection::ClassDescriptor::rootDescriptor())
+		{
+            writeClassHeader(d);
+
+			// Enumerate Properties
+			std::for_each(
+				d->begin<PropertyDescriptor>(), d->end<PropertyDescriptor>(), 
+				boost::bind(&Writer::writeProperty, this, _1, d)
+				);
+
+			// Enumerate Functions
+			std::for_each(
+				d->begin<FunctionDescriptor>(), d->end<FunctionDescriptor>(), 
+				boost::bind(&Writer::writeFunction, this, _1, d)
+				);
+
+			// Enumerate Yield-Functions
+			std::for_each(
+				d->begin<YieldFunctionDescriptor>(), d->end<YieldFunctionDescriptor>(), 
+				boost::bind(&Writer::writeYieldFunction, this, _1, d)
+				);
+
+			// Enumerate Events
+			std::for_each(
+				d->begin<EventDescriptor>(), d->end<EventDescriptor>(), 
+				boost::bind(&Writer::writeEvent, this, _1, d)
+				);
+
+			// Enumerate Callbacks
+			std::for_each(
+				d->begin<CallbackDescriptor>(), d->end<CallbackDescriptor>(), 
+				boost::bind(&Writer::writeCallback, this, _1, d)
+				);
+		}
+
+		// Recurse
+		std::for_each(
+			d->derivedClasses_begin(), 
+			d->derivedClasses_end(),
+			boost::bind(&Writer::writeClass, this, _1)
+			);
+		
+	}
+
+	void writeEnum(const EnumDescriptor* d)
+	{
+		stream << "Enum " << d->name.c_str() << '\n';
+		std::for_each(
+			d->begin(), d->end(), 
+			boost::bind(&Writer::writeEnumItem, this, _1)
+			);
+	}
+
+	void writeEnumItem(const EnumDescriptor::Item* d)
+	{
+		stream << "\tEnumItem " << d->owner.name << '.' << d->name << " : " << d->value;
+		writeMetadata(Metadata::Reflection::singleton()->get(*d), *d);
+		stream << '\n';
+	}
+
+	void writeAPI()
+	{
+		writeClass(&ClassDescriptor::rootDescriptor());
+
+		std::for_each(
+			EnumDescriptor::enumsBegin(),
+			EnumDescriptor::enumsEnd(),
+			boost::bind(&Writer::writeEnum, this, _1)
+			);
+	}
+
+    template <typename T> const T* checkConflict(const T* desc, std::map<std::string, const T*>& map)
+	{
+        const T*& old = map[desc->name.toString()];
+
+        if (old)
+            return old;
+
+        old = desc;
+        return NULL;
+	}
+
+	void writeConflictingMember(const ClassDescriptor* desc, const MemberDescriptor* member)
+	{
+		if (const PropertyDescriptor* d = dynamic_cast<const PropertyDescriptor*>(member))
+            writeProperty(d, desc);
+		else if (const FunctionDescriptor* d = dynamic_cast<const FunctionDescriptor*>(member))
+            writeFunction(d, desc);
+		else if (const YieldFunctionDescriptor* d = dynamic_cast<const YieldFunctionDescriptor*>(member))
+            writeYieldFunction(d, desc);
+		else if (const EventDescriptor* d = dynamic_cast<const EventDescriptor*>(member))
+            writeEvent(d, desc);
+		else if (const CallbackDescriptor* d = dynamic_cast<const CallbackDescriptor*>(member))
+            writeCallback(d, desc);
+	}
+
+	template <typename T> void writeConflictingMembers(const ClassDescriptor* desc, std::map<std::string, const MemberDescriptor*>& members)
+	{
+		const MemberDescriptorContainer<T>* container = desc;
+
+		for (typename MemberDescriptorContainer<T>::Collection::const_iterator it = container->descriptors_begin(); it != container->descriptors_end(); ++it)
+		{
+			const MemberDescriptor* member = *it;
+
+			if (const MemberDescriptor* oldmember = checkConflict(member, members))
+			{
+                stream << "ERROR: Duplicate declaration of member " << desc->name.toString() << "." << member->name.toString() << ":\n";
+                writeConflictingMember(desc, oldmember);
+                writeConflictingMember(desc, member);
+			}
+		}
+	}
+
+    void writeConflicts()
+	{
+        std::map<std::string, const ClassDescriptor*> classTypes;
+
+		for (ClassDescriptor::ClassDescriptors::const_iterator cit = ClassDescriptor::all_begin(); cit != ClassDescriptor::all_end(); ++cit)
+		{
+            const ClassDescriptor* desc = *cit;
+
+            if (const ClassDescriptor* olddesc = checkConflict(desc, classTypes))
+			{
+                stream << "ERROR: Duplicate declaration of class " << desc->name.toString() << "\n";
+                stream << "\t";
+				writeClassHeader(olddesc);
+                stream << "\t";
+				writeClassHeader(desc);
+			}
+
+			std::map<std::string, const MemberDescriptor*> classMembers;
+
+			writeConflictingMembers<PropertyDescriptor>(desc, classMembers);
+			writeConflictingMembers<EventDescriptor>(desc, classMembers);
+			writeConflictingMembers<FunctionDescriptor>(desc, classMembers);
+			writeConflictingMembers<YieldFunctionDescriptor>(desc, classMembers);
+			writeConflictingMembers<CallbackDescriptor>(desc, classMembers);
+        }
+
+        std::map<std::string, const EnumDescriptor*> enumTypes;
+
+        for (std::vector<const EnumDescriptor*>::const_iterator eit = EnumDescriptor::enumsBegin(); eit != EnumDescriptor::enumsEnd(); ++eit)
+		{
+            const EnumDescriptor* desc = *eit;
+
+            if (const EnumDescriptor* olddesc = checkConflict(desc, enumTypes))
+			{
+                stream << "ERROR: Duplicate declaration of enum " << desc->name.toString() << ":\n";
+				stream << "\t" << olddesc->name << "\n";
+				stream << "\t" << desc->name << "\n";
+			}
+
+            std::map<std::string, const EnumDescriptor::Item*> enumValues;
+
+			for (std::vector<const EnumDescriptor::Item*>::const_iterator eiit = desc->begin(); eiit != desc->end(); ++eiit)
+			{
+                const EnumDescriptor::Item* item = *eiit;
+
+                if (const EnumDescriptor::Item* olditem = checkConflict(item, enumValues))
+				{
+                    stream << "ERROR: Duplicate declaration of enum value " << desc->name.toString() << "." << item->name.toString() << ":\n";
+                    writeEnumItem(item);
+                    writeEnumItem(olditem);
+				}
+
+                enumValues[item->name.toString()] = item;
+			}
+		}
+	}
+
+};
+void Metadata::writeEverything(std::ostream& stream)
+{
+	Writer w(stream);
+
+	w.writeConflicts();
+	w.writeAPI();
+}

ClientBase/ReflectionMetadata.h

@@ -0,0 +1,223 @@
+#pragma once
+
+// Roblox Headers
+#include "v8tree/Instance.h"
+#include "reflection/reflection.h"
+#include <boost/filesystem.hpp>
+
+namespace RBX
+{
+	namespace Reflection
+	{
+		// A collection of classes that contain metadata for class documentation
+		// TODO: Support Enum matadata
+		namespace Metadata
+		{
+			void writeEverything(std::ostream& stream);
+
+			class Classes;
+			class Class;
+			class Member;
+			class Enums;
+			class Enum;
+			class EnumItem;
+
+			extern const char* const sReflection;
+			class Reflection : public DescribedCreatable<Reflection, Instance, sReflection>
+			{
+				Classes* classes;
+				Enums* enums;
+				static shared_ptr<Reflection> safe_static_do_get_singleton();
+				static void safe_static_init_singleton() { safe_static_do_get_singleton(); }
+			public:
+				Reflection();
+				static void registerClasses();
+
+				static shared_ptr<Reflection> singleton()
+				{
+					static boost::once_flag once_init_singleton = BOOST_ONCE_INIT;
+					boost::call_once(safe_static_init_singleton, once_init_singleton);
+					return safe_static_do_get_singleton();
+				}
+
+				void save(const boost::filesystem::path& filePath);
+				void load(const boost::filesystem::path& file);
+				// findBestMatch means find a base Class object if none exists for descriptor
+				Class* get(const ClassDescriptor& descriptor, bool findBestMatch) const;
+				Member* get(const PropertyDescriptor& descriptor) const;
+				Member* get(const FunctionDescriptor& descriptor) const;
+				Member* get(const YieldFunctionDescriptor& descriptor) const;
+				Member* get(const EventDescriptor& descriptor) const;
+				Member* get(const CallbackDescriptor& descriptor) const;
+
+				Enum* get(const EnumDescriptor& descriptor) const;
+				EnumItem* get(const EnumDescriptor::Item& item) const;
+			};
+
+			extern const char* const sClasses;
+			class Classes : public DescribedCreatable<Classes, Instance, sClasses>
+			{
+			public:
+				Classes() {;}
+				Class* get(const ClassDescriptor& descriptor, bool findBestMatch);
+			};
+
+			extern const char* const sItem;
+			class Item : public DescribedNonCreatable<Item, Instance, sItem>
+			{
+				friend class Classes;
+				bool browsable;
+				bool deprecated;
+				bool backend;		// This item can only be used in game servers and solo games
+			public:
+				static bool isDeprecated(const Item* item, const Descriptor& descriptor)	// TODO: || with owner, if any
+				{
+					if (item && item->deprecated)
+						return true;
+					return descriptor.attributes.isDeprecated;
+				}
+				// Browsable means it is visible in docs for end-users
+				bool isBrowsable() const { return browsable; }	    // TODO: && with owner, if any
+				static bool isBackend(const Item* item, const Descriptor& descriptor)	// TODO: || with owner, if any
+				{
+					if (item && item->backend)
+						return true;
+					return false;
+				}
+				static bool isBrowsable(const Item* item, const Descriptor& descriptor)	// TODO: || with owner, if any
+				{
+					if (item && item->browsable)
+						return true;
+					return false;
+				}
+				std::string description;
+				double minimum;
+				double maximum;
+
+				Item()
+					: browsable(true)
+					, deprecated(false)
+					, backend(false)
+					, minimum(0)
+					, maximum(0)
+				{}
+
+				static BoundProp<bool> prop_deprecated;
+				static BoundProp<bool> prop_browsable;
+			private:
+				static BoundProp<bool> prop_backend;
+				static BoundProp<std::string> prop_description;
+				static BoundProp<double> prop_minimum;
+				static BoundProp<double> prop_maximum;
+			};
+
+			extern const char* const sClass;
+			class Class : public DescribedCreatable<Class, Item, sClass>
+			{
+				int explorerOrder;		// -1 hide,  0 unspecified,  1+ order to show
+				int explorerImageIndex;	// -1 unspecified,  0 generic image
+				std::string preferredParent; // class name for the service you want this object to default under (Players, Lighting, StarterGui, etc.)
+                bool insertable; // class will show up in the list of insertable objects
+			public:
+				static BoundProp<int> prop_ExplorerOrder;
+				static BoundProp<int> prop_ExplorerImageIndex;
+				static BoundProp<std::string> prop_PreferredParent;
+				static BoundProp<bool> prop_Insertable;
+				
+				const Class* getBase() const { return dynamic_cast<const Class*>(getParent()); };
+
+				int getExplorerOrder() const { 
+					return explorerOrder==0 
+						? (getBase() && getBase()->getExplorerOrder())
+						: explorerOrder;
+				}
+				bool isExplorerItem() const { 
+					return getExplorerOrder()>=0;
+				}
+				int getExplorerImageIndex() const { 
+					return explorerImageIndex==-1
+						? (getBase() && getBase()->getExplorerImageIndex())
+						: std::max(explorerImageIndex, 0);		// don't ever return -1 
+				}
+
+				std::string getPreferredParent() const {
+					return preferredParent;
+				}
+
+                bool getInsertable() const { return insertable; }
+                
+				Class():explorerOrder(-1),explorerImageIndex(0), preferredParent(""),insertable(true) {}
+			};
+
+			class Members : public Instance
+			{
+			public:
+				Members() { }
+			};
+
+			extern const char* const sProperties;
+			class Properties : public DescribedCreatable<Properties, Members, sProperties>
+			{
+			public:
+				Properties() { }
+			};
+
+			extern const char* const sFunctions;
+			class Functions : public DescribedCreatable<Functions, Members, sFunctions>
+			{
+			public:
+				Functions() { }
+			};
+
+			extern const char* const sYieldFunctions;
+			class YieldFunctions : public DescribedCreatable<YieldFunctions, Members, sYieldFunctions>
+			{
+			public:
+				YieldFunctions() { }
+			};
+
+			extern const char* const sEvents;
+			class Events : public DescribedCreatable<Events, Members, sEvents>
+			{
+			public:
+				Events() { }
+			};
+
+			extern const char* const sCallbacks;
+			class Callbacks : public DescribedCreatable<Callbacks, Members, sCallbacks>
+			{
+			public:
+				Callbacks() { }
+			};
+
+			extern const char* const sMember;
+			class Member : public DescribedCreatable<Member, Item, sMember>
+			{
+			public:
+				Member() { }
+			};
+
+			extern const char* const sEnums;
+			class Enums : public DescribedCreatable<Enums, Instance, sEnums>
+			{
+			public:
+				Enums() {}
+			};
+
+			extern const char* const sEnum;
+			class Enum : public DescribedCreatable<Enum, Item, sEnum>
+			{
+			public:
+				Enum() { }
+			};
+
+			extern const char* const sEnumItem;
+			class EnumItem : public DescribedCreatable<EnumItem, Item, sEnumItem>
+			{
+			public:
+				EnumItem() { }
+			};
+		}
+	}
+}
+

ClientBase/RenderSettingsItem.cpp

@@ -0,0 +1,344 @@
+/**
+ * RenderSettingsItem.cpp
+ * Copyright (c) 2013 ROBLOX Corp. All Rights Reserved.
+ */
+
+#include "stdafx.h"
+#include "RenderSettingsItem.h"
+
+// Roblox Headers
+#include "v8datamodel/DebugSettings.h"
+#include "v8datamodel/GameBasicSettings.h"
+#include "V8DataModel/PartInstance.h"
+#include "util/standardout.h"
+#include "rbx/SystemUtil.h"
+
+using namespace RBX;
+
+RBX_REGISTER_CLASS(CRenderSettingsItem);
+
+RBX_REGISTER_ENUM(CRenderSettings::AASamples);
+RBX_REGISTER_ENUM(CRenderSettings::GraphicsMode);
+RBX_REGISTER_ENUM(CRenderSettings::FrameRateManagerMode);
+RBX_REGISTER_ENUM(CRenderSettings::AntialiasingMode);
+RBX_REGISTER_ENUM(CRenderSettings::QualityLevel);
+RBX_REGISTER_ENUM(CRenderSettings::ResolutionPreset);
+
+namespace RBX
+{
+	namespace Reflection
+	{
+		template<> Reflection::EnumDesc<CRenderSettings::AASamples>::EnumDesc()
+			:RBX::Reflection::EnumDescriptor("AASamples")
+		{
+			addPair(CRenderSettings::NONE, "None");
+			addPair(CRenderSettings::AA4, "4");
+			addPair(CRenderSettings::AA8, "8");
+		}
+
+		template<> Reflection::EnumDesc<CRenderSettings::GraphicsMode>::EnumDesc()
+			:Reflection::EnumDescriptor("GraphicsMode")
+		{
+			addPair(CRenderSettings::AutoGraphicsMode,"Automatic");
+			addPair(CRenderSettings::Direct3D9,"Direct3D9");
+            addPair(CRenderSettings::Direct3D11,"Direct3D11");
+			addPair(CRenderSettings::OpenGL,"OpenGL");
+			addPair(CRenderSettings::NoGraphics,"NoGraphics");
+		}
+
+		template<> Reflection::EnumDesc<CRenderSettings::FrameRateManagerMode>::EnumDesc()
+			:Reflection::EnumDescriptor("FramerateManagerMode")
+		{
+			addPair(CRenderSettings::FrameRateManagerAuto,"Automatic");
+			addPair(CRenderSettings::FrameRateManagerOn,"On");
+			addPair(CRenderSettings::FrameRateManagerOff,"Off");
+		}
+
+		template<> Reflection::EnumDesc<CRenderSettings::AntialiasingMode>::EnumDesc()
+			:Reflection::EnumDescriptor("Antialiasing")
+		{
+			addPair(CRenderSettings::AntialiasingOn,"Automatic");
+			addPair(CRenderSettings::AntialiasingOn,"Off");
+			addPair(CRenderSettings::AntialiasingOn,"On");
+		}
+
+		template<> Reflection::EnumDesc<CRenderSettings::QualityLevel>::EnumDesc()
+		:Reflection::EnumDescriptor("QualityLevel")
+		{
+			addPair(CRenderSettings::QualityAuto, "Automatic");
+
+			RBXASSERT(CRenderSettings::QualityLevelMax < 100);
+
+			// Generating all of the names for quality levels inplace on one array
+			for (int i = 1; i < CRenderSettings::QualityLevelMax; i++)
+			{
+				std::string name = RBX::format("Level%.2d", i);
+				addPair((CRenderSettings::QualityLevel)i, name.c_str());
+			}
+			{
+				char name [] = "Level 00";
+				char* numberstart = &name[sizeof(name) - 3];
+				for (int i = 1; i < CRenderSettings::QualityLevelMax; i++)
+				{
+					snprintf(numberstart, 3, "%2u", i);
+					addLegacyName(name, (CRenderSettings::QualityLevel)i);
+				}
+			}
+		}
+
+		template<> Reflection::EnumDesc<CRenderSettings::ResolutionPreset>::EnumDesc()
+		:Reflection::EnumDescriptor("Resolution")
+		{
+			addPair(CRenderSettings::ResolutionAuto, "Automatic");
+			addPair(CRenderSettings::Resolution720x526,		"720x526");
+			addPair(CRenderSettings::Resolution800x600,		"800x600");
+			addPair(CRenderSettings::Resolution1024x600,	"1024x600");
+			addLegacyName("1024x600 (wide)", CRenderSettings::Resolution1024x600);
+			addPair(CRenderSettings::Resolution1024x768,	"1024x768");
+			addPair(CRenderSettings::Resolution1280x720,	"1280x720");
+			addLegacyName("1280x720 (wide)", CRenderSettings::Resolution1280x720);
+			addPair(CRenderSettings::Resolution1280x768,	"1280x768");
+			addLegacyName("1280x768 (wide)", CRenderSettings::Resolution1280x768);
+			addPair(CRenderSettings::Resolution1152x864,	"1152x864");
+			addPair(CRenderSettings::Resolution1280x800,	"1280x800");
+			addLegacyName("1280x800 (wide)", CRenderSettings::Resolution1280x800);
+			addPair(CRenderSettings::Resolution1360x768,	"1360x768");
+			addLegacyName("1360x768 (wide)", CRenderSettings::Resolution1360x768);
+			addPair(CRenderSettings::Resolution1280x960,	"1280x960");
+			addPair(CRenderSettings::Resolution1280x1024,	"1280x1024");
+			addPair(CRenderSettings::Resolution1440x900,	"1440x900");
+			addLegacyName("1440x900 (wide)", CRenderSettings::Resolution1440x900);
+			addPair(CRenderSettings::Resolution1600x900,	"1600x900");
+			addLegacyName("1600x900 (wide)", CRenderSettings::Resolution1600x900);
+			addPair(CRenderSettings::Resolution1600x1024,	"1600x1024");
+			addLegacyName("1600x1024 (wide)", CRenderSettings::Resolution1600x1024);
+			addPair(CRenderSettings::Resolution1600x1200,	"1600x1200");
+			addPair(CRenderSettings::Resolution1680x1050,	"1680x1050");
+			addLegacyName("1680x1050 (wide)", CRenderSettings::Resolution1680x1050);
+			addPair(CRenderSettings::Resolution1920x1080,	"1920x1080");
+			addLegacyName("1920x1080 (wide)", CRenderSettings::Resolution1920x1080);
+			addPair(CRenderSettings::Resolution1920x1200,	"1920x1200");
+			addLegacyName("1920x1200 (wide)", CRenderSettings::Resolution1920x1200);
+		}
+	}
+}
+
+
+REFLECTION_BEGIN();
+static Reflection::EnumPropDescriptor<CRenderSettingsItem, CRenderSettingsItem::GraphicsMode> prop_graphicsMode("GraphicsMode", "General", &CRenderSettingsItem::getGraphicsMode, &CRenderSettingsItem::setGraphicsMode);
+static Reflection::PropDescriptor<CRenderSettingsItem, bool> prop_exporterMergeByMaterial("ExportMergeByMaterial", "General", &CRenderSettingsItem::getObjExportMergeByMaterial, &CRenderSettingsItem::setObjExportMergeByMaterial);
+
+static Reflection::EnumPropDescriptor<CRenderSettingsItem, CRenderSettingsItem::FrameRateManagerMode> prop_frameRateManagerMode("FrameRateManager", "General", &CRenderSettingsItem::getFrameRateManagerMode, &CRenderSettingsItem::setFrameRateManagerMode);
+static Reflection::EnumPropDescriptor<CRenderSettingsItem, CRenderSettingsItem::QualityLevel> prop_frmQuality("QualityLevel", "Performance", &CRenderSettingsItem::getQualityLevel, &CRenderSettingsItem::setQualityLevel);
+static Reflection::EnumPropDescriptor<CRenderSettingsItem, CRenderSettingsItem::QualityLevel> prop_frmEditQuality("EditQualityLevel", "Performance", &CRenderSettingsItem::getEditQualityLevel, &CRenderSettingsItem::setEditQualityLevel);
+
+static Reflection::PropDescriptor<CRenderSettingsItem, bool> prop_ShowAggregation("IsAggregationShown", "Debug", &CRenderSettingsItem::getShowAggregation, &CRenderSettingsItem::setShowAggregation);
+
+static Reflection::BoundProp<bool> prop_IsSynchronizedWithPhysics("IsSynchronizedWithPhysics", "Performance", &CRenderSettingsItem::isSynchronizedWithPhysics);
+static Reflection::EnumPropDescriptor<CRenderSettingsItem, CRenderSettingsItem::AASamples> prop_AASamples("AASamples", "Quality", &CRenderSettingsItem::getAASamples, &CRenderSettingsItem::setAASamples);
+Reflection::BoundProp<std::string> CRenderSettingsItem::prop_profileName("profileName", "Quality", &CRenderSettingsItem::profileName, Reflection::PropertyDescriptor::STREAMING);
+static Reflection::EnumPropDescriptor<CRenderSettingsItem, CRenderSettingsItem::AntialiasingMode> prop_antialiasingMode("Antialiasing", "Quality", &CRenderSettingsItem::getAntialiasingMode, &CRenderSettingsItem::setAntialiasingMode);
+static Reflection::PropDescriptor<CRenderSettingsItem, bool> prop_debugShowBoundingBoxes("ShowBoundingBoxes", "Debug", &CRenderSettingsItem::getDebugShowBoundingBoxes, &CRenderSettingsItem::setDebugShowBoundingBoxes);
+static Reflection::PropDescriptor<CRenderSettingsItem, int> prop_autoQualityLevel("AutoFRMLevel", "Debug", &CRenderSettingsItem::getAutoQualityLevel, &CRenderSettingsItem::setAutoQualityLevel);
+
+static Reflection::PropDescriptor<CRenderSettingsItem, bool> prop_enableFRM("EnableFRM", "Debug", &CRenderSettingsItem::getEnableFRM, &CRenderSettingsItem::setEnableFRM, Reflection::PropertyDescriptor::LEGACY_SCRIPTING);
+static Reflection::PropDescriptor<CRenderSettingsItem, bool> prop_debugDisableInterpolation("DebugDisableInterpolation", "Debug", &CRenderSettingsItem::getDebugDisableInterpolation, &CRenderSettingsItem::setDebugDisableInterpolation);
+static Reflection::PropDescriptor<CRenderSettingsItem, bool> prop_showInterpolationPath("ShowInterpolationpath", "Debug", &CRenderSettingsItem::getShowInterpolationPath, &CRenderSettingsItem::setShowInterpolationPath);
+
+static Reflection::PropDescriptor<CRenderSettingsItem, bool> prop_debugReloadAssets("ReloadAssets", "Debug", &CRenderSettingsItem::getDebugReloadAssets, &CRenderSettingsItem::setDebugReloadAssets);
+
+Reflection::EnumPropDescriptor<CRenderSettingsItem, CRenderSettingsItem::ResolutionPreset> CRenderSettingsItem::prop_resolution("Resolution", "Screen", &CRenderSettingsItem::getResolutionPreference, &CRenderSettingsItem::setResolutionPreference);
+
+static Reflection::BoundFuncDesc<CRenderSettingsItem, int()> func_getMaxQualityLevel(&CRenderSettingsItem::getMaxQualityLevel, "GetMaxQualityLevel", Security::None);
+
+static Reflection::PropDescriptor<CRenderSettingsItem, int> prop_textureCacheSize("TextureCacheSize", "Cache", &CRenderSettingsItem::getTextureCacheSize, &CRenderSettingsItem::setTextureCacheSize);
+static Reflection::PropDescriptor<CRenderSettingsItem, int> prop_meshCacheSize("MeshCacheSize", "Cache", &CRenderSettingsItem::getMeshCacheSize, &CRenderSettingsItem::setMeshCacheSize);
+REFLECTION_END();
+
+const char* const sRenderSettings = "RenderSettings";
+
+CRenderSettingsItem::CRenderSettingsItem()
+	:isSynchronizedWithPhysics(false)
+	, currentDisplaySize(800, 600)
+{
+	setName("Rendering");
+	fullScreenSizes.push_back(currentDisplaySize); // at least one valid default.	
+
+	size_t s = SystemUtil::getVideoMemory();
+	if (s>=16000000)
+		fullscreenSize = G3D::Vector2int16(1024, 768);
+	else
+		fullscreenSize = G3D::Vector2int16(800, 600);
+}
+
+
+void CRenderSettingsItem::setShowAggregation(bool value) {
+	if (value!=showAggregation)
+	{
+		showAggregation = value;
+		settingsChangedSignal(&prop_ShowAggregation);
+	}
+}
+
+void CRenderSettingsItem::runProfiler(bool overwriteExistingValues)
+{
+	static const char* profileName = "profiled5";
+	if (overwriteExistingValues || this->profileName!=profileName)
+	{
+		prop_profileName.setValue(this, profileName);
+	}
+}
+
+
+void CRenderSettingsItem::setAASamples(AASamples value)
+{
+	if (value!=aaSamples)
+	{
+		aaSamples = value;
+		settingsChangedSignal(&prop_AASamples);
+	}
+}
+
+void CRenderSettingsItem::setResolutionPreference(ResolutionPreset value)
+{
+	if (value!=resolutionPreference)
+	{
+		resolutionPreference = value;
+		settingsChangedSignal(&prop_resolution);
+	}
+}
+
+void CRenderSettingsItem::setFullscreenSize(G3D::Vector2int16 value)
+{
+	fullscreenSize = value;
+}
+
+void CRenderSettingsItem::setWindowSize(G3D::Vector2int16 value)
+{
+	windowSize = value;
+}
+
+// Same pattern used in PhysicsSettings::30FPS Throttle
+void CRenderSettingsItem::setGraphicsMode(GraphicsMode value) 
+{
+	if (value != graphicsMode) {
+		graphicsMode = value;
+		settingsChangedSignal(&prop_graphicsMode);
+	}
+}
+
+#define SET_MODE(modeName, modeVar) \
+void CRenderSettingsItem::set##modeName##Mode(modeName##Mode value) \
+{\
+	if (value != modeVar##Mode) {\
+		modeVar##Mode = value;\
+		settingsChangedSignal(&prop_##modeVar##Mode);\
+	}\
+}
+
+SET_MODE(FrameRateManager,frameRateManager);
+SET_MODE(Antialiasing,antialiasing);
+
+
+void CRenderSettingsItem::setQualityLevel(QualityLevel value)
+{
+	if (value != qualityLevel) {
+		qualityLevel = value;
+		settingsChangedSignal(&prop_frmQuality);
+	}
+}
+void CRenderSettingsItem::setEditQualityLevel(QualityLevel value)
+{
+	if (value != editQualityLevel) {
+		editQualityLevel = value;
+		settingsChangedSignal(&prop_frmEditQuality);
+	}
+}
+void CRenderSettingsItem::setAutoQualityLevel(int value)
+{
+	if (value != autoQualityLevel) {
+		autoQualityLevel = value;
+		settingsChangedSignal(&prop_frmQuality);
+	}
+}
+
+void CRenderSettingsItem::setDebugShowBoundingBoxes(bool value)
+{
+	if (value != debugShowBoundingBoxes) {
+		debugShowBoundingBoxes = value;
+		settingsChangedSignal(&prop_debugShowBoundingBoxes);
+	}
+}
+
+void CRenderSettingsItem::setEnableFRM(bool value)
+{
+	if (value != enableFRM) {
+		enableFRM = value;
+		settingsChangedSignal(&prop_enableFRM);
+	}
+}
+
+void CRenderSettingsItem::setTextureCacheSize(unsigned int size)
+{
+	textureCacheSize = size;
+}
+void CRenderSettingsItem::setMeshCacheSize(unsigned int size)
+{
+	meshCacheSize = size;
+}
+
+bool CRenderSettingsItem::getDebugDisableInterpolation() const
+{
+	return PartInstance::disableInterpolation;
+}
+
+void CRenderSettingsItem::setDebugDisableInterpolation(bool value)
+{
+	PartInstance::disableInterpolation = value;
+}
+
+bool CRenderSettingsItem::getShowInterpolationPath() const
+{
+	return PartInstance::showInterpolationPath;
+}
+
+void CRenderSettingsItem::setShowInterpolationPath(bool value)
+{
+	PartInstance::showInterpolationPath = value;
+}
+
+bool CRenderSettingsItem::getDebugReloadAssets() const
+{
+    return debugReloadAssets;
+}
+
+void CRenderSettingsItem::setDebugReloadAssets(bool value)
+{
+    debugReloadAssets = value;
+}
+
+bool CRenderSettingsItem::getObjExportMergeByMaterial() const
+{
+    return objExportMergeByMaterial;
+}
+
+void CRenderSettingsItem::setObjExportMergeByMaterial(bool value)
+{
+    objExportMergeByMaterial = value;
+}
+
+#define SET_VAR_NOREG(T, boolName, boolVar, Category) \
+	void CRenderSettingsItem::set##boolName(T value) \
+	{ \
+		if (value != boolVar) { \
+			boolVar = value; \
+			settingsChangedSignal(&prop_##boolVar); \
+		} \
+	}
+
+#define SET_VAR(T, boolName, boolVar, Category) \
+	static Reflection::PropDescriptor<CRenderSettingsItem, T> prop_##boolVar(#boolName, Category, &CRenderSettingsItem::get##boolName, &CRenderSettingsItem::set##boolName); \
+	SET_VAR_NOREG(T, boolName, boolVar, Category)
+
+SET_VAR(bool, EagerBulkExecution, eagerBulkExecution, "Performance")
+

ClientBase/RenderSettingsItem.h

@@ -0,0 +1,70 @@
+#pragma once
+
+// standard C/C++ Headers
+#include <vector>
+
+// Roblox Headers
+#include "V8DataModel/GlobalSettings.h"
+#include "GfxBase/RenderSettings.h"
+#include "Reflection/Reflection.h"
+
+
+extern const char* const sRenderSettings;
+class CRenderSettingsItem : public RBX::GlobalAdvancedSettingsItem<CRenderSettingsItem, sRenderSettings>, public RBX::CRenderSettings
+{
+	std::string profileName;
+	G3D::Vector2int16 currentDisplaySize;
+	std::vector<G3D::Vector2int16> fullScreenSizes;
+public:
+	
+
+	void setShowAggregation(bool value);
+
+	static RBX::Reflection::BoundProp<std::string> prop_profileName;
+
+	CRenderSettingsItem();
+	
+	void runProfiler(bool overwriteExistingValues);
+
+	void setAASamples(AASamples value);
+
+	void setFullscreenSize(G3D::Vector2int16 value);
+	void setWindowSize(G3D::Vector2int16 value);
+
+	bool isSynchronizedWithPhysics;
+
+	void setGraphicsMode(GraphicsMode value);
+
+	void setFrameRateManagerMode(FrameRateManagerMode value);
+	void setAntialiasingMode(AntialiasingMode value);
+	void setQualityLevel(QualityLevel value);
+	void setEditQualityLevel(QualityLevel value);
+	void setAutoQualityLevel(int level);
+	void setResolutionPreference(ResolutionPreset value);
+
+	void setMinCullDistance(int value);
+	void setDebugShowBoundingBoxes(bool value);
+	void setEagerBulkExecution(bool value);
+
+	void setEnableFRM(bool value);
+
+	void setTextureCacheSize(unsigned int size);
+	void setMeshCacheSize(unsigned int size);
+
+	bool getDebugDisableInterpolation() const;
+	void setDebugDisableInterpolation(bool value);
+
+	bool getShowInterpolationPath() const;
+	void setShowInterpolationPath(bool value);
+
+    bool getDebugReloadAssets() const;
+    void setDebugReloadAssets(bool value);
+
+    bool getObjExportMergeByMaterial() const;
+    void setObjExportMergeByMaterial(bool value);
+
+	static RBX::Reflection::EnumPropDescriptor<CRenderSettingsItem, CRenderSettingsItem::ResolutionPreset> prop_resolution;
+
+	// special signal used only in native code
+	rbx::signal<void(const RBX::Reflection::PropertyDescriptor*)> settingsChangedSignal;
+};