#include "stdafx.h"
#include "GeometryGenerator.h"

#include "GfxBase/AsyncResult.h"
#include "GfxBase/PartIdentifier.h"
#include "humanoid/Humanoid.h"
#include "VisualEngine.h"
#include "GfxBase/RenderCaps.h"
#include "GfxCore/Device.h"

#include "util/MeshId.h"
#include "Util.h"
#include "util/Lcmrand.h"
#include "util/NormalId.h"

#include "v8datamodel/CharacterMesh.h"
#include "v8datamodel/SpecialMesh.h"
#include "v8datamodel/FileMesh.h"
#include "v8datamodel/ContentProvider.h"
#include "v8datamodel/MeshContentProvider.h"
#include "v8datamodel/BlockMesh.h"
#include "v8datamodel/CylinderMesh.h"
#include "v8datamodel/Decal.h"
#include "v8datamodel/ExtrudedPartInstance.h"
#include "v8datamodel/PartCookie.h"
#include "v8datamodel/Lighting.h"
#include "v8world/Primitive.h"
#include "V8DataModel/PartOperation.h"
#include "V8DataModel/PartOperationAsset.h"
#include "V8DataModel/SolidModelContentProvider.h"

#include "g3d/g3dmath.h"

#include "GfxBase/FileMeshData.h"
#include "GfxBase/GfxPart.h"

#include "MaterialGenerator.h"
#include "V8World/TriangleMesh.h"
#include "BulletCollision/CollisionShapes/btConvexHullShape.h"
#include "BulletCollision/CollisionShapes/btShapeHull.h"
#include "BulletCollision/CollisionShapes/btConvexPolyhedron.h"
#include "Extras/GIMPACTUtils/btGImpactConvexDecompositionShape.h"

FASTFLAGVARIABLE(NoRandomColorsWithoutOutlines, true)
FASTFLAGVARIABLE(FixMeshOffset, false)
FASTFLAG(FixGlowingCSG)
FASTFLAG(StudioCSGAssets)
FASTFLAG(CSGLoadBlocking)
FASTFLAG(CSGPhysicsLevelOfDetailEnabled)

#define TESSELATION_PIECE 8.0f
#define MAX_TESSELATION 50.0f

#define NO_OUTLINES 10.0f


namespace RBX
{
namespace Graphics
{
	static const boost::shared_ptr<FileMeshData> kDummyMeshData(new FileMeshData());
	
	static const float kNormalOffsetScale = 0.02f;
	
	static const Vector3 kNormalOffsetTable[32] =
	{
		Vector3(-0.5237f, +0.7208f, -0.5878f) * kNormalOffsetScale,
		Vector3(-0.5590f, +0.7694f, -0.5878f) * kNormalOffsetScale,
		Vector3(-0.2668f, +0.3673f, -0.5878f) * kNormalOffsetScale,
		Vector3(+0.1816f, -0.2500f, -0.5878f) * kNormalOffsetScale,
		Vector3(-0.8800f, +0.1394f, -0.9877f) * kNormalOffsetScale,
		Vector3(-0.9393f, +0.1488f, -0.9877f) * kNormalOffsetScale,
		Vector3(-0.4484f, +0.0710f, -0.9877f) * kNormalOffsetScale,
		Vector3(+0.3052f, -0.0483f, -0.9877f) * kNormalOffsetScale,
		Vector3(-0.7208f, -0.5237f, -0.8090f) * kNormalOffsetScale,
		Vector3(-0.7694f, -0.5590f, -0.8090f) * kNormalOffsetScale,
		Vector3(-0.3673f, -0.2668f, -0.8090f) * kNormalOffsetScale,
		Vector3(+0.2500f, +0.1816f, -0.8090f) * kNormalOffsetScale,
		Vector3(-0.1394f, -0.8800f, -0.1564f) * kNormalOffsetScale,
		Vector3(-0.1488f, -0.9393f, -0.1564f) * kNormalOffsetScale,
		Vector3(-0.0710f, -0.4484f, -0.1564f) * kNormalOffsetScale,
		Vector3(+0.0483f, +0.3052f, -0.1564f) * kNormalOffsetScale,
		Vector3(+0.5237f, -0.7208f, +0.5878f) * kNormalOffsetScale,
		Vector3(+0.5590f, -0.7694f, +0.5878f) * kNormalOffsetScale,
		Vector3(+0.2668f, -0.3673f, +0.5878f) * kNormalOffsetScale,
		Vector3(-0.1816f, +0.2500f, +0.5878f) * kNormalOffsetScale,
		Vector3(+0.8800f, -0.1394f, +0.9877f) * kNormalOffsetScale,
		Vector3(+0.9393f, -0.1488f, +0.9877f) * kNormalOffsetScale,
		Vector3(+0.4484f, -0.0710f, +0.9877f) * kNormalOffsetScale,
		Vector3(-0.3052f, +0.0483f, +0.9877f) * kNormalOffsetScale,
		Vector3(+0.7208f, +0.5237f, +0.8090f) * kNormalOffsetScale,
		Vector3(+0.7694f, +0.5590f, +0.8090f) * kNormalOffsetScale,
		Vector3(+0.3673f, +0.2668f, +0.8090f) * kNormalOffsetScale,
		Vector3(-0.2500f, -0.1816f, +0.8090f) * kNormalOffsetScale,
		Vector3(+0.1394f, +0.8800f, +0.1564f) * kNormalOffsetScale,
		Vector3(+0.1488f, +0.9393f, +0.1564f) * kNormalOffsetScale,
		Vector3(+0.0710f, +0.4484f, +0.1564f) * kNormalOffsetScale,
		Vector3(-0.0483f, -0.3052f, +0.1564f) * kNormalOffsetScale,
	};
	
	static const float kUniformRandomTable[64] =
	{
		0.827323f, 0.526485f, 0.916254f, 0.225426f, 0.969743f, 0.069476f, 0.423928f, 0.794976f,
		0.629325f, 0.707109f, 0.997080f, 0.371298f, 0.537122f, 0.692187f, 0.309150f, 0.207611f,
		0.347299f, 0.680269f, 0.854916f, 0.321542f, 0.848045f, 0.825441f, 0.699820f, 0.365232f,
		0.391758f, 0.982131f, 0.961126f, 0.854716f, 0.847131f, 0.427982f, 0.901692f, 0.705821f,
		0.230473f, 0.367524f, 0.324393f, 0.797571f, 0.048550f, 0.245296f, 0.805075f, 0.484867f,
		0.740669f, 0.375044f, 0.792494f, 0.275678f, 0.915932f, 0.376178f, 0.625879f, 0.648950f,
		0.213511f, 0.454967f, 0.172181f, 0.734572f, 0.339370f, 0.280913f, 0.053203f, 0.001882f,
		0.826664f, 0.551022f, 0.833667f, 0.987611f, 0.108350f, 0.569212f, 0.947845f, 0.201343f,
	};
	
	struct UVAtlasInfo
	{
		bool tileX;
		float scaleY, offsetY;
		
		UVAtlasInfo(bool tileX, float scaleY, float offsetY): tileX(tileX), scaleY(scaleY), offsetY(offsetY)
		{
		}
	};

	struct FACEDESC
	{
		unsigned start0, start1;
		unsigned end0, end1;
		bool dirZ;
		bool tangentZ;
	};

	inline float transformUV(float v, float scale, float offset)
	{
		const float threshold = 1e-2f;
		
		if (v < -threshold || v > 1.f + threshold)
			return (v - floorf(v)) * scale + offset;
		else
			return v * scale + offset;
	}
	
	inline Vector2 transformUV(const Vector2& uv, const GeometryGenerator::Options& options)
	{
		return
			(options.flags & GeometryGenerator::Flag_TransformUV)
				? Vector2(transformUV(uv.x, options.uvframe.z, options.uvframe.x), transformUV(uv.y, options.uvframe.w, options.uvframe.y))
				: uv;
	}

	inline UVAtlasInfo getStudsAtlasInfo(SurfaceType type)
	{
		switch(type)
		{
		case STUDS:
			return UVAtlasInfo(true, 0.25f, 0.0f);
			break;
		case WELD:
			return UVAtlasInfo(true, 0.25f, 0.25f);
			break;
		case INLET:
			return UVAtlasInfo(true, 0.25f, 0.5f);
			break;
		case UNIVERSAL:
			return UVAtlasInfo(true, 0.25f, 0.75f);
			break;
		case GLUE:
			return UVAtlasInfo(true, 0.25f, 0.25f);
			break;
		default:
			return UVAtlasInfo(false, 0.0f, 0.0f);
		}
	}
	
#ifdef _MSC_VER
	__forceinline
#else
	inline
#endif
	void fillVertex(
		GeometryGenerator::Vertex& r, 
		const Vector3& pos, 
		const Vector3& normal, 
		const Vector2& uv, 
		const Vector2& uvStuds, 
		const Color4uint8& color, 
		const Color4uint8& extra, 
		const Vector3& tangent, 
		const Vector4& edgeDistances = Vector4(NO_OUTLINES, NO_OUTLINES, NO_OUTLINES, NO_OUTLINES))
	{
		r.pos = pos;
		r.normal = normal;
		r.uv = uv;
		r.uvStuds = uvStuds;
		r.color = color;
		r.extra = extra;
		r.tangent = tangent;
		r.edgeDistances = edgeDistances;
	}
	
	inline void fillQuadIndices(unsigned short* r, size_t offset, unsigned int i00, unsigned int i10, unsigned int i01, unsigned int i11)
	{
		r[0] = offset + i00;
		r[1] = offset + i10;
		r[2] = offset + i01;
		
		r[3] = offset + i01;
		r[4] = offset + i10;
		r[5] = offset + i11;
	}
	
	inline void extendBounds(Vector3& boundsMin, Vector3& boundsMax, const Vector3& pos)
	{
		boundsMin = boundsMin.min(pos);
		boundsMax = boundsMax.max(pos);
	}

	inline void extendBoundsBlock(Vector3& boundsMin, Vector3& boundsMax, const Vector3& center, const Vector3& size, 
		const Vector3& axisX, const Vector3& axisY, const Vector3& axisZ )
	{
		Vector3 extent = size * 0.5f;

		Vector3 boundsExtent = Vector3(
			fabsf(axisX.x) * extent.x + fabsf(axisY.x) * extent.y + fabsf(axisZ.x) * extent.z,
			fabsf(axisX.y) * extent.x + fabsf(axisY.y) * extent.y + fabsf(axisZ.y) * extent.z,
			fabsf(axisX.z) * extent.x + fabsf(axisY.z) * extent.y + fabsf(axisZ.z) * extent.z);

		boundsMin = boundsMin.min(center - boundsExtent);
		boundsMax = boundsMax.max(center + boundsExtent);
	}
	
	// We have 1 default non-mesh head and 16 non-mesh heads that you can buy
	// All future heads will be mesh heads; but we have to support legacy heads as well
	// They were baked once into mesh files (with decal UVs and some vertex welding).
	
	// Here's a table of cylinder head meshes: id, bevel, bevel roundness, bulge, LODx, LODy, offset, scale
	// A		0		0	0.5		1	2	0,0.1,0		1.25,1.25,1.25
	// C		0.1		0	0.5		1	2	0,0.1,0		1.25,1.25,1.25
	// D		0.4		0	0		2	2	0,0.05,0	1.4,1.4,1.35
	// E		0.66	0	0.5		2	2	0,0.05,0	1.4,1.6,1.35
	// F		0		0	0		1	0	0,0.1,0		1.25,1.25,1.25
	// G		0		0	1		2	2	0,0.1,0		1.25,1.25,1.25
	// H		0.2		0	1		2	2	0,0.1,0		1.3,1.3,1.3
	// N		0.4		1	0		2	2	0,0.05,0	1.4,1.4,1.35
	// O		0.2		0	0.5		1	2	0,0.1,0		1.3,1.3,1.3
	// P		0.1		0	0		2	2	0,0.1,0		1.25,1.25,1.25
	
	// Here's a table of block head meshes: id, bevel, bevel roundness, bulge, LODx, LODy, offset, scale
	// B		0		0	0		2	2	0,0.05,0	0.56,1.1,1.1
	// I		0.5		0	0		2	2	0,0.05,0	0.8,1.3,1.2
	// J		0.3		0	0		2	2	0,0.1,0		0.63,1.3,1.1
	// M		0.05	0	0		2	2	0,0.05,0	0.56,1.1,1.1
	static MeshId getHeadMeshId(PartInstance* part, DataModelMesh* specialShape)
	{
		// Note that bevel, roundness and bulge are unique enough to determine the cylinder/block variant, so we'll use just that
	#define LOOKUP(ifBevel, ifRoundness, ifBulge, head) \
		if (G3D::fuzzyEq(bevel, ifBevel) && G3D::fuzzyEq(roundness, ifRoundness) && G3D::fuzzyEq(bulge, ifBulge)) return MeshId("rbxasset://fonts/head" head ".mesh")
	
		if (specialShape)
		{
			if (SpecialShape* shape = specialShape->fastDynamicCast<SpecialShape>())
			{
				if (shape->getMeshType() == SpecialShape::HEAD_MESH)
				{
					// Return the default head; scaling is taken care of in getMeshScale
					return MeshId("rbxasset://fonts/head.mesh");
				}
				else if (shape->getMeshType() == SpecialShape::SPHERE_MESH)
				{
					// Return the sphere head; scaling is taken care of in getMeshScale
					return MeshId("rbxasset://fonts/headL.mesh");
				}
			}
			else if (CylinderMesh* shape = specialShape->fastDynamicCast<CylinderMesh>())
			{
				float bevel = shape->getBevel(), roundness = shape->getRoundness(), bulge = shape->getBulge();
				
				LOOKUP(0.0,		0.0,		0.5,	"A");
				LOOKUP(0.1,		0.0,		0.5,	"C");
				LOOKUP(0.4,		0.0,		0.0,	"D");
				LOOKUP(0.66,	0.0,		0.5,	"E");
				LOOKUP(0.0,		0.0,		0.0,	"F");
				LOOKUP(0.0,		0.0,		1.0,	"G");
				LOOKUP(0.2,		0.0,		1.0,	"H");
				LOOKUP(0.4,		1.0,		0.0,	"N");
				LOOKUP(0.2,		0.0,		0.5,	"O");
				LOOKUP(0.1,		0.0,		0.0,	"P");
			}
			else if (BlockMesh* shape = specialShape->fastDynamicCast<BlockMesh>())
			{
				float bevel = shape->getBevel(), roundness = shape->getRoundness(), bulge = shape->getBulge();
				
				LOOKUP(0.0,		0.0,		0.0,	"B");
				LOOKUP(0.5,		0.0,		0.0,	"I");
				LOOKUP(0.3,		0.0,		0.0,	"J");
				LOOKUP(0.05,	0.0,		0.0,	"M");
			}
		}
		
		// fallback for all other head types
		return MeshId("rbxasset://fonts/head.mesh");
		
	#undef LOOKUP
	}
	
	static MeshId getMeshIdForBodyPart(const HumanoidIdentifier& hi, PartInstance* part, DataModelMesh* specialShape, unsigned int flags)
	{
		if (CharacterMesh* charmesh = hi.getRelevantMesh(part))
			return charmesh->getMeshId();
		else if (part == hi.torso && (flags & GeometryGenerator::Resource_SubstituteBodyParts))
			return MeshId("rbxasset://fonts/torso.mesh");
		else if (part == hi.leftArm && (flags & GeometryGenerator::Resource_SubstituteBodyParts))
			return MeshId("rbxasset://fonts/leftarm.mesh");
		else if (part == hi.rightArm && (flags & GeometryGenerator::Resource_SubstituteBodyParts))
			return MeshId("rbxasset://fonts/rightarm.mesh");
		else if (part == hi.leftLeg && (flags & GeometryGenerator::Resource_SubstituteBodyParts))
			return MeshId("rbxasset://fonts/leftleg.mesh");
		else if (part == hi.rightLeg && (flags & GeometryGenerator::Resource_SubstituteBodyParts))
			return MeshId("rbxasset://fonts/rightleg.mesh");
		else if (part == hi.head && (flags & GeometryGenerator::Resource_SubstituteBodyParts))
			return getHeadMeshId(part, specialShape);
		else
			return MeshId();
	}
	
	static float getPartTransparency(PartInstance* part)
	{
		// Reflectance affects Transparency for plastic parts - part with Transparency at 0.99 and Reflectance at 1 should still be somewhat visible
		return (part->getRenderMaterial() == PLASTIC_MATERIAL)
			? part->getTransparencyUi() * (1 - getPartReflectance(part))
			: part->getTransparencyUi();
	}
	
	static Color4uint8 getBaseColor(PartInstance* part, Decal* decal, DataModelMesh* specialShape, const GeometryGenerator::Options& options)
	{
		float transparency = decal ? decal->getTransparencyUi() : getPartTransparency(part);
		unsigned char alpha = 255 - static_cast<int>(G3D::clamp(transparency, 0.f, 1.f) * 255.f);
		
		// Decal never takes part/mesh colors
		if (decal)
			return Color4uint8(255, 255, 255, alpha);
		
		// Requested colors from mesh
		if (options.flags & GeometryGenerator::Flag_VertexColorMesh)
		{
			FileMesh* fileMesh = Instance::fastDynamicCast<FileMesh>(specialShape);
			
			if (fileMesh && !fileMesh->getTextureId().isNull())
				return Color4uint8(Color3uint8(Color3(specialShape->getVertColor())), alpha);
			else
				return Color4uint8(255, 255, 255, alpha);
		}
			
		// Requested colors from part
		if (options.flags & GeometryGenerator::Flag_VertexColorPart)
			return Color4uint8(part->getColor().color3uint8(), alpha);
			
		return Color4uint8(255, 255, 255, alpha);
	}

	static Color4uint8 getColor(PartInstance* part, Decal* decal, DataModelMesh* specialShape, const GeometryGenerator::Options& options, unsigned int randomSeed, bool isBlock)
	{
		Color4uint8 diffuse = getBaseColor(part, decal, specialShape, options);
		
		Color4uint8 color =
			(isBlock && (options.flags & GeometryGenerator::Flag_RandomizeBlockAppearance))
				? Color4uint8(
					(diffuse.r & 0xf8) | (randomSeed & 7),
					(diffuse.g & 0xf8) | (randomSeed & 7),
					(diffuse.b & 0xf8) | (randomSeed & 7),
					diffuse.a)
				: diffuse;

		return
			(options.flags & GeometryGenerator::Flag_DiffuseColorBGRA)
				? Color4uint8(color.b, color.g, color.r, color.a)
				: color;
	}
	
	static Color4uint8 getExtra(PartInstance* part, const GeometryGenerator::Options& options)
	{
		Vector2int16 specular = MaterialGenerator::getSpecular(part->getRenderMaterial());
        int reflectance = getPartReflectance(part) * 255;
		
		return
			(options.flags & GeometryGenerator::Flag_ExtraIsZero)
			? Color4uint8(0, 0, 0, 0)
			: Color4uint8(options.extra, specular.x, specular.y, reflectance);
	}

	static Vector3 getMeshScale(PartInstance* part, DataModelMesh* specialShape, const HumanoidIdentifier* humanoidIdentifier)
	{
    	if (specialShape)
		{
			// File meshes don't inherit part size and just use custom scale
			if (part->getCookie() & PartCookie::HAS_FILEMESH)
				return specialShape->getScale();
				
			// If it's not a file mesh, it must be a substituted body part.
			// These have a constant scale with the exception of the head mesh and sphere mesh
			if (SpecialShape* shape = specialShape->fastDynamicCast<SpecialShape>())
			{
				if (shape->getMeshType() == SpecialShape::HEAD_MESH)
				{
					// For heads, the scale works separately for XZ and Y
					Vector3 size = part->getPartSizeXml() * shape->getScale();
					float scaleXZ = std::min(size.x, size.z);
					float scaleY = size.y;
					
					// Default head is baked with uniform scale 1.25
					return Vector3(scaleXZ, scaleY, scaleXZ) / 1.25f;
				}
				else if (shape->getMeshType() == SpecialShape::SPHERE_MESH)
				{
					Vector3 size = part->getPartSizeXml() * shape->getScale();
					
					// Default head is baked with scale 1.5 1.45 1.45
					return size / Vector3(1.5f, 1.45f, 1.45f);
				}
			}
		}
		
        if (humanoidIdentifier && humanoidIdentifier->getBodyPartType(part) != HumanoidIdentifier::PartType_Unknown)
        {
            if (humanoidIdentifier->isPartHead(part))
            {
                Vector3 size = part->getPartSizeXml();
                float scaleXZ = std::min(size.x, size.z);
                return Vector3(scaleXZ, size.y, scaleXZ);
            }
            else
            {
                Vector3 standardPartSize = humanoidIdentifier->getBodyPartScale(part);
                Vector3 partSize = part->getPartSizeXml();
                return partSize / standardPartSize;
            }
        }

		return Vector3::one();
	}

	template<bool vertical> Vector3 verticalRotate(const Vector3& pos)
	{
		return vertical ? Vector3(pos.y, -pos.x, pos.z) : pos;
	}

	template<bool vertical> Vector2 verticalRotateDecal(const Vector2& pos)
	{
		return vertical ? Vector2(-pos.y, pos.x) : pos;
	}

	template<bool vertical> NormalId verticalRotate(NormalId id) {
		if (!vertical)
			return id;

		switch(id)
		{
		case NORM_X: return NORM_Y;
		case NORM_Y: return NORM_X_NEG;
		case NORM_X_NEG: return NORM_Y_NEG;
		case NORM_Y_NEG: return NORM_X;
		default:
			return id;
		}
	}


	template<bool vertical> Vector2 getDecalUVVertical(Decal* decal, const Vector3& size, bool ignoreSurfaceType)	
	{
		if (!ignoreSurfaceType)
		{
			if (DecalTexture* texture = decal->fastDynamicCast<DecalTexture>())
			{
				switch (verticalRotate<vertical>(texture->getFace()))
				{
				case NORM_X: return Vector2(size.z, size.y) / texture->getStudsPerTile();
				case NORM_Y: return Vector2(-size.x, size.z) / texture->getStudsPerTile();
				case NORM_Z: return Vector2(size.x, size.y) / texture->getStudsPerTile();
				
				case NORM_X_NEG: return Vector2(-size.z, size.y) / texture->getStudsPerTile();
				case NORM_Y_NEG: return Vector2(size.x, -size.z) / texture->getStudsPerTile();
				case NORM_Z_NEG: return Vector2(-size.x, size.y) / texture->getStudsPerTile();
                        
                default: return Vector2();
				}
			}
		}
		
		return Vector2(1.0f, 1.0f);
	}

	inline Vector2 getDecalUV(Decal* decal, const Vector3& size, bool ignoreSurfaceType)
	{
		return getDecalUVVertical<false>(decal, size, ignoreSurfaceType);
	}

	static Vector2 getSurfaceOffset(const Vector3& size, unsigned int randomSeed, PartMaterial material)
	{
        int randomU = (randomSeed >> 3) & 63;
        int randomV = (randomSeed >> 9) & 63;

        if (material == BRICK_MATERIAL || material == WOODPLANKS_MATERIAL)
        {
            // We want the stud-aligned bricks to roughly match between parts, so we're only shifting the tiling in 1 stud increments
            return Vector2(randomU, randomV);
        }
        else
        {
            float maxOffset = (size.x + size.y + size.z) / 2;
            
            return maxOffset * Vector2(kUniformRandomTable[randomU] * 2 - 1, kUniformRandomTable[randomV] * 2 - 1);
        }
	}

    static float getSurfaceTiling(PartMaterial material)
    {
        return MaterialGenerator::getTiling(material);
    } 

	static Vector4 computeOutlineOffsetPart(NormalId face, PartInstance* part)
	{
		if(part->getSurfaceType(face) == NO_SURFACE_NO_OUTLINES)
			return Vector4(NO_OUTLINES, NO_OUTLINES, NO_OUTLINES, NO_OUTLINES);


		static const NormalId adjTable [6][4] = {
			{ NORM_Z_NEG, NORM_Z, NORM_Y, NORM_Y_NEG }, // NormX
			{ NORM_X_NEG, NORM_X, NORM_Z, NORM_Z_NEG }, // NormY
			{ NORM_X, NORM_X_NEG, NORM_Y, NORM_Y_NEG }, // NormZ
			{ NORM_Z, NORM_Z_NEG, NORM_Y, NORM_Y_NEG }, // NormX_Neg
			{ NORM_X_NEG, NORM_X, NORM_Z_NEG, NORM_Z }, // NormY_Neg
			{ NORM_X_NEG, NORM_X, NORM_Y, NORM_Y_NEG }, // NormZ_Neg
		};

		Vector4 result;

		result.x = part->getSurfaceType(adjTable[face][0]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;
		result.y = part->getSurfaceType(adjTable[face][1]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;
		result.z = part->getSurfaceType(adjTable[face][2]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;
		result.w = part->getSurfaceType(adjTable[face][3]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;

		return result;
	}

	static Vector4 computeOutlineOffsetWedge(NormalId face, PartInstance* part)
	{
		if(part->getSurfaceType(face) == NO_SURFACE_NO_OUTLINES)
			return Vector4(NO_OUTLINES, NO_OUTLINES, NO_OUTLINES, NO_OUTLINES);


		static const NormalId adjTable [6][4] = {
			{ NORM_Z, NORM_Z_NEG, NORM_Z_NEG, NORM_Y_NEG }, // NormX
			{ NORM_Y, NORM_Y, NORM_Y, NORM_Y },				// NormY
			{ NORM_X, NORM_X_NEG, NORM_Z_NEG, NORM_Y_NEG }, // NormZ
			{ NORM_Z, NORM_Z_NEG, NORM_Z_NEG, NORM_Y_NEG }, // NormX_Neg
			{ NORM_X_NEG, NORM_X, NORM_Z_NEG, NORM_Z },		// NormY_Neg
			{ NORM_X_NEG, NORM_X, NORM_Z, NORM_Y_NEG },		// NormZ_Neg
		};

		Vector4 result;

		result.x = part->getSurfaceType(adjTable[face][0]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;
		result.y = part->getSurfaceType(adjTable[face][1]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;
		result.z = part->getSurfaceType(adjTable[face][2]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;
		result.w = part->getSurfaceType(adjTable[face][3]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;

		return result;
	}

	static Vector4 computeOutlineOffsetCornerWedge(NormalId face, PartInstance* part)
	{
		if(part->getSurfaceType(face) == NO_SURFACE_NO_OUTLINES)
			return Vector4(NO_OUTLINES, NO_OUTLINES, NO_OUTLINES, NO_OUTLINES);

		static const NormalId adjTable [6][4] = {
			{ NORM_Z_NEG, NORM_Z, NORM_Z_NEG, NORM_Y_NEG }, // NormX
			{ NORM_Y, NORM_Y, NORM_Y, NORM_Y },				// NormY
			{ NORM_X, NORM_X_NEG, NORM_X_NEG, NORM_Y_NEG },	// NormZ
			{ NORM_Z_NEG, NORM_Z, NORM_Z_NEG, NORM_Y_NEG }, // NormX_Neg
			{ NORM_X_NEG, NORM_X, NORM_Z_NEG, NORM_Z },		// NormY_Neg
			{ NORM_X_NEG, NORM_X, NORM_X_NEG, NORM_Y_NEG }, // NormZ_Neg
		};

		Vector4 result;

		result.x = part->getSurfaceType(adjTable[face][0]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;
		result.y = part->getSurfaceType(adjTable[face][1]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;
		result.z = part->getSurfaceType(adjTable[face][2]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;
		result.w = part->getSurfaceType(adjTable[face][3]) == NO_SURFACE_NO_OUTLINES ? NO_OUTLINES : 0;

		return result;
	}
	
	void GeometryGenerator::addFileMesh(FileMeshData* data, DataModelMesh* specialShape, PartInstance* part, Decal* decal, const HumanoidIdentifier* humanoidIdentifier, const Options& options)
	{
		size_t vertexCount = data->vnts.size();
		size_t faceCount = data->faces.size();

		size_t vertexOffset = mVertexCount;
		size_t indexOffset = mIndexCount;
		
		mVertexCount += vertexCount;
		mIndexCount += faceCount * 3;
		
		if (!mVertices) return;

		Color4uint8 color = getColor(part, decal, specialShape, options, 0, false);
		Color4uint8 extra = getExtra(part, options);
		Vector3 scale = getMeshScale(part, specialShape, humanoidIdentifier);

		const CoordinateFrame& cframe = options.cframe;
		Vertex* vertices = mVertices;
        Vector3 offset = specialShape ? specialShape->getOffset() : Vector3::zero();

		SpecialShape* shape = Instance::fastDynamicCast<SpecialShape>(specialShape);
		bool isHead = shape && shape->getMeshType() == SpecialShape::HEAD_MESH;

		if (isHead)
		{
			// Head mesh scale is not uniform - XZ scale scales the caps (beveled portion), and Y scale just extrudes the cylinder portion
			// Since head mesh is centered around origin, with 0.625 as Y extents (maxY ~= 0.625, minY ~= -0.625), we scale vertices by scale.x
			// along Y axis and extrude by headCylinderExtents, that is set to keep the cumulative extents at 0.625 * scale.y
			float headCylinderExtents = 0.625 * (scale.y - scale.x);
			
			for (size_t i = 0; i < vertexCount; ++i)
			{
				Vertex& v = vertices[vertexOffset + i];
				const FileMeshVertexNormalTexture3d& sv = data->vnts[i];
				
				float headY = (sv.vy > 0) ? (sv.vy * scale.x + headCylinderExtents) : (sv.vy * scale.x - headCylinderExtents);
					
                Vector3 pos;
                if (FFlag::FixMeshOffset)
				    pos = cframe.pointToWorldSpace(Vector3(sv.vx * scale.x, headY, sv.vz * scale.z) + offset);
                else
                    pos = cframe.pointToWorldSpace(Vector3(sv.vx * scale.x, headY, sv.vz * scale.z)) + offset;
				
				fillVertex(v, pos, cframe.vectorToWorldSpace(Vector3(sv.nx, sv.ny, sv.nz)), 
					transformUV(Vector2(sv.tu, sv.tv), options), Vector2(0.0f,0.0f),
					color, extra, Vector3());
			}
		}
		else
		{
			for (size_t i = 0; i < vertexCount; ++i)
			{
				Vertex& v = vertices[vertexOffset + i];
				const FileMeshVertexNormalTexture3d& sv = data->vnts[i];
				
                Vector3 pos;
                if (FFlag::FixMeshOffset)
                    pos = cframe.pointToWorldSpace(Vector3(sv.vx * scale.x, sv.vy * scale.y, sv.vz * scale.z) + offset);
                else
                    pos = cframe.pointToWorldSpace(Vector3(sv.vx * scale.x, sv.vy * scale.y, sv.vz * scale.z)) + offset;
				
				fillVertex(v, pos, cframe.vectorToWorldSpace(Vector3(sv.nx, sv.ny, sv.nz)), 
					transformUV(Vector2(sv.tu, sv.tv), options), Vector2(0.0f,0.0f), 
					color, extra, Vector3());
			}
		}
		
		if (vertexCount > 0)
		{
			AABox aabb = cframe.AABBtoWorldSpace(AABox(data->aabb.low() * scale + offset, data->aabb.high() * scale + offset));
					
			extendBounds(mBboxMin, mBboxMax, aabb.low());
			extendBounds(mBboxMin, mBboxMax, aabb.high());
		}
		
		unsigned short* indices = mIndices;
		
		for (size_t i = 0; i < faceCount; ++i)
		{
			indices[indexOffset + i * 3 + 0] = vertexOffset + data->faces[i].a;
			indices[indexOffset + i * 3 + 1] = vertexOffset + data->faces[i].b;
			indices[indexOffset + i * 3 + 2] = vertexOffset + data->faces[i].c;
		}
	}

	bool isPartSmooth(PartInstance* p)
	{
		for(unsigned normal = 0; normal < NORM_UNDEFINED; normal++)
			if(p->getSurfaceType((NormalId)normal) != NO_SURFACE)
				return false;

		return true;
	}

	Vector3 computeCylinderPosition(const Vector3& localUnitPos, const Vector3& size, float radius, Vector2& normal2d)
	{
		normal2d = Vector2(localUnitPos.y, localUnitPos.z);
		normal2d = normal2d.isZero() ? normal2d : normal2d.direction();
		Vector3 localPos = Vector3(localUnitPos.x*size.x/2.0f,normal2d.x*radius,normal2d.y*radius);
		return localPos;
	}


	template<bool vertical> void GeometryGenerator::addCylinder(const Vector3& size, const Vector3& center, PartInstance* part, Decal* decal, const Options& options, unsigned int randomSeed, bool ignoreMaterialsStuds)
	{
		size_t vertexOffset = mVertexCount;
		size_t indexOffset = mIndexCount;
		bool isSmooth = isPartSmooth(part) || ignoreMaterialsStuds;

		Vector3 genSize = vertical ? size.yxz() : size;

		float primaryDimension = std::min(genSize.y, genSize.z);

		float primaryDimensionStuds = std::min(primaryDimension, MAX_TESSELATION*(TESSELATION_PIECE-1));
		
		unsigned minimumTesselationFactor = 6;

		float quadNumberF = isSmooth ? 1 : ceil(primaryDimensionStuds / (TESSELATION_PIECE-1));

		unsigned quadNumberI = (unsigned)quadNumberF;
		
		if (quadNumberI == 0) return;
		
		unsigned tesselationPerQuad = (minimumTesselationFactor + quadNumberI - 1) / quadNumberI;
		float invTesselationFactor = 1.0f / (quadNumberF*tesselationPerQuad);
		unsigned tesselationFactor = quadNumberI*tesselationPerQuad;

		unsigned totalVerts = 4*quadNumberI*2*(tesselationPerQuad+1) + 2*(1 + (tesselationFactor+1)*4);
		unsigned quads = 4*tesselationFactor;
		unsigned tris = 4*tesselationFactor*2;

		if(decal) {
			if(verticalRotate<vertical>(decal->getFace()) % 3 == 0) {
				// Cap decal
				totalVerts = (1 + (tesselationFactor+1)*4);
				quads = 0;
				tris = 4*tesselationFactor;
			}
			else
			{
				// Side decal
				totalVerts = quadNumberI*2*(tesselationPerQuad+1);
				quads = tesselationFactor;
				tris = 0;
			}
		}

		mVertexCount += totalVerts;
		mIndexCount += quads*6 + tris*3;

		if (!mVertices) return;

		Color4uint8 color = getColor(part, decal, NULL, options, randomSeed, true);
		Color4uint8 extra = getExtra(part, options);

		float radius = primaryDimension/2;

		Vector3 axisX = Vector3(1.0f, 0.0f, 0.0f);
		Vector3 axisY = Vector3(0.0f, 1.0f, 0.0f);
		Vector3 axisZ = Vector3(0.0f, 0.0f, 1.0f);

		Vector3 worldAxisX = Vector3(options.cframe.rotation[0][0], options.cframe.rotation[1][0], options.cframe.rotation[2][0]);
		Vector3 worldAxisY = Vector3(options.cframe.rotation[0][1], options.cframe.rotation[1][1], options.cframe.rotation[2][1]);
		Vector3 worldAxisZ = Vector3(options.cframe.rotation[0][2], options.cframe.rotation[1][2], options.cframe.rotation[2][2]);

		Vector3 cornerO = -axisX - axisY - axisZ;
		Vector3 cornerX = axisX * 2;
		Vector3 cornerY = axisY * 2;
		Vector3 cornerZ = axisZ * 2;

		Vector2 surfaceOffset = decal ? Vector2() : getSurfaceOffset(genSize, randomSeed, part->getRenderMaterial());
        float surfaceTiling = decal ? 1 : getSurfaceTiling(part->getRenderMaterial());

		Vector3 corners[8] =
		{
			cornerO,
			cornerO + cornerZ,
			cornerO + cornerY,
			cornerO + cornerY + cornerZ,
			cornerO + cornerX,
			cornerO + cornerX + cornerZ,
			cornerO + cornerX + cornerY,
			cornerO + cornerX + cornerY + cornerZ,
		};

		Vector3 facesDirU[] =
		{
			-axisY,
			-axisZ,
			-axisY,
			-axisY,
			axisZ,
			-axisY
		};

		Vector3 facesDirV[] =
		{
			axisZ,
			axisX,
			-axisX,
			-axisZ,
			axisX,
			axisX
		};

		Vector3 tangents[6];
		
		if (vertical)
		{
			tangents[0] = worldAxisX;
			tangents[1] = worldAxisY;
			tangents[2] = -worldAxisY;
			tangents[3] = -worldAxisX;
			tangents[4] = worldAxisY;
			tangents[5] = worldAxisY;
		}
		else
		{
			tangents[0] = -worldAxisZ;
			tangents[1] = -worldAxisX;
			tangents[2] = worldAxisX;
			tangents[3] = worldAxisZ;
			tangents[4] = -worldAxisX;
			tangents[5] = -worldAxisX;
		}

		unsigned vertexCounter = 0;
		unsigned faceCounter = 0;
		Vertex* vertices = mVertices;
		unsigned short* indices = mIndices;

		struct CAPDESC
		{
			Vector3 start[4];
			Vector3 direction[4];
			Vector3 fanPoint;
			Vector2 normal2dToUV;
		};


		CAPDESC capsDesc[] = 
		{
			{
				{ corners[6], corners[4], corners[5], corners[7] },
				{ -axisY, axisZ, axisY, -axisZ },
				Vector3(1,0,0),
				Vector2(-1,-1),
			},
			{
				{ corners[3], corners[1], corners[0], corners[2] },
				{ -axisY, -axisZ, axisY, axisZ },
				Vector3(-1,0,0),
				Vector2(1,-1),
			}
		};

		static const FACEDESC facesDesc[] =
		{
			{ 6,7,4,5, false, true, }, // Face 0
			{ 3,7,2,6, true, false, }, // Face 1
			{ 7,3,5,1, false, false, }, // Face 2
			{ 3,2,1,0, false, true, }, // Face 3
			{ 0,4,1,5, true, false, }, // Face 4
			{ 2,6,0,4, false, false, }, // Face 5
		};

		float capRightOutlineOffset = (part->getConstPartPrimitive()->getSurfaceType(NORM_X) == NO_SURFACE_NO_OUTLINES) ? NO_OUTLINES : 0;
		float capLeftOutlineOffset = (part->getConstPartPrimitive()->getSurfaceType(NORM_X_NEG) == NO_SURFACE_NO_OUTLINES) ? NO_OUTLINES : 0;


		for (int face = 0; face < 6; ++face)
		{
			if(decal && verticalRotate<vertical>(decal->getFace()) != face)
				continue;

			// Caps
			if(face % 3 == 0)
			{
				const CAPDESC& capDesc = capsDesc[face == 0 ? 0 : 1];
				Vector3 fanPoint = capDesc.fanPoint;

				unsigned fanPointIndex = vertexOffset+vertexCounter;

				Vector2 mainMultiplier = decal ? getDecalUVVertical<vertical>(decal, genSize, ignoreMaterialsStuds) : Vector2(primaryDimension,primaryDimension);
				Vector2 normal2d;
				Vector3 localPos = computeCylinderPosition(fanPoint, genSize, radius, normal2d);
				Vector3 outPos = options.cframe.pointToWorldSpace(verticalRotate<vertical>(localPos) + center);
				Vector3 normal = options.cframe.vectorToWorldSpace(verticalRotate<vertical>(fanPoint));

				Vector2 mainUV = 0.5f * mainMultiplier;

				float outlineOffset = face == 0 ? capRightOutlineOffset : capLeftOutlineOffset;
				fillVertex(vertices[vertexOffset + vertexCounter], outPos, normal, (mainUV + surfaceOffset) * surfaceTiling, Vector2::zero(), 
					color, extra,
					tangents[face], Vector4(NO_OUTLINES,NO_OUTLINES, NO_OUTLINES, radius + outlineOffset));
				vertexCounter++;

				unsigned prevVertexCounter = vertexCounter;
				for(unsigned adjFace = 0; adjFace < 4; adjFace++)
				{
					Vector3 unitPos = capDesc.start[adjFace];
					Vector3 unitDirV = capDesc.direction[adjFace]*2*invTesselationFactor;
					for(unsigned tess = 0; tess < tesselationFactor+1; tess++) 
					{
						Vector2 normal2d;
						Vector3 localPos = computeCylinderPosition(unitPos, genSize, radius, normal2d);
						Vector3 outPos = options.cframe.pointToWorldSpace(verticalRotate<vertical>(localPos) + center);

						Vector2 mainUV = (verticalRotateDecal<vertical>(normal2d.yx())*capDesc.normal2dToUV +Vector2(1,1))*0.5f * mainMultiplier;

						Vector3 normal = options.cframe.vectorToWorldSpace(verticalRotate<vertical>(fanPoint));
						fillVertex(vertices[vertexOffset + vertexCounter], outPos, normal, (mainUV + surfaceOffset) * surfaceTiling, Vector2::zero(), 
							color, extra,
							tangents[face], Vector4(NO_OUTLINES,NO_OUTLINES, NO_OUTLINES, outlineOffset));

						vertexCounter++;
						unitPos += unitDirV;
					}
				}
				unsigned tessIndex = vertexOffset+prevVertexCounter;
				for(unsigned adjFace = 0; adjFace < 4; adjFace++)
				{
					for(unsigned tess = 0; tess < tesselationFactor; tess++)
					{
						indices[indexOffset + faceCounter*3] = fanPointIndex;
						indices[indexOffset + faceCounter*3+1] = tessIndex+tess+1;
						indices[indexOffset + faceCounter*3+2] = tessIndex+tess;
						faceCounter++;
					}
					tessIndex += tesselationFactor+1;
				}
			}
			else 
			{
				const FACEDESC& desc = facesDesc[face];

				Vector3 start0 = corners[desc.start0]; //, start1 = corners[desc.start1];

				Vector3 unitDirU = facesDirU[face] * invTesselationFactor * 2;
				Vector3 unitDirV = facesDirV[face] * 2;

				Vector3 unitPos = start0;

				UVAtlasInfo studsAtlasInfo = getStudsAtlasInfo((ignoreMaterialsStuds || (options.flags & Flag_IgnoreStuds)) ? NO_SURFACE : part->getConstPartPrimitive()->getSurfaceType((NormalId)face));

				float studOffsetU = studsAtlasInfo.tileX ? genSize.x / 2.0f : 0.0f;
				float studOffsetV = studsAtlasInfo.scaleY * primaryDimensionStuds * invTesselationFactor / TESSELATION_PIECE;

				Vector2 mainOffsetOrig = decal ? getDecalUVVertical<vertical>(decal, genSize, ignoreMaterialsStuds) : Vector2(genSize.x,primaryDimension);
				Vector2 mainCoords = Vector2(mainOffsetOrig.x,0.0f) + surfaceOffset;
				Vector2 mainOffset = mainOffsetOrig*Vector2(1,invTesselationFactor);

				for (unsigned quad = 0; quad < quadNumberI; quad++) {
					unsigned prevVertexCounter = vertexCounter;
					Vector2 studStart = Vector2(studOffsetU, studsAtlasInfo.offsetY + 
						frac(quad*primaryDimensionStuds / quadNumberF) / TESSELATION_PIECE * studsAtlasInfo.scaleY);

					// Generate vertices
					for(unsigned iU = 0; iU < tesselationPerQuad+1; iU++) 
					{
						Vector3 unitPosV = unitPos;
						Vector2 studsV = studStart;
						Vector2 mainCoordsV = mainCoords;

						for(unsigned iV = 0; iV < 2; iV++) 
						{
							Vector2 normal2d;
							Vector3 localPos = computeCylinderPosition(unitPosV, genSize, radius, normal2d);
							Vector3 outPos = options.cframe.pointToWorldSpace(verticalRotate<vertical>(localPos) + center);

							Vector3 worldNormal = options.cframe.vectorToWorldSpace(verticalRotate<vertical>(Vector3(0, normal2d.x, normal2d.y)));

							Vector2 mainUV = mainCoordsV;
							if(decal && vertical) {
								mainUV = Vector2(mainUV.y, mainOffsetOrig.y - mainUV.x);
							}
							Vector4 edgeDistances = Vector4(NO_OUTLINES,NO_OUTLINES, 
								capLeftOutlineOffset + (iV == 0 ? 0 : genSize.x), capRightOutlineOffset + (iV == 0 ? genSize.x : 0));

							fillVertex(vertices[vertexOffset + vertexCounter], outPos, worldNormal, mainUV * surfaceTiling, studsV, 
								color, extra,
								tangents[face], edgeDistances);

							vertexCounter++;
							unitPosV += unitDirV;
							studsV.x -= studOffsetU;
							mainCoordsV.x -= mainOffset.x;
						}
						if(iU < tesselationPerQuad) {
							unitPos += unitDirU;
							mainCoords.y += mainOffset.y;
						}

						studStart.y += studOffsetV;
					}

					// Generate faces
					for(unsigned iU = 0; iU < tesselationPerQuad; iU++) 
					{
						fillQuadIndices(&indices[indexOffset + faceCounter*3], vertexOffset + prevVertexCounter, 
							iU*2, 
							iU*2+1,
							(iU+1)*2,
							(iU+1)*2+1);
						faceCounter+=2;
					}
				}
			}
		}

		RBXASSERT(faceCounter == 2*quads+tris);
		RBXASSERT(vertexCounter == totalVerts);

		Vector3 boundsCenter = options.cframe.pointToWorldSpace(center);
		extendBoundsBlock(mBboxMin, mBboxMax, boundsCenter, size, worldAxisX, worldAxisY, worldAxisZ);
	}

	void GeometryGenerator::addSphere(const Vector3& size, const Vector3& center, PartInstance* part, Decal* decal, const Options& options, unsigned int randomSeed, bool ignoreMaterialsStuds) 
	{
		size_t vertexOffset = mVertexCount;
		size_t indexOffset = mIndexCount;

		bool isSmooth = isPartSmooth(part) || ignoreMaterialsStuds;

		float primaryDimension = size.min();
		float primaryDimensionStuds = std::min(primaryDimension, MAX_TESSELATION*(TESSELATION_PIECE-1));

		unsigned minimumTesselationFactor = 6;
		float quadNumberF = isSmooth ? 1 : ceil(primaryDimensionStuds / (TESSELATION_PIECE-1));

		unsigned quadNumberI = (unsigned)quadNumberF;

		if (quadNumberI == 0) return;
		
		unsigned tesselationPerQuad = (minimumTesselationFactor + quadNumberI - 1) / quadNumberI;
		float invTesselationFactor = 1.0f / (quadNumberF*tesselationPerQuad);
		unsigned tesselationFactor = quadNumberI*tesselationPerQuad;

		unsigned totalVerts = quadNumberI*(tesselationFactor+1)*(tesselationPerQuad+1);
		unsigned quads = tesselationFactor*tesselationFactor;

		if(!decal)
		{
			totalVerts *= 6;
			quads *= 6;
		}

		mVertexCount += totalVerts;
		mIndexCount += quads*6;

		if (!mVertices) return;

		Color4uint8 color = getColor(part, decal, NULL, options, randomSeed, true);
		Color4uint8 extra = getExtra(part, options);

		float radius = primaryDimension/2;

		static const Vector3 axisX = Vector3(1.0f, 0.0f, 0.0f);
		static const Vector3 axisY = Vector3(0.0f, 1.0f, 0.0f);
		static const Vector3 axisZ = Vector3(0.0f, 0.0f, 1.0f);

		static const Vector3 cornerO = -axisX - axisY - axisZ;
		static const Vector3 cornerX = axisX * 2;
		static const Vector3 cornerY = axisY * 2;
		static const Vector3 cornerZ = axisZ * 2;

		static const Vector3 corners[8] =
		{
			cornerO,
			cornerO + cornerZ,
			cornerO + cornerY,
			cornerO + cornerY + cornerZ,
			cornerO + cornerX,
			cornerO + cornerX + cornerZ,
			cornerO + cornerX + cornerY,
			cornerO + cornerX + cornerY + cornerZ,
		};

		static const Vector3 facesDirU[] =
		{
			-axisY,
			-axisZ,
			-axisY,
			-axisY,
			axisZ,
			-axisY
		};

		static const Vector3 facesDirV[] =
		{
			axisZ,
			axisX,
			-axisX,
			-axisZ,
			axisX,
			axisX
		};

		Vector3 worldAxisX = Vector3(options.cframe.rotation[0][0], options.cframe.rotation[1][0], options.cframe.rotation[2][0]);
		Vector3 worldAxisY = Vector3(options.cframe.rotation[0][1], options.cframe.rotation[1][1], options.cframe.rotation[2][1]);
		Vector3 worldAxisZ = Vector3(options.cframe.rotation[0][2], options.cframe.rotation[1][2], options.cframe.rotation[2][2]);

		Vector2 surfaceOffset = decal ? Vector2() : getSurfaceOffset(size, randomSeed, part->getRenderMaterial());
        float surfaceTiling = decal ? 1 : getSurfaceTiling(part->getRenderMaterial());

		Vector3 tangents[] =
		{
			worldAxisZ,
			worldAxisX,
			-worldAxisX,
			-worldAxisZ,
			worldAxisX,
			worldAxisX
		};

		static const FACEDESC facesDesc[] =
		{
			{ 6,7,4,5, false, true, }, // Face 0
			{ 3,7,2,6, true, false, }, // Face 1
			{ 7,3,5,1, false, false, }, // Face 2
			{ 3,2,1,0, false, true, }, // Face 3
			{ 0,4,1,5, true, false, }, // Face 4
			{ 2,6,0,4, false, false, }, // Face 5
		};

		unsigned faceCounter = 0;
		Vertex* vertices = mVertices;
		unsigned short* indices = mIndices;
		Vector3 scale = size * (radius / primaryDimension);

		unsigned vertexCounter = 0;
		for (int face = 0; face < 6; ++face)
		{
			if(decal && decal->getFace() != face)
				continue;

			const FACEDESC& desc = facesDesc[face];
			Vector3 start0 = corners[desc.start0]; //, start1 = corners[desc.start1];

			Vector3 worldDirU = facesDirU[face] * invTesselationFactor * 2;
			Vector3 worldDirV = facesDirV[face] * invTesselationFactor * 2;

			Vector3 worldPos = start0;

			UVAtlasInfo studsAtlasInfo = getStudsAtlasInfo((ignoreMaterialsStuds || (options.flags & Flag_IgnoreStuds)) ? NO_SURFACE : part->getConstPartPrimitive()->getSurfaceType((NormalId)face));

			float studOffsetU = studsAtlasInfo.tileX ? primaryDimensionStuds * invTesselationFactor / 2.0f : 0.0f;
			float studOffsetV = studsAtlasInfo.scaleY * primaryDimensionStuds * invTesselationFactor / TESSELATION_PIECE;

			Vector2 mainOffset = decal ? getDecalUV(decal, size, ignoreMaterialsStuds) : abs(Vector2(dot(facesDirV[face], size),dot(facesDirU[face], size)));
			Vector2 mainCoords = surfaceOffset + Vector2(mainOffset.x, 0);
			mainOffset *= invTesselationFactor;
			
			for (unsigned quad = 0; quad < quadNumberI; quad++) {
				unsigned prevVertexCounter = vertexCounter;
				Vector2 studStart = Vector2(studOffsetU * tesselationPerQuad, studsAtlasInfo.offsetY + 
					frac(quad*primaryDimensionStuds / quadNumberF) / TESSELATION_PIECE * studsAtlasInfo.scaleY);

				// Generate vertices
				for(unsigned iU = 0; iU < tesselationPerQuad+1; iU++) 
				{
					Vector3 worlsPosV = worldPos;
					Vector2 studsV = studStart;
					Vector2 mainCoordsV = mainCoords;

					for(unsigned iV = 0; iV < tesselationFactor+1; iV++) 
					{
						Vector3 normal = worlsPosV.direction();
						Vector3 localPos = scale*normal;

						Vector3 worldOffset = options.cframe.vectorToWorldSpace(localPos);
						Vector3 worldNormal = worldOffset.direction();

						Vector3 tangent = (worldNormal*dot(tangents[face],worldNormal) - tangents[face]).direction();
						
						fillVertex(vertices[vertexOffset + vertexCounter], options.cframe.translation + worldOffset + center, worldNormal, 
							mainCoordsV * surfaceTiling, studsV, 
							color, extra, tangent);
						vertexCounter++;
						worlsPosV += worldDirV;
						studsV.x -= studOffsetU;
						mainCoordsV.x -= mainOffset.x;
					}
					if(iU < tesselationPerQuad) {
						worldPos += worldDirU;
						mainCoords.y += mainOffset.y;
					}

					studStart.y += studOffsetV;
				}

				// Generate faces
				for(unsigned iU = 0; iU < tesselationPerQuad; iU++) 
				{
					for(unsigned iV = 0; iV < tesselationFactor; iV++) 
					{
						fillQuadIndices(&indices[indexOffset + faceCounter*6], vertexOffset + prevVertexCounter, 
							iU*(tesselationFactor+1)+iV, 
							iU*(tesselationFactor+1)+iV+1,
							(iU+1)*(tesselationFactor+1)+iV,
							(iU+1)*(tesselationFactor+1)+iV+1);
						faceCounter++;
					}
				}
			}
		}

		RBXASSERT(faceCounter == quads);
		RBXASSERT(vertexCounter == totalVerts);

		extendBoundsBlock(mBboxMin, mBboxMax, options.cframe.translation + center, size, worldAxisX, worldAxisY, worldAxisZ);
	}

	template<bool corner> void GeometryGenerator::addWedge(const Vector3& size, const Vector3& center, PartInstance* part, Decal* decal, const Options& options, unsigned int randomSeed, bool ignoreMaterialsStuds)
	{
		size_t vertexOffset = mVertexCount;
		size_t indexOffset = mIndexCount;
	
		bool facesIgnoreTiling[NORM_UNDEFINED] = { 0 };
		Vector3 localExtentsSize = size;

		float wedgeFaceLength[6];

		if (!corner) {
			float diagLenZY = sqrt(size.y*size.y+size.z*size.z);
			wedgeFaceLength[0] = size.y;
			wedgeFaceLength[1] = size.z;
			wedgeFaceLength[2] = size.y;
			wedgeFaceLength[3] = size.y;
			wedgeFaceLength[4] = size.z;
			wedgeFaceLength[5] = diagLenZY;
		}
		else 
		{
			float diagLenXY = sqrt(size.y*size.y+size.x*size.x);
			float diagLenZY = sqrt(size.y*size.y+size.z*size.z);
			wedgeFaceLength[0] = size.y;
			wedgeFaceLength[1] = size.z;
			wedgeFaceLength[2] = diagLenZY;
			wedgeFaceLength[3] = diagLenXY;
			wedgeFaceLength[4] = size.z;
			wedgeFaceLength[5] = size.y;
		}

		bool noBlanks = true;

		unsigned quads = 1;
		if(!decal) 
		{
			quads = 0;
			for (int face = 0; face < NORM_UNDEFINED; face++)
			{
				SurfaceType surface = part->getConstPartPrimitive()->getSurfaceType((NormalId)face);
				if(surface == NO_SURFACE_NO_OUTLINES)
					noBlanks = false;

				if(face == NORM_Y)
					continue;

				facesIgnoreTiling[face] = IsNoSurface(surface) || ignoreMaterialsStuds;
				if(facesIgnoreTiling[face])
					quads += 1;
				else
				{
					quads += fastCeilPositiveApprox(wedgeFaceLength[face] / TESSELATION_PIECE);
				}
			}
		}
		
		if (quads > 32768 / 4)
		{
			// We do not allow a part to generate more than 32768 vertices
			// This is both to ensure that we never exceed 16-bit index limit even if we had some vertices before, and to avoid potential issues with negative size components
			RBXASSERT(false);
			return;
		}
		
		mVertexCount += quads*4;
		mIndexCount += quads*6;
		
		if (!mVertices) return;

		Color4uint8 color = getColor(part, decal, NULL, options, randomSeed, true);
		Color4uint8 extra = getExtra(part, options);
		
		const CoordinateFrame& cframe = options.cframe;
		
		Vector3 axisX = Vector3(cframe.rotation[0][0], cframe.rotation[1][0], cframe.rotation[2][0]);
		Vector3 axisY = Vector3(cframe.rotation[0][1], cframe.rotation[1][1], cframe.rotation[2][1]);
		Vector3 axisZ = Vector3(cframe.rotation[0][2], cframe.rotation[1][2], cframe.rotation[2][2]);
		
		Vector3 extent = size * 0.5f;
		
		Vector3 cornerO = cframe.pointToWorldSpace(Vector3(center - extent));
		Vector3 cornerX = axisX * size.x;
		Vector3 cornerY = axisY * size.y;
		Vector3 cornerZ = axisZ * size.z;
		
		Vector3 corners[8] =
		{
			cornerO,
			cornerO + cornerZ,
			cornerO + cornerY,
			cornerO + cornerY + cornerZ,
			cornerO + cornerX,
			cornerO + cornerX + cornerZ,
			cornerO + cornerX + cornerY,
			cornerO + cornerX + cornerY + cornerZ,
		};

		float zyProportion = size.z/size.y;
		float xyProportion = size.x/size.y;
		Vector3 adjustedAxisZ = axisZ*zyProportion;
		Vector3 adjustedAxisX = axisX*xyProportion;

		Vector2 surfaceOffset = getSurfaceOffset(size, randomSeed, part->getRenderMaterial());
        float surfaceTiling = decal ? 1 : getSurfaceTiling(part->getRenderMaterial());
			
		Vector3 normalOffset =
			(options.flags & Flag_RandomizeBlockAppearance)
				? kNormalOffsetTable[(randomSeed >> 3) & 31]
				: Vector3(0, 0, 0);
		
		Vector3 normals[6];
		if(!corner) 
		{
			normals[0] = normalize(normalOffset + axisX);
			normals[1] = normalize(normalOffset + axisY);
			normals[2] = normalize(normalOffset + axisZ);
			normals[3] = normalize(normalOffset - axisX);
			normals[4] = normalize(normalOffset - axisY);
			normals[5] = normalize(normalOffset - axisZ + axisY*zyProportion);
		} 
		else
		{
			Vector3 diag = -size.x*axisX - size.y*axisY + size.z*axisZ;
			Vector3 zside = -size.y*axisY + size.z*axisZ;
			Vector3 xside = -size.x*axisX - size.y*axisY;
			normals[0] = normalize(normalOffset + axisX);
			normals[1] = normalize(normalOffset + axisY);
			normals[2] = normalize(normalOffset + diag.cross(zside));
			normals[3] = normalize(normalOffset + xside.cross(diag));
			normals[4] = normalize(normalOffset - axisY);
			normals[5] = normalize(normalOffset - axisZ);
		}
		
		Vector3 tangents[6] =
		{
			-axisZ, -axisX,  axisX,
			 axisZ, -axisX, -axisX,
		};
		
		Vertex* vertices = mVertices;
		unsigned short* indices = mIndices;

		if (decal)
		{
			// Note: this table is almost identical to the facesDesc below, with the exception of bottom face.
			// This is needed to preserve the decal orientation compared to legacy code.
			static const unsigned int wedgeFaces[6][4] =
			{
				{7, 7, 4, 5}, // Face 0 +X
				{3, 7, 0, 4}, // Face 1 +Y
				{7, 3, 5, 1}, // Face 2 +Z
				{3, 3, 1, 0}, // Face 3 -X
				{5, 1, 4, 0}, // Face 4 -Y
				{3, 7, 0, 4}, // Face 5 -Z
			};

            static const unsigned int cornerWedgeFaces[6][4] =
            {
                { 6,6,4,5}, // Face 0 +X
                { 0,1,6,5}, // Face 1 +Y
                { 6,6,5,1}, // Face 2 +Z
                { 6,6,1,0}, // Face 3 -X
                { 5,1,4,0}, // Face 4 -Y
                { 6,6,0,4}, // Face 5 -Z
            };

            const unsigned int (*faces)[4] = corner ? cornerWedgeFaces : wedgeFaces;
			
			int face = decal->getFace();
			
			// If the block ignores studs (block meshes), then the Texture UV generation should not take size into account as well.
			Vector2 uv = getDecalUV(decal, size, /* ignoreSurfaceType= */ ignoreMaterialsStuds);

            Vector2 outUvs[4];
            if (corner && face == NORM_Y)
            {
                // when projecting from top to corner wedge, make decal to "stand" on base part
                outUvs[3] = Vector2(uv.x, uv.y);
                outUvs[2] = Vector2(uv.x, 0);
                outUvs[1] = Vector2(0, uv.y);
                outUvs[0] = Vector2(0, 0);
            }
            else
            {
                outUvs[0] = Vector2(uv.x, 0);
                outUvs[1] = Vector2(0, 0);
                outUvs[2] = Vector2(uv.x, uv.y);
                outUvs[3] = Vector2(0, uv.y);
            }

            if(!corner)
            {
                if(face == NORM_X_NEG) // Fix for wedges
                    outUvs[1] = outUvs[0];
            }
            else
            {
                if(face == NORM_X || face == NORM_Z) // Fix for triangular part of corner wedge part
                    outUvs[1] = outUvs[0];
            }
            
			fillVertex(vertices[vertexOffset + 0], corners[faces[face][0]], normals[face], outUvs[0], Vector2(), color, extra, Vector3());
			fillVertex(vertices[vertexOffset + 1], corners[faces[face][1]], normals[face], outUvs[1], Vector2(), color, extra, Vector3());
			fillVertex(vertices[vertexOffset + 2], corners[faces[face][2]], normals[face], outUvs[2], Vector2(), color, extra, Vector3());
			fillVertex(vertices[vertexOffset + 3], corners[faces[face][3]], normals[face], outUvs[3], Vector2(), color, extra, Vector3());
			
			fillQuadIndices(&indices[indexOffset], vertexOffset, 0, 1, 2, 3);
										
			for (int i = 0; i < 4; ++i)
				extendBounds(mBboxMin, mBboxMax, corners[faces[face][i]]);
		}
		else
		{
			struct WEDGESTEPDESC
			{
				Vector3 faceDir0, faceDir1;
				float studOffset0, studOffset1;

				inline WEDGESTEPDESC(const Vector3& faceDir0, const Vector3& faceDir1, float studOffset0, float studOffset1)
				    : faceDir0(faceDir0), faceDir1(faceDir1), studOffset0(studOffset0), studOffset1(studOffset1)
				{}

				inline WEDGESTEPDESC()
				{}
			};

			WEDGESTEPDESC wedgeStepDesc[6];

			if(!corner)
			{
				Vector3 wedgeDirection = (-axisY*size.y - axisZ*size.z).direction();;

				wedgeStepDesc[0] = WEDGESTEPDESC(-axisY-adjustedAxisZ,	-axisY, zyProportion, 0.0f);
				wedgeStepDesc[1] = WEDGESTEPDESC(Vector3(0,0,0), Vector3(0,0,0), 0.0f, 0.0f);
				wedgeStepDesc[2] = WEDGESTEPDESC(-axisY, -axisY, 0.0f, 0.0f);
				wedgeStepDesc[3] = WEDGESTEPDESC(-axisY,-axisY-adjustedAxisZ, 0.0f,  zyProportion);
				wedgeStepDesc[4] = WEDGESTEPDESC(axisZ, axisZ, 0.0f, 0.0f);
				wedgeStepDesc[5] = WEDGESTEPDESC(wedgeDirection, wedgeDirection, 0.0f, 0.0f);
			}
			else
			{
				Vector3 sideZDirection = (-size.y*axisY + size.z*axisZ).direction();
				Vector3 sideXDirection = (-size.x*axisX - size.y*axisY).direction();
				float xAspect = size.x/wedgeFaceLength[2];
				float zAspect = size.z/wedgeFaceLength[3];

				wedgeStepDesc[0] = WEDGESTEPDESC(-axisY, -axisY+adjustedAxisZ, 0.0f, zyProportion);
				wedgeStepDesc[1] = WEDGESTEPDESC(Vector3(0,0,0), Vector3(0,0,0), 0.0f, 0.0f);
				wedgeStepDesc[2] = WEDGESTEPDESC(sideZDirection, sideZDirection-axisX*xAspect, 0.0f, xAspect);
				wedgeStepDesc[3] = WEDGESTEPDESC(sideXDirection+axisZ*zAspect, sideXDirection, zAspect,  0.0f);
				wedgeStepDesc[4] = WEDGESTEPDESC(axisZ, axisZ, 0.0f, 0.0f);
				wedgeStepDesc[5] = WEDGESTEPDESC(-axisY -adjustedAxisX, -axisY, xyProportion, 0.0f);
			}

			static const FACEDESC wedgeFacesDesc[] =
			{
				{ 7,7,4,5, false, true, }, // Face 0
				{ 3,7,3,7, true, false, }, // Face 1
				{ 7,3,5,1, false, false, }, // Face 2
				{ 3,3,1,0, false, true, }, // Face 3
				{ 0,4,1,5, true, false, }, // Face 4
				{ 3,7,0,4, false, false, }, // Face 5
			};

			static const FACEDESC cornerWedgeFacesDesc[] =
			{
				{ 6,6,4,5, false, true, }, // Face 0
				{ 6,6,6,6, true, false, }, // Face 1
				{ 6,6,5,1, false, false, }, // Face 2
				{ 6,6,1,0, false, true, }, // Face 3
				{ 0,4,1,5, true, false, }, // Face 4
				{ 6,6,0,4, false, false, }, // Face 5
			};

			const FACEDESC* facesDesc = corner ? cornerWedgeFacesDesc : wedgeFacesDesc;


			unsigned faceCounter = 0;

			Vector2 uvs[4];

			for (int face = 0; face < ARRAYSIZE(wedgeFacesDesc); ++face)
			{
				if(face == NORM_Y) // Wedge only
					continue;

				const FACEDESC& desc = facesDesc[face];
				const WEDGESTEPDESC& wdesc = wedgeStepDesc[face];

				Vector3 start0 = corners[desc.start0], start1 = corners[desc.start1];

				int quadNumber = fastCeilPositiveApprox(wedgeFaceLength[face] / TESSELATION_PIECE);
				float quadLength = wedgeFaceLength[face];

				if(facesIgnoreTiling[face])
					quadNumber = 1;

				Vector3 offset0 = Vector3::zero(),offset1 = Vector3::zero();

				float uTiling = (desc.tangentZ ? localExtentsSize.z : localExtentsSize.x);

				uvs[0] = surfaceOffset;
				uvs[0].x += uTiling;
				uvs[1] = surfaceOffset;
				uvs[2] = surfaceOffset;
				uvs[2].x += uTiling;
				uvs[2].y += TESSELATION_PIECE;
				uvs[3] = surfaceOffset;
				uvs[3].y += TESSELATION_PIECE;
				
				UVAtlasInfo studsAtlasInfo = getStudsAtlasInfo((ignoreMaterialsStuds || (options.flags & Flag_IgnoreStuds)) ? NO_SURFACE : part->getConstPartPrimitive()->getSurfaceType((NormalId)face));
				
				float uTilingStuds = studsAtlasInfo.tileX ? uTiling * 0.5f : 0;
                float uStudsIncrement = studsAtlasInfo.tileX ? TESSELATION_PIECE * 0.5f : 0;

				Vector2 uvStuds[4] =
				{
					Vector2(uTilingStuds, studsAtlasInfo.offsetY),
					Vector2(0, studsAtlasInfo.offsetY),
					Vector2(uTilingStuds, studsAtlasInfo.offsetY + studsAtlasInfo.scaleY),
					Vector2(0, studsAtlasInfo.offsetY + studsAtlasInfo.scaleY),
				};

				Vector4 startEdgeOffset = Vector4::zero();
				if(!noBlanks)
				{
					if(corner)
						startEdgeOffset =computeOutlineOffsetCornerWedge((NormalId)face, part);
					else
						startEdgeOffset =computeOutlineOffsetWedge((NormalId)face, part);
				}

				Vector4 edge0 = Vector4(0,uTiling,0,quadLength) + startEdgeOffset;
				Vector4 edge1 = Vector4(uTiling,0,0,quadLength) + startEdgeOffset;

				if(wdesc.studOffset1 != 0) {
					uvStuds[1].x = uTilingStuds;
					uvStuds[3].x = uTilingStuds;
					uvs[1].x = uvs[0].x;
					uvs[3].x = uvs[2].x;
					edge1.x = edge0.x;
					edge0.y = edge1.y;
				}
				if(wdesc.studOffset0 != 0) {
					uvStuds[0].x = 0;
					uvStuds[2].x = 0;
					uvs[0].x = uvs[1].x;
					uvs[2].x = uvs[3].x;
					edge1.x = edge0.x;
					edge0.y = edge1.y;
				}

				Vector3 worldDir0 = wdesc.faceDir0 * TESSELATION_PIECE;
				Vector3 worldDir1 = wdesc.faceDir1 * TESSELATION_PIECE;

				for (int quad = 0; quad < quadNumber - 1; quad++)
				{
					Vector3 nextOffset0 = offset0 + worldDir0;
					Vector3 nextOffset1 = offset1 + worldDir1;

					Vector4 nextEdge0 = edge0 + Vector4(0,0,TESSELATION_PIECE, -TESSELATION_PIECE);
					Vector4 nextEdge1 = edge1 + Vector4(0,0,TESSELATION_PIECE, -TESSELATION_PIECE);

					if(wdesc.studOffset1 != 0) {
						uvStuds[3].x -= wdesc.studOffset1*uStudsIncrement;
						uvs[3].x -= wdesc.studOffset1*TESSELATION_PIECE;
						nextEdge0.y += wdesc.studOffset1*TESSELATION_PIECE;
						nextEdge1.x += wdesc.studOffset1*TESSELATION_PIECE;
					}

					if(wdesc.studOffset0 != 0) {
						uvStuds[2].x += wdesc.studOffset0*uStudsIncrement;
						uvs[2].x += wdesc.studOffset0*TESSELATION_PIECE;

						nextEdge0.x += wdesc.studOffset0*TESSELATION_PIECE;
						nextEdge1.y += wdesc.studOffset0*TESSELATION_PIECE;
					}
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 0], start0 + offset0, normals[face], uvs[0] * surfaceTiling, uvStuds[0], color, extra, tangents[face], edge0);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 1], start1 + offset1, normals[face], uvs[1] * surfaceTiling, uvStuds[1], color, extra, tangents[face], edge1);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 2], start0 + nextOffset0, normals[face], uvs[2] * surfaceTiling, uvStuds[2], color, extra, tangents[face], nextEdge0);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 3], start1 + nextOffset1, normals[face], uvs[3] * surfaceTiling, uvStuds[3], color, extra, tangents[face], nextEdge1);
				
					uvs[0].y = uvs[2].y;
					uvs[1].y = uvs[3].y;
					uvs[2].y += TESSELATION_PIECE;
					uvs[3].y += TESSELATION_PIECE;

					if(wdesc.studOffset1 != 0) {
						uvStuds[1].x = uvStuds[3].x;
						uvs[1].x = uvs[3].x;
					}
				
					if(wdesc.studOffset0 != 0) {
						uvStuds[0].x = uvStuds[2].x;
						uvs[0].x = uvs[2].x;
					}

					offset0 = nextOffset0;
					offset1 = nextOffset1;
					edge0 = nextEdge0;
					edge1 = nextEdge1;
					
					fillQuadIndices(&indices[indexOffset + faceCounter * 6], vertexOffset + faceCounter * 4, 0, 1, 2, 3);
					faceCounter++;
				}
				
				if (quadNumber > 0)
				{
					// Last quad
					float texRemainderFraction = wedgeFaceLength[face] - (quadNumber - 1)*TESSELATION_PIECE;
					float texMultiplier = saturate(texRemainderFraction / TESSELATION_PIECE);

					Vector4 nextEdge0 = edge0 + Vector4(0,0,texRemainderFraction, -texRemainderFraction);
					Vector4 nextEdge1 = edge1 + Vector4(0,0,texRemainderFraction, -texRemainderFraction);

					if(wdesc.studOffset1 != 0) {
						uvStuds[3].x -= wdesc.studOffset1*texMultiplier*uStudsIncrement;
						uvs[3].x -= wdesc.studOffset1*texRemainderFraction;

						nextEdge0.y += wdesc.studOffset1*texRemainderFraction;
						nextEdge1.x += wdesc.studOffset1*texRemainderFraction;

					}

					if(wdesc.studOffset0 != 0) {
						uvStuds[2].x += wdesc.studOffset0*texMultiplier*uStudsIncrement;
						uvs[2].x += wdesc.studOffset0*texRemainderFraction;

						nextEdge0.x += wdesc.studOffset0*texRemainderFraction;
						nextEdge1.y += wdesc.studOffset0*texRemainderFraction;
					}

					Vector2 uv2 = Vector2(uvs[2].x, uvs[0].y + texRemainderFraction);
					Vector2 uv3 = Vector2(uvs[3].x, uvs[1].y + texRemainderFraction);

					Vector2 uvStuds2 = Vector2(uvStuds[2].x, studsAtlasInfo.offsetY + texMultiplier * studsAtlasInfo.scaleY);
					Vector2 uvStuds3 = Vector2(uvStuds[3].x, studsAtlasInfo.offsetY + texMultiplier * studsAtlasInfo.scaleY);

					fillVertex(vertices[vertexOffset + faceCounter * 4 + 0], start0 + offset0, normals[face], uvs[0] * surfaceTiling, uvStuds[0], color, extra, tangents[face], edge0);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 1], start1 + offset1, normals[face], uvs[1] * surfaceTiling, uvStuds[1], color, extra, tangents[face], edge1);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 2], corners[desc.end0], normals[face], uv2 * surfaceTiling, uvStuds2, color, extra, tangents[face], nextEdge0);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 3], corners[desc.end1], normals[face], uv3 * surfaceTiling, uvStuds3, color, extra, tangents[face], nextEdge1);
					
					fillQuadIndices(&indices[indexOffset + faceCounter * 6], vertexOffset + faceCounter * 4, 0, 1, 2, 3);
					faceCounter++;
				}
			}
			
			RBXASSERT(faceCounter == quads);
			
			Vector3 boundsCenter = cframe.pointToWorldSpace(center);
			extendBoundsBlock(mBboxMin, mBboxMax, boundsCenter, size, axisX, axisY, axisZ);
		}
	}

	void GeometryGenerator::addBlock(const Vector3& size, const Vector3& center, PartInstance* part, Decal* decal, const Options& options, unsigned int randomSeed, bool ignoreMaterialsStuds)
	{
		size_t vertexOffset = mVertexCount;
		size_t indexOffset = mIndexCount;
	
		bool facesIgnoreTiling[NORM_UNDEFINED] = { 0 };
		Vector3 localExtentsSize = size;
		Vector3int16 tesselatedExtents = Vector3CeilPositiveApprox(localExtentsSize / TESSELATION_PIECE);

		static const FACEDESC facesDesc[] =
		{
			{ 6,7,4,5, false, true, }, // Face 0
			{ 3,7,2,6, true, false, }, // Face 1
			{ 7,3,5,1, false, false, }, // Face 2
			{ 3,2,1,0, false, true, }, // Face 3
			{ 0,4,1,5, true, false, }, // Face 4
			{ 2,6,0,4, false, false, }, // Face 5
		};

		unsigned quads = 1;
		bool noBlanks = true;

		if(!decal) 
		{
			quads = 0;

			for (int face = 0; face < NORM_UNDEFINED; face++)
			{
				SurfaceType surface = part->getConstPartPrimitive()->getSurfaceType((NormalId)face);

				facesIgnoreTiling[face] = IsNoSurface(surface) || ignoreMaterialsStuds;
				if(facesIgnoreTiling[face])
					quads += 1;
				else
				{
					const FACEDESC& desc = facesDesc[face];
					quads += desc.dirZ ? tesselatedExtents.z : tesselatedExtents.y;
				}

				if(surface == NO_SURFACE_NO_OUTLINES)
					noBlanks = false;
			}
		}

		if (quads > 32768 / 4)
		{
			// We do not allow a part to generate more than 32768 vertices
			// This is both to ensure that we never exceed 16-bit index limit even if we had some vertices before, and to avoid potential issues with negative size components
			RBXASSERT(false);
			return;
		}
		
		mVertexCount += quads*4;
		mIndexCount += quads*6;
		
		if (!mVertices) return;

		Color4uint8 color = getColor(part, decal, NULL, options, randomSeed, true);
		Color4uint8 extra = getExtra(part, options);
		
		const CoordinateFrame& cframe = options.cframe;
		
		Vector3 axisX = Vector3(cframe.rotation[0][0], cframe.rotation[1][0], cframe.rotation[2][0]);
		Vector3 axisY = Vector3(cframe.rotation[0][1], cframe.rotation[1][1], cframe.rotation[2][1]);
		Vector3 axisZ = Vector3(cframe.rotation[0][2], cframe.rotation[1][2], cframe.rotation[2][2]);
		
		Vector3 extent = size * 0.5f;
		
		Vector3 cornerO = cframe.pointToWorldSpace(Vector3(center - extent));
		Vector3 cornerX = axisX * size.x;
		Vector3 cornerY = axisY * size.y;
		Vector3 cornerZ = axisZ * size.z;
		
		Vector3 corners[8] =
		{
			cornerO,
			cornerO + cornerZ,
			cornerO + cornerY,
			cornerO + cornerY + cornerZ,
			cornerO + cornerX,
			cornerO + cornerX + cornerZ,
			cornerO + cornerX + cornerY,
			cornerO + cornerX + cornerY + cornerZ,
		};

		Vector2 surfaceOffset = getSurfaceOffset(size, randomSeed, part->getRenderMaterial());
        float surfaceTiling = decal ? 1 : getSurfaceTiling(part->getRenderMaterial());
			
		Vector3 normalOffset =
			(options.flags & Flag_RandomizeBlockAppearance)
				? kNormalOffsetTable[(randomSeed >> 3) & 31]
				: Vector3(0, 0, 0);
		
		Vector3 normals[6] =
		{
			 normalize(normalOffset + axisX), normalize(normalOffset + axisY), normalize(normalOffset + axisZ),
			 normalize(normalOffset - axisX), normalize(normalOffset - axisY), normalize(normalOffset - axisZ),
		};
		
		Vector3 tangents[6] =
		{
			-axisZ, -axisX,  axisX,
			 axisZ, -axisX, -axisX,
		};
		
		Vertex* vertices = mVertices;
		unsigned short* indices = mIndices;

		if (decal)
		{
			// Note: this table is almost identical to the facesDesc below, with the exception of bottom face.
			// This is needed to preserve the decal orientation compared to legacy code.
			static const unsigned int faces[6][4] =
			{
				{6, 7, 4, 5},
				{3, 7, 2, 6},
				{7, 3, 5, 1},
				{3, 2, 1, 0},
				{5, 1, 4, 0},
				{2, 6, 0, 4},
			};
			
			int face = decal->getFace();
			
			// If the block ignores studs (block meshes), then the Texture UV generation should not take size into account as well.
			Vector2 uv = getDecalUV(decal, size, /* ignoreSurfaceType= */ ignoreMaterialsStuds);
			
			fillVertex(vertices[vertexOffset + 0], corners[faces[face][0]], normals[face], Vector2(uv.x, 0), Vector2(), color, extra, Vector3());
			fillVertex(vertices[vertexOffset + 1], corners[faces[face][1]], normals[face], Vector2(0, 0), Vector2(), color, extra, Vector3());
			fillVertex(vertices[vertexOffset + 2], corners[faces[face][2]], normals[face], Vector2(uv.x, uv.y), Vector2(), color, extra, Vector3());
			fillVertex(vertices[vertexOffset + 3], corners[faces[face][3]], normals[face], Vector2(0, uv.y), Vector2(), color, extra, Vector3());
			
			fillQuadIndices(&indices[indexOffset], vertexOffset, 0, 1, 2, 3);
										
			for (int i = 0; i < 4; ++i)
				extendBounds(mBboxMin, mBboxMax, corners[faces[face][i]]);
		}
		else
		{
			Vector3 facesDir[] =
			{
				-axisY,
				-axisZ,
				-axisY,
				-axisY,
				axisZ,
				-axisY
			};

			unsigned faceCounter = 0;
	 
			Vector2 uvs[4];

			for (int face = 0; face < ARRAYSIZE(facesDesc); ++face)
			{
				const FACEDESC& desc = facesDesc[face];
				
				Vector3 start0 = corners[desc.start0], start1 = corners[desc.start1];
				int quadNumber = desc.dirZ ? tesselatedExtents.z : tesselatedExtents.y;

				float quadLength = desc.dirZ ? size.z : size.y;

				if(facesIgnoreTiling[face])
					quadNumber = 1;

				Vector3 offset = Vector3::zero();
	
				float uTiling = (desc.tangentZ ? localExtentsSize.z : localExtentsSize.x);

				uvs[0] = surfaceOffset;
				uvs[0].x += uTiling;
				uvs[1] = surfaceOffset;
				uvs[2] = surfaceOffset;
				uvs[2].x += uTiling;
				uvs[2].y += TESSELATION_PIECE;
				uvs[3] = surfaceOffset;
				uvs[3].y += TESSELATION_PIECE;
				
				UVAtlasInfo studsAtlasInfo = getStudsAtlasInfo((ignoreMaterialsStuds || (options.flags & Flag_IgnoreStuds)) ? NO_SURFACE : part->getConstPartPrimitive()->getSurfaceType((NormalId)face));
				
				float uTilingStuds = studsAtlasInfo.tileX ? uTiling * 0.5f : 0;

				Vector2 uvStuds[4] =
				{
					Vector2(uTilingStuds, studsAtlasInfo.offsetY),
					Vector2(0, studsAtlasInfo.offsetY),
					Vector2(uTilingStuds, studsAtlasInfo.offsetY + studsAtlasInfo.scaleY),
					Vector2(0, studsAtlasInfo.offsetY + studsAtlasInfo.scaleY),
				};

				Vector4 startEdgeOffset = noBlanks ? Vector4() : computeOutlineOffsetPart((NormalId)face, part);

				Vector4 edgeOffset = startEdgeOffset;

				Vector4 edge0 = Vector4(0,uTiling,0,quadLength);
				Vector4 edge1 = Vector4(uTiling,0,0,quadLength);

				Vector3 worldDir = facesDir[face] * TESSELATION_PIECE;

				for (int quad = 0; quad < quadNumber - 1; quad++)
				{
					Vector3 nextOffset = offset + worldDir;

					Vector4 nextEdgeOffset = edgeOffset + Vector4(0,0,TESSELATION_PIECE, -TESSELATION_PIECE);

					fillVertex(vertices[vertexOffset + faceCounter * 4 + 0], start0 + offset, normals[face], uvs[0] * surfaceTiling, uvStuds[0], color, extra, tangents[face], edge0 + edgeOffset);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 1], start1 + offset, normals[face], uvs[1] * surfaceTiling, uvStuds[1], color, extra, tangents[face], edge1 + edgeOffset);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 2], start0 + nextOffset, normals[face], uvs[2] * surfaceTiling, uvStuds[2], color, extra, tangents[face], edge0 + nextEdgeOffset);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 3], start1 + nextOffset, normals[face], uvs[3] * surfaceTiling, uvStuds[3], color, extra, tangents[face], edge1 + nextEdgeOffset);
				
					uvs[0].y = uvs[2].y;
					uvs[1].y = uvs[3].y;
					uvs[2].y += TESSELATION_PIECE;
					uvs[3].y += TESSELATION_PIECE;

					offset = nextOffset;
					edgeOffset = nextEdgeOffset;
					
					fillQuadIndices(&indices[indexOffset + faceCounter * 6], vertexOffset + faceCounter * 4, 0, 1, 2, 3);
					faceCounter++;
				}
				
				if (quadNumber > 0)
				{
					// Last quad
					float texRemainderFraction = (desc.dirZ ? localExtentsSize.z : localExtentsSize.y) - (quadNumber - 1)*TESSELATION_PIECE;
					float texMultiplier = saturate(texRemainderFraction / TESSELATION_PIECE);

					Vector2 uv2 = Vector2(uvs[2].x, uvs[0].y + texRemainderFraction);
					Vector2 uv3 = Vector2(uvs[3].x, uvs[1].y + texRemainderFraction);
					
					Vector2 uvStuds2 = Vector2(uvStuds[2].x, studsAtlasInfo.offsetY + texMultiplier * studsAtlasInfo.scaleY);
					Vector2 uvStuds3 = Vector2(uvStuds[3].x, studsAtlasInfo.offsetY + texMultiplier * studsAtlasInfo.scaleY);

					Vector4 finalEdgeOffset = startEdgeOffset + Vector4(0,0, quadLength, -quadLength);

					fillVertex(vertices[vertexOffset + faceCounter * 4 + 0], start0 + offset, normals[face], uvs[0] * surfaceTiling, uvStuds[0], color, extra, tangents[face], edge0 + edgeOffset);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 1], start1 + offset, normals[face], uvs[1] * surfaceTiling, uvStuds[1], color, extra, tangents[face], edge1 + edgeOffset);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 2], corners[desc.end0], normals[face], uv2 * surfaceTiling, uvStuds2, color, extra, tangents[face], edge0 + finalEdgeOffset);
					fillVertex(vertices[vertexOffset + faceCounter * 4 + 3], corners[desc.end1], normals[face], uv3 * surfaceTiling, uvStuds3, color, extra, tangents[face], edge1 + finalEdgeOffset);
					
					fillQuadIndices(&indices[indexOffset + faceCounter * 6], vertexOffset + faceCounter * 4, 0, 1, 2, 3);
					faceCounter++;
				}
			}
			
			RBXASSERT(faceCounter == quads);
			
			Vector3 boundsCenter = cframe.pointToWorldSpace(center);
			extendBoundsBlock(mBboxMin, mBboxMax, boundsCenter, size, axisX, axisY, axisZ);
		}
	}

	void GeometryGenerator::addTorso(const Vector3& size, const Vector3& center, PartInstance* part, Decal* decal, const Options& options, unsigned int randomSeed)
	{
		int quads = decal ? 1 : 6;
		
		size_t vertexOffset = mVertexCount;
		size_t indexOffset = mIndexCount;

		mVertexCount += quads*4;
		mIndexCount += quads*6;
		
		if (!mVertices) return;

		Color4uint8 color = getColor(part, decal, NULL, options, randomSeed, false);
		Color4uint8 extra = getExtra(part, options);
		
		const CoordinateFrame& cframe = options.cframe;
		
		Vector3 extent = size * 0.5f;

		float shoulderInset = std::min(extent.x, size.z * 0.3f);

		Vector3 corners[8] =
		{
			Vector3(-extent.x, -extent.y, -extent.z) + center,
			Vector3(-extent.x, -extent.y, +extent.z) + center,
			Vector3(-extent.x + shoulderInset, +extent.y, -extent.z) + center,
			Vector3(-extent.x + shoulderInset, +extent.y, +extent.z) + center,
			Vector3(+extent.x, -extent.y, -extent.z) + center,
			Vector3(+extent.x, -extent.y, +extent.z) + center,
			Vector3(+extent.x - shoulderInset, +extent.y, -extent.z) + center,
			Vector3(+extent.x - shoulderInset, +extent.y, +extent.z) + center,
		};

		Vector2 surfaceOffset = getSurfaceOffset(size, randomSeed, part->getRenderMaterial());
        float surfaceTiling = decal ? 1 : getSurfaceTiling(part->getRenderMaterial());
			
		Vector3 normals[6] =
		{
			normalize(Vector3( size.y, shoulderInset, 0)), Vector3(0,  1, 0), Vector3(0, 0,  1),
			normalize(Vector3(-size.y, shoulderInset, 0)), Vector3(0, -1, 0), Vector3(0, 0, -1),
		};

		Vector3 tangents[6] =
		{
			-Vector3(0, 0, 1), -Vector3(1, 0, 0),  Vector3(1, 0, 0),
			 Vector3(0, 0, 1), -Vector3(1, 0, 0), -Vector3(1, 0, 0),
		};
		
		Vertex* vertices = mVertices;
		unsigned short* indices = mIndices;

		static const FACEDESC facesDesc[] =
		{
			{ 6,7,4,5, false, true, }, // Face 0
			{ 3,7,2,6, true, false, }, // Face 1
			{ 7,3,5,1, false, false, }, // Face 2
			{ 3,2,1,0, false, true, }, // Face 3
			{ 0,4,1,5, true, false, }, // Face 4
			{ 2,6,0,4, false, false, }, // Face 5
		};


		if (decal)
		{
			// Note: this table is almost identical to the facesDesc below, with the exception of bottom face.
			// This is needed to preserve the decal orientation compared to legacy code.
			static const unsigned int faces[6][4] =
			{
				{6, 7, 4, 5},
				{3, 7, 2, 6},
				{7, 3, 5, 1},
				{3, 2, 1, 0},
				{5, 1, 4, 0},
				{2, 6, 0, 4},
			};
			
			int face = decal->getFace();
			
			// If the block ignores studs (block meshes), then the Texture UV generation should not take size into account as well.
			Vector2 uv = getDecalUV(decal, size, /* ignoreSurfaceType= */ false);

			Vector3 normal = cframe.vectorToWorldSpace(normals[face]);
			
			fillVertex(vertices[vertexOffset + 0], cframe.pointToWorldSpace(corners[faces[face][0]]), normal, Vector2(uv.x, 0), Vector2(), color, extra, Vector3());
			fillVertex(vertices[vertexOffset + 1], cframe.pointToWorldSpace(corners[faces[face][1]]), normal, Vector2(0, 0), Vector2(), color, extra, Vector3());
			fillVertex(vertices[vertexOffset + 2], cframe.pointToWorldSpace(corners[faces[face][2]]), normal, Vector2(uv.x, uv.y), Vector2(), color, extra, Vector3());
			fillVertex(vertices[vertexOffset + 3], cframe.pointToWorldSpace(corners[faces[face][3]]), normal, Vector2(0, uv.y), Vector2(), color, extra, Vector3());
			
			fillQuadIndices(&indices[indexOffset], vertexOffset, 0, 1, 2, 3);
										
			for (int i = 0; i < 4; ++i)
				extendBounds(mBboxMin, mBboxMax, cframe.pointToWorldSpace(corners[faces[face][i]]));
		}
		else
		{
			unsigned faceCounter = 0;
	 
			for (int face = 0; face < ARRAYSIZE(facesDesc); ++face)
			{
				const FACEDESC& desc = facesDesc[face];
				
				Vector3 start0 = corners[desc.start0], start1 = corners[desc.start1];
				Vector3 end0 = corners[desc.end0], end1 = corners[desc.end1];

				float uTiling = (desc.tangentZ ? size.z : size.x);
				float vTiling = (desc.dirZ ? size.z : size.y);

				Vector3 normal = cframe.vectorToWorldSpace(normals[face]);
				Vector3 tangent = cframe.vectorToWorldSpace(tangents[face]);
		
				fillVertex(vertices[vertexOffset + faceCounter * 4 + 0], cframe.pointToWorldSpace(start0), normal, (surfaceOffset + Vector2(uTiling, 0)) * surfaceTiling, Vector2(), color, extra, tangent);
				fillVertex(vertices[vertexOffset + faceCounter * 4 + 1], cframe.pointToWorldSpace(start1), normal, surfaceOffset * surfaceTiling, Vector2(), color, extra, tangent);
				fillVertex(vertices[vertexOffset + faceCounter * 4 + 2], cframe.pointToWorldSpace(end0), normal, (surfaceOffset + Vector2(uTiling, vTiling)) * surfaceTiling, Vector2(), color, extra, tangent);
				fillVertex(vertices[vertexOffset + faceCounter * 4 + 3], cframe.pointToWorldSpace(end1), normal, (surfaceOffset + Vector2(0, vTiling)) * surfaceTiling, Vector2(), color, extra, tangent);
					
				fillQuadIndices(&indices[indexOffset + faceCounter * 6], vertexOffset + faceCounter * 4, 0, 1, 2, 3);

				faceCounter++;
			}

			for (int i = 0; i < 8; ++i)
				extendBounds(mBboxMin, mBboxMax, cframe.pointToWorldSpace(corners[i]));
			
			RBXASSERT(faceCounter == quads);
		}
	}
	
	struct TrussQuadBuilder
	{
		GeometryGenerator::Vertex* vertices;
		unsigned short* indices;
		unsigned int vertexOffset;
		unsigned int indexOffset;
		
		Vector3* bboxMin;
		Vector3* bboxMax;
		
		Color4uint8 color;
		Color4uint8 extra;
		
		CoordinateFrame cframe;
		Vector2 surfaceOffset;
        float surfaceTiling;
		
		TrussQuadBuilder(GeometryGenerator::Vertex* vertices, unsigned short* indices, unsigned int vertexOffset, unsigned int indexOffset, Vector3* bboxMin, Vector3* bboxMax, const Vector3& size, PartInstance* part, const GeometryGenerator::Options& options, unsigned int randomSeed)
		{
			this->vertices = vertices;
			this->indices = indices;
			this->vertexOffset = vertexOffset;
			this->indexOffset = indexOffset;
			this->bboxMin = bboxMin;
			this->bboxMax = bboxMax;
			
			color = getColor(part, NULL, NULL, options, randomSeed, false);
			extra = getExtra(part, options);
			
			cframe = options.cframe;
			
			surfaceOffset = getSurfaceOffset(size, randomSeed, part->getRenderMaterial());
            surfaceTiling = getSurfaceTiling(part->getRenderMaterial());
		}
		
		void emit(const Vector3& pos, const Vector3& udir, float usize, const Vector3& vdir, float vsize)
		{
			if (vertices)
			{
				Vector3 corner0 = pos + udir * std::max(0.f, usize) + vdir * std::max(0.f, vsize);
				Vector3 corner1 = pos + udir * std::min(0.f, usize) + vdir * std::max(0.f, vsize);
				Vector3 corner2 = pos + udir * std::max(0.f, usize) + vdir * std::min(0.f, vsize);
				Vector3 corner3 = pos + udir * std::min(0.f, usize) + vdir * std::min(0.f, vsize);
				
				Vector3 localNormal = cross(udir, vdir);
				Vector3 normal = cframe.vectorToWorldSpace(localNormal);
				Vector3 tangent = cframe.vectorToWorldSpace(udir);
				
				fillVertex(vertices[vertexOffset + 0], cframe.pointToWorldSpace(corner0), normal, (surfaceOffset + Vector2(dot(corner0, udir), dot(corner0, vdir))) * surfaceTiling, Vector2(), color, extra, tangent);
				fillVertex(vertices[vertexOffset + 1], cframe.pointToWorldSpace(corner1), normal, (surfaceOffset + Vector2(dot(corner1, udir), dot(corner1, vdir))) * surfaceTiling, Vector2(), color, extra, tangent);
				fillVertex(vertices[vertexOffset + 2], cframe.pointToWorldSpace(corner2), normal, (surfaceOffset + Vector2(dot(corner2, udir), dot(corner2, vdir))) * surfaceTiling, Vector2(), color, extra, tangent);
				fillVertex(vertices[vertexOffset + 3], cframe.pointToWorldSpace(corner3), normal, (surfaceOffset + Vector2(dot(corner3, udir), dot(corner3, vdir))) * surfaceTiling, Vector2(), color, extra, tangent);
				
				fillQuadIndices(&indices[indexOffset], vertexOffset, 0, 1, 2, 3);
				
				extendBounds(*bboxMin, *bboxMax, cframe.pointToWorldSpace(corner0));
				extendBounds(*bboxMin, *bboxMax, cframe.pointToWorldSpace(corner1));
				extendBounds(*bboxMin, *bboxMax, cframe.pointToWorldSpace(corner2));
				extendBounds(*bboxMin, *bboxMax, cframe.pointToWorldSpace(corner3));
			}
			
			vertexOffset += 4;
			indexOffset += 6;
		}
	};
	
	void GeometryGenerator::addTruss(int style, const Vector3& size, PartInstance* part, Decal* decal, const Options& options, unsigned int randomSeed)
	{
		if (decal) return;
		
		switch (size.primaryAxis())
		{
		case Vector3::X_AXIS:
			return addTrussY(Vector3(-size.x / 2, 0, 0), Vector3(0, 0, -1), Vector3(1, 0, 0), Vector3(0, -1, 0), static_cast<int>(size.x / 2 + 0.005f), style, size, part, options, randomSeed);
			
		case Vector3::Y_AXIS:
			return addTrussY(Vector3(0, -size.y / 2, 0), Vector3(1, 0, 0), Vector3(0, 1, 0), Vector3(0, 0, 1), static_cast<int>(size.y / 2 + 0.005f), style, size, part, options, randomSeed);

		case Vector3::Z_AXIS:
			return addTrussY(Vector3(0, 0, -size.z / 2), Vector3(1, 0, 0), Vector3(0, 0, 1), Vector3(0, -1, 0), static_cast<int>(size.z / 2 + 0.005f), style, size, part, options, randomSeed);
        default:
            break;
		}
	}

	void GeometryGenerator::addTrussY(const Vector3& origin, const Vector3& axisX, const Vector3& axisY, const Vector3& axisZ, int segments, int style, const Vector3& size, PartInstance* part, const Options& options, unsigned int randomSeed)
	{
		if (segments == 0) return;
		
		int styleAlt = (style == ExtrudedPartInstance::BRIDGE_STYLE_CROSS_BEAM) ? ExtrudedPartInstance::NO_CROSS_BEAM : style;
		
		addTrussSideX(origin - axisX - axisZ, axisX, axisY, axisZ, false, segments, styleAlt, size, part, options, randomSeed);
		addTrussSideX(origin - axisX + axisZ, -axisZ, axisY, axisX, true, segments, style, size, part, options, randomSeed);
		addTrussSideX(origin + axisX + axisZ, -axisX, axisY, -axisZ, false, segments, styleAlt, size, part, options, randomSeed);
		addTrussSideX(origin + axisX - axisZ, axisZ, axisY, -axisX, false, segments, style, size, part, options, randomSeed);
	}
	
	void GeometryGenerator::addTrussSideX(const Vector3& origin, const Vector3& axisX, const Vector3& axisY, const Vector3& axisZ, bool reverseBridge, int segments, int style, const Vector3& size, PartInstance* part, const Options& options, unsigned int randomSeed)
	{
		TrussQuadBuilder builder(mVertices, mIndices, mVertexCount, mIndexCount, &mBboxMin, &mBboxMax, size, part, options, randomSeed);

		// Build vertical frame
		builder.emit(origin, -axisX, -0.25f, axisY, segments * 2);
		builder.emit(origin, axisZ, 0.25f, axisY, segments * 2);
		builder.emit(origin + axisX * 0.25f, -axisZ, -0.25f, axisY, segments * 2);
		builder.emit(origin + axisZ * 0.25f, axisX, 0.25f, axisY, segments * 2);
		
		// Build horizontal frames
		for (int i = 0; i <= segments; ++i)
		{
			Vector3 frameOrigin = origin + axisY * (i == 0 ? 0 : 2 * i - 0.25f);
			float frameHeight = (i == 0 || i == segments) ? 0.25f : 0.5f;
			
			float bottomStart = (i == 0) ? 0.f : 0.25f;
			float topStart = (i == segments) ? 0.f : 0.25f;
			
			builder.emit(frameOrigin + axisX * 0.25f, -axisX, -1.5f, axisY, frameHeight);
			builder.emit(frameOrigin + axisX * 0.25f + axisZ * 0.25f, axisX, 1.5f, axisY, frameHeight);
			builder.emit(frameOrigin + axisX * bottomStart, axisX, 1.75f - bottomStart, axisZ, 0.25f);
			builder.emit(frameOrigin + axisX * topStart + axisY * frameHeight, -axisX, -(1.75f - topStart), axisZ, 0.25f);
		}

		// Build supports
		if (style != ExtrudedPartInstance::NO_CROSS_BEAM && segments > 1)
		{
			for (int i = 0; i < segments; ++i)
			{
				bool reverse = style == ExtrudedPartInstance::FULL_ALTERNATING_CROSS_BEAM ? (i % 2 == 1) : (reverseBridge ? i >= segments / 2 : i < segments / 2);
				
				Vector3 frameAxisY = reverse ? -axisY : axisY;
			
				Vector3 frameOrigin = origin + axisY * 2 * i + (reverse ? axisY * 2 : Vector3());
				
				Vector3 supportAxisU = (frameAxisY - axisX) * 0.707106f * (reverse ? -1 : 1);
				Vector3 supportAxisV = (axisX + frameAxisY) * 0.707106f;
				
				float supportLength = 2.474873f; // sqrt(sqr(1.75) * 2)
				
				Vector3 supportOrigin = frameOrigin + (frameAxisY + axisX) * 0.125f + axisZ * 0.0625f - supportAxisU * 0.125f;
				
				builder.emit(supportOrigin, supportAxisU, 0.25f, supportAxisV, supportLength);
				builder.emit(supportOrigin + axisZ * 0.125f, -supportAxisU, -0.25f, supportAxisV, supportLength);
				builder.emit(supportOrigin, -axisZ, -0.125f, supportAxisV, supportLength);
				builder.emit(supportOrigin + axisZ * 0.125f + supportAxisU * 0.25f, axisZ, -0.125f, supportAxisV, supportLength);
			}
		}

		mVertexCount = builder.vertexOffset;
		mIndexCount = builder.indexOffset;
	}

	void GeometryGenerator::addPartImpl(PartInstance* part, Decal* decal, const Options& options, const Resources& resources, const HumanoidIdentifier* hi, bool ignoreMaterialsStuds)
	{
		DataModelMesh* specialShape = getSpecialShape(part);
		
		unsigned int randomSeed = boost::hash_value(part);
		
		// handle mesh parts
		if (resources.fileMeshData)
		{
			return addFileMesh(resources.fileMeshData.get(), specialShape, part, decal, hi, options);
		}
			
		// handle parts with special shape
		if (specialShape)
		{
			if (SpecialShape* shape = specialShape->fastDynamicCast<SpecialShape>())
			{
                Vector3 offset = shape->getOffset();
				switch (shape->getMeshType())
				{
				case SpecialShape::BRICK_MESH:
					return addBlock(part->getPartSizeXml() * abs(shape->getScale()), offset, part, decal, options, randomSeed, ignoreMaterialsStuds);
				case SpecialShape::SPHERE_MESH:
					return addSphere(part->getPartSizeXml() * abs(shape->getScale()), offset, part, decal, options, randomSeed, ignoreMaterialsStuds);
				case SpecialShape::CYLINDER_MESH:
					return addCylinder<false>(part->getPartSizeXml() * abs(shape->getScale()), offset, part, decal, options, randomSeed,  ignoreMaterialsStuds);
				case SpecialShape::TORSO_MESH:
					return addTorso(part->getPartSizeXml() * abs(shape->getScale()), offset, part, decal, options, randomSeed);
				case SpecialShape::WEDGE_MESH:
					return addWedge<false>(part->getPartSizeXml() * abs(shape->getScale()), offset, part, decal, options, randomSeed, ignoreMaterialsStuds);
				default:
					// mesh type not supported yet
					return;
				}
			}
			else if (BlockMesh* shape = specialShape->fastDynamicCast<BlockMesh>())
			{
				return addBlock(part->getPartSizeXml() * abs(shape->getScale()), shape->getOffset(), part, decal, options, randomSeed, /* ignoreMaterialsStuds= */ true);
			}
			else if (CylinderMesh* shape = specialShape->fastDynamicCast<CylinderMesh>())
			{
				return addCylinder<true>(part->getPartSizeXml() * abs(shape->getScale()), shape->getOffset(), part, decal, options, randomSeed, /* ignoreMaterialsStuds= */ true);
			}

			// Unknown shape type, or a file mesh with an empty meshData (which means that the mesh data could not be loaded)
			return;
		}
		
		// handle parts
		switch(part->getPartType())
		{
		case BLOCK_PART:
			return addBlock(part->getPartSizeXml(), Vector3::zero(), part, decal, options, randomSeed, ignoreMaterialsStuds);
		case BALL_PART: 
			return addSphere(part->getPartSizeXml(), Vector3::zero(), part, decal, options, randomSeed, ignoreMaterialsStuds);
		case CYLINDER_PART:
			return addCylinder<false>(part->getPartSizeXml(), Vector3::zero(), part, decal, options, randomSeed, ignoreMaterialsStuds);
		case TRUSS_PART:
			return addTruss(static_cast<ExtrudedPartInstance*>(part)->getVisualTrussStyle(), part->getPartSizeXml(), part, decal, options, randomSeed);
		case WEDGE_PART:
			return addWedge<false>(part->getPartSizeXml(), Vector3::zero(), part, decal, options, randomSeed, ignoreMaterialsStuds);
		case CORNERWEDGE_PART:
			return addWedge<true>(part->getPartSizeXml(), Vector3::zero(), part, decal, options, randomSeed, ignoreMaterialsStuds);
		case OPERATION_PART:
			return addOperation(part, decal, options, resources, randomSeed);
        default:
            // unknown geometry type, skip it
            return;
		}
	}

    template <class AssetProvider, class AssetType, class AssetIdType>
	static boost::shared_ptr<AssetType> fetchMesh(const AssetIdType& meshFile, Instance* instance, AsyncResult* asyncResult)
	{
		if (meshFile.isNull())
			return boost::shared_ptr<AssetType>();
			
		ContentProvider* contentProvider = ServiceProvider::find<ContentProvider>(instance);
		CacheableContentProvider* mcp = ServiceProvider::find<AssetProvider>(contentProvider);
		
		if (!mcp)
		{
			asyncResult->returnResult(AsyncHttpQueue::Failed);
            return boost::shared_ptr<AssetType>();
		}
		
		AsyncHttpQueue::RequestResult reqResult;
		boost::shared_ptr<AssetType> meshData = boost::static_pointer_cast<AssetType>(mcp->requestContent(meshFile, ContentProvider::PRIORITY_MESH, true, reqResult));
		
		switch (reqResult)
		{
		case AsyncHttpQueue::Succeeded:
			return meshData;
			
		case AsyncHttpQueue::Waiting:
			asyncResult->returnWaitingFor(meshFile);
            return boost::shared_ptr<AssetType>();
        default:
			asyncResult->returnResult(reqResult);
            return boost::shared_ptr<AssetType>();
		}
	}
	
	GeometryGenerator::Resources GeometryGenerator::fetchResources(PartInstance* part, const HumanoidIdentifier* hi, unsigned int flags, AsyncResult* asyncResult)
	{
		DataModelMesh* specialShape = getSpecialShape(part);
		
		// handle parts with file mesh
		if (FileMesh* shape = getFileMesh(specialShape))
		{
            boost::shared_ptr<FileMeshData> fileMeshData = fetchMesh<MeshContentProvider, FileMeshData, MeshId>(shape->getMeshId(), part, asyncResult);
            return Resources(fileMeshData ? fileMeshData : kDummyMeshData);
		}

		// handle body parts
		if (Humanoid* humanoid = getHumanoid(part))
		{
			RBXASSERT(hi && hi->humanoid == humanoid);
			
			MeshId meshId = getMeshIdForBodyPart(*hi, part, specialShape, flags);
			
			if (!meshId.isNull())
			{
                boost::shared_ptr<FileMeshData> fileMeshData = fetchMesh<MeshContentProvider, FileMeshData, MeshId>(meshId, part, asyncResult);
                return Resources(fileMeshData ? fileMeshData : kDummyMeshData);
			}
		}
		
		// handle head mesh
		if (part->getCookie() & PartCookie::HAS_HEADMESH)
		{
			// Return the default head; scaling is taken care of in getMeshScale
            boost::shared_ptr<FileMeshData> fileMeshData = fetchMesh<MeshContentProvider, FileMeshData, MeshId>(MeshId("rbxasset://fonts/head.mesh"), part, asyncResult);
            return Resources(fileMeshData ? fileMeshData : kDummyMeshData);
		}

        if (FFlag::StudioCSGAssets && !FFlag::CSGLoadBlocking)
        {
            if (PartOperation* operation = part->fastDynamicCast<PartOperation>())
            {
                if (operation->hasAsset())
                {
                    shared_ptr<PartOperationAsset> partOperationAsset = fetchMesh<SolidModelContentProvider, PartOperationAsset, ContentId>(operation->getAssetId(), part, asyncResult);

                    if (partOperationAsset)
                        return Resources(partOperationAsset->getRenderMesh());
                }
            }
        }

        // no mesh
		return Resources();
	}
	
	GeometryGenerator::GeometryGenerator()
		: mVertices(NULL)
		, mIndices(NULL)
		, mVertexCount(0)
		, mIndexCount(0)
		, mBboxMin(Vector3::maxFinite())
		, mBboxMax(Vector3::minFinite())
	{
	}

	GeometryGenerator::GeometryGenerator(Vertex* vertices, unsigned short* indices, unsigned int vertexOffset)
		: mVertices(vertices)
		, mIndices(indices)
		, mVertexCount(vertexOffset)
		, mIndexCount(0)
		, mBboxMin(Vector3::maxFinite())
		, mBboxMax(Vector3::minFinite())
	{
		RBXASSERT(vertices && indices);
	}

	void GeometryGenerator::reset()
	{
		mVertexCount = 0;
		mIndexCount = 0;
		
		resetBounds();
	}
	
	void GeometryGenerator::resetBounds()
	{
		mBboxMin = Vector3::maxFinite();
		mBboxMax = Vector3::minFinite();
	}
	
	void GeometryGenerator::resetBounds(const Vector3& min, const Vector3& max)
	{
		mBboxMin = min;
		mBboxMax = max;
	}
	
	void GeometryGenerator::addInstance(PartInstance* part, Decal* decal, const Options& options, const Resources& resources, const HumanoidIdentifier* humanoidIdentifier /*=NULL*/)
	{
		addPartImpl(part, decal, options, resources, humanoidIdentifier, /* ignoreMaterialsStuds= */ false);
		
		// check that our indices did not overflow (caller should ensure this before calling addDecal)
		RBXASSERT(!mVertices || mVertexCount < (1 << 16));
	}

    static bool shouldRandomizeColor(VisualEngine* visualEngine, const PartInstance& part, Decal* decal)
    {
        bool randomizeColor = false;
        if (Lighting* lighting = visualEngine->getLighting())
            randomizeColor = lighting->getOutlines();

        if (randomizeColor)
        {
            if (decal && decal->isA<DecalTexture>())
                randomizeColor = false;
            else
            {
                randomizeColor = false;
                for (unsigned i = 0; i < NORM_UNDEFINED; ++i)
                    if (part.getSurfaceType((NormalId)i) != NO_SURFACE_NO_OUTLINES)
                    {
                        randomizeColor = true;
                        break;
                    }
            }  
        }

        return randomizeColor;
    }
    
	GeometryGenerator::Options::Options(VisualEngine* visualEngine, const PartInstance& part, Decal* decal, const CoordinateFrame& localTransform, unsigned int materialFlags, const Vector4& uvOffsetScale, unsigned int extra)
	{
        unsigned int randomizeFlag = 0;

        if (FFlag::NoRandomColorsWithoutOutlines)
        {
            randomizeFlag = 
                shouldRandomizeColor(visualEngine, part, decal)
                ? GeometryGenerator::Flag_RandomizeBlockAppearance
                : 0;   
        }
        else
        {
            randomizeFlag = 
            decal && decal->isA<DecalTexture>()
            ? 0
            : GeometryGenerator::Flag_RandomizeBlockAppearance;
        }

		unsigned int colorFlag =
			(materialFlags & MaterialGenerator::Result_UsesCompositTexture)
			? GeometryGenerator::Flag_VertexColorMesh // composited parts w/meshes and accoutrements need vertex color, but part color is baked in
			: (materialFlags & MaterialGenerator::Result_UsesTexture)
			? GeometryGenerator::Flag_VertexColorMesh  // meshes w/texture need vertex color, part color does not apply
			: GeometryGenerator::Flag_VertexColorPart; // no texture means that vertex color does not have any effect

		unsigned int colorOrderFlag =
			visualEngine->getDevice()->getCaps().colorOrderBGR ? GeometryGenerator::Flag_DiffuseColorBGRA : 0;

		unsigned int studFlag =
			(visualEngine->getSettings()->getDrawConnectors() || part.getRenderMaterial() == RBX::PLASTIC_MATERIAL)
			? 0
			: GeometryGenerator::Flag_IgnoreStuds;

		unsigned int extraFlag =
			visualEngine->getRenderCaps()->getSkinningBoneCount() > 0 ? 0 : GeometryGenerator::Flag_ExtraIsZero;

		unsigned int flags = randomizeFlag | colorFlag | colorOrderFlag | studFlag | extraFlag;

		this->flags = flags;
		this->extra = extra;

		if (uvOffsetScale != G3D::Vector4(0.f, 0.f, 1.f, 1.f))
		{
			this->flags |= GeometryGenerator::Flag_TransformUV;
			this->uvframe = uvOffsetScale;
		}

		this->cframe = localTransform;
	}

    void GeometryGenerator::addCSGPrimitive(PartInstance* part)
	{	
        Graphics::GeometryGenerator::Options options;
		options.flags |= Graphics::GeometryGenerator::Flag_VertexColorPart;

        // Setting the gfx cookie artificially so that the special mesh will
        // be searched for.  We need to do this because this part may not
        // have been through the renderer yet to receive the cookie.
        unsigned int oldCookie = part->getCookie();
        part->setCookie(oldCookie | PartCookie::HAS_SPECIALSHAPE);

        // Trusses are not manifold so skip them for now.
        if (part->getPartType() == TRUSS_PART)
        {
            return;
        }

        addPartImpl(part, NULL, options, Resources(), /*humanoidIdentifier=*/ NULL, /* ignoreMaterialsStuds= */ true);

        part->setCookie(oldCookie);
	}

    void GeometryGenerator::addOperation(PartInstance* part, Decal* decal, const Options& options, const Resources& resources, unsigned int randomSeed)
	{
        bool renderCollision = PartOperation::renderCollisionData;

		PartOperation* operation = part->fastDynamicCast<PartOperation>();

		if (!operation)
			return;

        shared_ptr<CSGMesh> csgMesh = resources.csgMeshData;

        if (!csgMesh)
        {
            if (!FFlag::StudioCSGAssets || FFlag::CSGLoadBlocking)
            {
                if (!operation->getMesh())
                    return;

                if (operation->getMesh()->isBadMesh())
                    return;

                csgMesh = operation->getMesh();
            }
            else
            {
                if (operation->getRenderMesh() && !operation->getRenderMesh()->isBadMesh())
                {
                    csgMesh = operation->getRenderMesh();
                }
            }
        }
                
        if (!csgMesh)
            return;

		if (renderCollision)
		{
			addOperationDecompositionDebug(operation, part, decal, options, randomSeed);
			return;
		}

		size_t vertexOffset = mVertexCount;
		size_t indexOffset = mIndexCount;
		CSGMesh* modelData = csgMesh.get();

        const std::vector<CSGVertex>& meshVertices = modelData->getVertices();
        const std::vector<unsigned int>& meshIndices = modelData->getIndices();

        if (!FFlag::FixGlowingCSG || !decal)
        {
		mVertexCount += meshVertices.size();
		mIndexCount += meshIndices.size();
        }
        else
        {
            mVertexCount += csgMesh->getVertexRemap(decal->getFace()).size();
            mIndexCount += csgMesh->getIndexRemap(decal->getFace()).size();
        }

		if (!mVertices) return;

		Vertex* vertices = mVertices;
		unsigned short* indices = mIndices;

		Vector3 size = part->getPartSizeXml();
		RBX::Color4uint8 partColor = getColor(part, decal, NULL, options, randomSeed, true);
        const RBX::Color4uint8& extra = getExtra(part, options);

        bool isNegate = part->fastDynamicCast<NegateOperation>() != 0;
        bool usePartColor = operation->getUsePartColor();

        if (isNegate)
        {
            partColor = RBX::Color4uint8(255, 154, 161, 150);
		    if ((options.flags & GeometryGenerator::Flag_DiffuseColorBGRA) != 0)
                std::swap(partColor.r, partColor.b);
        }

        Vector3 scale = operation->getSizeDifference();
		const CoordinateFrame& cframe = options.cframe;

		Vector2 surfaceOffset = getSurfaceOffset(size, randomSeed, part->getRenderMaterial());
        float surfaceTiling = decal ? 1 : getSurfaceTiling(part->getRenderMaterial());
        Vector3 invSize = Vector3(1.0f/size.x, 1.0f/size.y, 1.0f/size.z);
        bool isScaled = operation->getInitialSize() != operation->getPartSizeXml();
		Vector2 uvStuds; // blank for now

        if (!FFlag::FixGlowingCSG)
        {
		for (size_t vi = 0; vi < meshVertices.size(); vi++)
		{
            const CSGVertex& vert = meshVertices[vi];
			Vector3 pos = vert.pos * scale;
			Vector3 normal = vert.normal;
            Vector3 tangent = vert.tangent;
            Color4uint8 vertColor = partColor;
           
            if (!isNegate && !usePartColor && !decal)
			{
				vertColor = meshVertices[vi].color;
				vertColor.a = partColor.a;
				if ((options.flags & GeometryGenerator::Flag_DiffuseColorBGRA) != 0)
					std::swap(vertColor.r, vertColor.b);
            }

            Vector2 uv = vert.uv;
            
            if (isScaled)
                uv = vert.generateUv(pos);

            if (decal)
            {
                if (vert.extra.r - 1 != decal->getFace())
                {
                    uv = Vector2();
                    vertColor.a = 0.0f;
                }
                else
                {
                    DecalTexture* texture = decal->fastDynamicCast<DecalTexture>();
                    if (texture)
                    {
                        uv /= texture->getStudsPerTile();
                    }
                    else
                    {
                        switch (decal->getFace())
                        {
                            case NORM_X:
                            case NORM_X_NEG:
                                uv = uv * Vector2(invSize.z, invSize.y) + Vector2(0.5f, 0.5f);
                                break;
                            case NORM_Y:
                            case NORM_Y_NEG:
                                uv = uv * Vector2(invSize.x, invSize.z) + Vector2(0.5f, 0.5f);
                                break;
                            case NORM_Z:
                            case NORM_Z_NEG:
                                uv = uv * Vector2(invSize.x, invSize.y) + Vector2(0.5f, 0.5f);
                                break;
                            default: break;
                        }
                    }
                }
            }
            else
            {
                uv = Vector2(uv.x * surfaceTiling + surfaceOffset.x,
                             uv.y * surfaceTiling + surfaceOffset.y);
            }

            pos = cframe.pointToWorldSpace(pos);
            normal = cframe.vectorToWorldSpace(normal);
			tangent = cframe.vectorToWorldSpace(tangent);

            fillVertex(vertices[vertexOffset + vi], pos, normal, uv, uvStuds, vertColor /*Color4uint8(rand() % 255, rand() % 255, rand() % 255, 255)*/, extra, tangent);
		}

		for (size_t ii = 0; ii < meshIndices.size(); ii++)
		{
            indices[indexOffset + ii] = vertexOffset + meshIndices[ii];
		}
        }
        else
        {
            unsigned numberOfVerts = decal ? csgMesh->getVertexRemap(decal->getFace()).size() : meshVertices.size();
            unsigned int vertId = 0;
            for (size_t vi = 0; vi < numberOfVerts; vi++)
            {
                const CSGVertex& vert = decal ? meshVertices[csgMesh->getVertexRemap(decal->getFace())[vi]] : meshVertices[vi];

                Vector3 pos = vert.pos * scale;
                Vector3 normal = vert.normal;
                Vector3 tangent = vert.tangent;
                Color4uint8 vertColor = partColor;

                if (!isNegate && !usePartColor && !decal)
                {
                    vertColor = meshVertices[vi].color;
                    vertColor.a = partColor.a;
                    if ((options.flags & GeometryGenerator::Flag_DiffuseColorBGRA) != 0)
                        std::swap(vertColor.r, vertColor.b);
                }

                Vector2 uv = vert.uv;

                if (isScaled)
                    uv = vert.generateUv(pos);

                if (decal)
                {
                    DecalTexture* texture = decal->fastDynamicCast<DecalTexture>();
                    if (texture)
                    {
                        uv /= texture->getStudsPerTile();
                    }
                    else
                    {
                        switch (decal->getFace())
                        {
                        case NORM_X:
                        case NORM_X_NEG:
                            uv = uv * Vector2(invSize.z, invSize.y) + Vector2(0.5f, 0.5f);
                            break;
                        case NORM_Y:
                        case NORM_Y_NEG:
                            uv = uv * Vector2(invSize.x, invSize.z) + Vector2(0.5f, 0.5f);
                            break;
                        case NORM_Z:
                        case NORM_Z_NEG:
                            uv = uv * Vector2(invSize.x, invSize.y) + Vector2(0.5f, 0.5f);
                            break;
                        default: break;
                        } 
                    }
                }
                else
                {
                    uv = Vector2(uv.x * surfaceTiling + surfaceOffset.x,
                                 uv.y * surfaceTiling + surfaceOffset.y);
                }

                pos = cframe.pointToWorldSpace(pos);
                normal = cframe.vectorToWorldSpace(normal);
                tangent = cframe.vectorToWorldSpace(tangent);

                fillVertex(vertices[vertexOffset + vertId], pos, normal, uv, uvStuds, vertColor , extra, tangent);
                vertId++;
            }

            if (!decal)
            {
                for (size_t ii = 0; ii < meshIndices.size(); ii++)
                    indices[indexOffset + ii] = vertexOffset + meshIndices[ii];
            }
            else
            {
                const std::vector<unsigned>& indexFaceRamep = csgMesh->getIndexRemap(decal->getFace());

                for (size_t ii = 0; ii < indexFaceRamep.size(); ii++)
                    indices[indexOffset + ii] = vertexOffset + indexFaceRamep[ii];
            }
        }

		Vector3 boundsCenter = cframe.pointToWorldSpace(RBX::Vector3::zero());
		Vector3 axisX = Vector3(cframe.rotation[0][0], cframe.rotation[1][0], cframe.rotation[2][0]);
		Vector3 axisY = Vector3(cframe.rotation[0][1], cframe.rotation[1][1], cframe.rotation[2][1]);
		Vector3 axisZ = Vector3(cframe.rotation[0][2], cframe.rotation[1][2], cframe.rotation[2][2]);
		extendBoundsBlock(mBboxMin, mBboxMax, boundsCenter, part->getPartSizeXml(), axisX, axisY, axisZ);
	}

	void GeometryGenerator::addOperationDecompositionDebug(PartOperation* operation, PartInstance* part, Decal* decal, const Options& options, unsigned int randomSeed)
	{
		if (FFlag::CSGPhysicsLevelOfDetailEnabled && operation->getCollisionFidelity() == CollisionFidelity_Box)
		{
			fillBlockShapeDebug(part, options);
			return;
		}

		fillDecompShapeDebug(operation, part, options);
	}

	void GeometryGenerator::fillBlockShapeDebug(PartInstance* part, const Options &options)
	{
		size_t vertexOffset = mVertexCount;
		size_t indexOffset = mIndexCount;

		LcmRand randGen;
		randGen.setSeed(static_cast<unsigned>(reinterpret_cast<long>(part)));

		unsigned int numfaces = 6;
		mVertexCount += numfaces*4;
		mIndexCount += numfaces*6;

		Color4uint8 color = RBX::Color4uint8(randGen.value() % 255, randGen.value() % 255, randGen.value() % 255, 100);
		Color4uint8 extra = getExtra(part, options);

		const Vector3 size = part->getPartSizeUi();
		const CoordinateFrame& cframe = options.cframe;
		const Vector3 center = Vector3::zero();

		if (!mVertices) return;

		Vertex* vertices = mVertices;
		unsigned short* indices = mIndices;

		Vector3 axisX = Vector3(cframe.rotation[0][0], cframe.rotation[1][0], cframe.rotation[2][0]);
		Vector3 axisY = Vector3(cframe.rotation[0][1], cframe.rotation[1][1], cframe.rotation[2][1]);
		Vector3 axisZ = Vector3(cframe.rotation[0][2], cframe.rotation[1][2], cframe.rotation[2][2]);

		Vector3 extent = size * 0.5f;

		Vector3 cornerO = cframe.pointToWorldSpace(Vector3(center - extent));
		Vector3 cornerX = axisX * size.x;
		Vector3 cornerY = axisY * size.y;
		Vector3 cornerZ = axisZ * size.z;

		Vector3 corners[8] =
		{
			cornerO,
			cornerO + cornerZ,
			cornerO + cornerY,
			cornerO + cornerY + cornerZ,
			cornerO + cornerX,
			cornerO + cornerX + cornerZ,
			cornerO + cornerX + cornerY,
			cornerO + cornerX + cornerY + cornerZ,
		};

		Vector3 normal;  // Set Normals to Z
		normal.x = 0;
		normal.y = 0;
		normal.z = 1;
		Vector3 tangent;
		tangent.x = 0;
		tangent.y = 0;
		tangent.z = 1;	// Set Normals to Z

		Vector2 uv;
		uv.x = 0;
		uv.y = 0;

		static const unsigned int faces[6][4] =
		{
			{6, 7, 4, 5},
			{3, 7, 2, 6},
			{7, 3, 5, 1},
			{3, 2, 1, 0},
			{5, 1, 4, 0},
			{2, 6, 0, 4},
		};

		for (unsigned int face = 0; face < numfaces; face++)
		{
			unsigned int internalOffset = face*4;
			fillVertex(vertices[internalOffset + vertexOffset + 0], corners[faces[face][0]], normal, uv,uv, color, extra, Vector3());
			fillVertex(vertices[internalOffset + vertexOffset + 1], corners[faces[face][1]], normal, uv,uv, color, extra, Vector3());
			fillVertex(vertices[internalOffset + vertexOffset + 2], corners[faces[face][2]], normal, uv,uv, color, extra, Vector3());
			fillVertex(vertices[internalOffset + vertexOffset + 3], corners[faces[face][3]], normal, uv,uv, color, extra, Vector3());

			unsigned int internalIndexOffset = face*6;
			fillQuadIndices(&indices[internalIndexOffset + indexOffset], internalOffset + vertexOffset, 0, 1, 2, 3);
		}
		Vector3 boundsCenter = cframe.pointToWorldSpace(RBX::Vector3::zero());
		extendBoundsBlock(mBboxMin, mBboxMax, boundsCenter, part->getPartSizeXml(), axisX, axisY, axisZ);
	}

	void GeometryGenerator::fillDecompShapeDebug(PartOperation* operation, PartInstance* part, const Options &options)
	{
		Vector3 scale;
		int currentVersion = 0;

		if (operation->getPrimitive(operation)->getGeometry()->getGeometryType() != RBX::Geometry::GEOMETRY_TRI_MESH)
			return;

		size_t vertexOffset = mVertexCount;
		size_t indexOffset = mIndexCount;
		int childIndexOffset = 0;
		int childVertexOffset = 0;

		if (operation->getNonKeyPhysicsData() == "")
			return;

		btVector3 btScale; 
		std::vector<CSGConvex> meshConvexes = TriangleMesh::getDecompConvexes(operation->getNonKeyPhysicsData(), currentVersion, btScale, false);

		if (currentVersion == 0)
			return;

		for (unsigned int i = 0; i < meshConvexes.size(); i++)
		{
			mVertexCount += meshConvexes[i].vertices.size();
			mIndexCount += meshConvexes[i].indices.size();
		}

		if (!mVertices) return;


		Vertex* vertices = mVertices;
		unsigned short* indices = mIndices;

		const RBX::Color4uint8& extra = getExtra(part, options);
		const CoordinateFrame& cframe = options.cframe;

		Vector3 axisX = Vector3(cframe.rotation[0][0], cframe.rotation[1][0], cframe.rotation[2][0]);
		Vector3 axisY = Vector3(cframe.rotation[0][1], cframe.rotation[1][1], cframe.rotation[2][1]);
		Vector3 axisZ = Vector3(cframe.rotation[0][2], cframe.rotation[1][2], cframe.rotation[2][2]);

		scale = operation->calculateSizeDifference(operation->getPartSizeXml());

		LcmRand randGen;
		randGen.setSeed(static_cast<unsigned>(reinterpret_cast<long>(operation)));

		for (unsigned int i = 0; i < meshConvexes.size(); i++)
		{
			const RBX::Color4uint8 color = RBX::Color4uint8(randGen.value() % 255, randGen.value() % 255, randGen.value() % 255, 100);

			for (unsigned int j = 0; j < meshConvexes[i].vertices.size(); j++)
			{
				Vector3 pos;
				btVector3 offsetVertex = meshConvexes[i].transform * meshConvexes[i].vertices[j];
				pos.x = offsetVertex.x();
				pos.y = offsetVertex.y();
				pos.z = offsetVertex.z();

				Vector3 normal;  // Set Normals to Z
				normal.x = 0;
				normal.y = 0;
				normal.z = 1;
				Vector3 tangent;
				tangent.x = 0;
				tangent.y = 0;
				tangent.z = 1;	// Set Normals to Z

				Vector2 uv;
				uv.x = 0;
				uv.y = 0;

				pos *= scale;


				pos = cframe.pointToWorldSpace(pos);
				normal = cframe.vectorToWorldSpace(normal);
				tangent = cframe.vectorToWorldSpace(tangent);
				fillVertex(vertices[vertexOffset + childVertexOffset + j], pos, normal, uv,uv, color, extra, tangent);
			}
			for (unsigned int j = 0; j < meshConvexes[i].indices.size(); j++)
			{
				indices[indexOffset + childIndexOffset + j] = vertexOffset + childVertexOffset + meshConvexes[i].indices[j];
			}
			childIndexOffset += meshConvexes[i].indices.size();
			childVertexOffset += meshConvexes[i].vertices.size();
		}
		Vector3 boundsCenter = cframe.pointToWorldSpace(RBX::Vector3::zero());
		extendBoundsBlock(mBboxMin, mBboxMax, boundsCenter, part->getPartSizeXml(), axisX, axisY, axisZ);
	}
}
}