+Unity Runtime codeHEADmaster

1 files changed, 762 insertions, 0 deletions

diff --git a/Runtime/GfxDevice/opengles30/TransformFeedbackSkinnedMesh.cpp b/Runtime/GfxDevice/opengles30/TransformFeedbackSkinnedMesh.cpp
new file mode 100644
index 0000000..dc22318
--- /dev/null
+++ b/Runtime/GfxDevice/opengles30/TransformFeedbackSkinnedMesh.cpp
@@ -0,0 +1,762 @@
+ #include "UnityPrefix.h"
+
+#include "Runtime/GfxDevice/opengles30/TransformFeedbackSkinnedMesh.h"
+
+#include "Runtime/Filters/Mesh/Mesh.h"
+#include "Runtime/Filters/Mesh/MeshSkinning.h"
+#include "Runtime/Filters/Renderer.h"
+#include "Runtime/GfxDevice/opengles30/VBOGLES30.h"
+#include "Runtime/GfxDevice/opengles30/AssertGLES30.h"
+#include "Runtime/Shaders/GraphicsCaps.h"
+
+// If 1, uses uniform blocks, otherwise fix bone count to 82
+#define USE_UNIFORM_BLOCK_FOR_BONES 0
+
+// 1 to use glVertexAttribIPointer for bone indices, 0 to convert to floats
+#define USE_INT_ATTRIBS 1
+
+//! Attribute array indices.
+enum { TFATTRLOC_POS = 0, TFATTRLOC_NORM = 1, TFATTRLOC_TAN = 2, TFATTRLOC_BONEIDX=3, TFATTRLOC_BONEWEIGHT = 4,  TFATTRLOC_SIZE = 5 };
+
+// Shader programs
+enum { TFSHADER_POS = 0, TFSHADER_POSNORM = 1, TFSHADER_POSNORMTAN = 2, TFSHADER_SIZE = 3 };
+
+struct TFShader
+{
+	TFShader() : program(0), vertShader(0), bonesLocation(0) {}
+
+	// Not a dtor, we're storing them in a map, so delete manually in CleanupTransformFeedbackShaders
+	void Release()
+	{
+		if(program)
+			glDeleteProgram(program);
+		if(vertShader)
+			glDeleteShader(vertShader);
+	}
+
+	GLuint	program;
+	GLuint	vertShader;
+	GLint	bonesLocation;
+	GLint	attribLocations[TFATTRLOC_SIZE];
+};
+
+// Swap specialization for TFShader
+namespace std
+{
+	template<> void swap(TFShader &a, TFShader &b)
+	{
+		swap(a.program, b.program);
+		swap(a.vertShader, b.vertShader);
+		swap(a.bonesLocation, b.bonesLocation);
+		swap(a.attribLocations, b.attribLocations);
+	}
+}
+
+// Map to store shaders. the key is channelMap + (bonesPerVertex << 16)
+typedef std::map<UInt32, TFShader> TFShaderMap;
+
+static TFShaderMap tfShaders;
+
+const char *tfShaderAttribNames[TFATTRLOC_SIZE] = {"in_vertex", "in_normal", "in_tangent", "in_boneIndices", "in_boneWeights" };
+
+//! Fragment shader, common to all programs.
+static GLuint tfFragShader = 0; 
+
+
+#define STRINGIFY(x) #x
+
+#if USE_UNIFORM_BLOCK_FOR_BONES
+	#define MATRIX_DECL "uniform MtxBlock { vec4 bones[max_bone_count*3]; } Matrices; \n"
+	#define BUILD_MATRIX "Matrices.bones[bidx + 0], Matrices.bones[bidx + 1], Matrices.bones[bidx + 2]"
+#else
+	#define MATRIX_DECL "uniform vec4 bones[max_bone_count*3];\n"
+	#define BUILD_MATRIX "bones[bidx + 0], bones[bidx + 1], bones[bidx + 2]"
+#endif
+
+// Macro to build shader source.
+#define BUILD_SHADER_2(bonecount, indecl, outdecl, skincalc, outcalc ) \
+	"#version 300 es\n" \
+	"\n" \
+	"const int max_bone_count = " STRINGIFY(bonecount) ";\n" \
+	"in vec3 in_vertex;\n" \
+	indecl \
+	"out vec3 out_pos;\n" \
+	outdecl \
+	"\n" \
+	MATRIX_DECL \
+	"\n" \
+	"mat4 getMatrix(int idx)\n" \
+	"{\n"\
+	"	int bidx = idx*3;\n" \
+	"	return mat4(" BUILD_MATRIX ", vec4(0.0, 0.0, 0.0, 1.0));\n" \
+	"}\n"\
+	"void main(void)\n" \
+	"{\n" \
+	"	vec4 inpos = vec4(in_vertex.xyz, 1.0);\n" \
+	"	mat4 localToWorldMatrix = \n" \
+	skincalc \
+	"	out_pos = (inpos * localToWorldMatrix).xyz;\n" \
+	"	gl_Position = vec4(out_pos.xyz, 1.0);\n" \
+	outcalc \
+	"}"
+
+#if USE_INT_ATTRIBS
+#define BONEINDEXTYPE1 "int"
+#define BONEINDEXTYPE2 "ivec2"
+#define BONEINDEXTYPE4 "ivec4"
+#else
+#define BONEINDEXTYPE1 "float"
+#define BONEINDEXTYPE2 "vec2"
+#define BONEINDEXTYPE4 "vec4"
+#endif
+
+#if USE_UNIFORM_BLOCK_FOR_BONES
+#define BUILD_SHADER( indecl, outdecl, skincalc, outcalc ) \
+	{\
+		BUILD_SHADER_2(32, indecl, outdecl, skincalc, outcalc), \
+		BUILD_SHADER_2(64, indecl, outdecl, skincalc, outcalc), \
+		BUILD_SHADER_2(128, indecl, outdecl, skincalc, outcalc), \
+		BUILD_SHADER_2(256, indecl, outdecl, skincalc, outcalc), \
+		BUILD_SHADER_2(512, indecl, outdecl, skincalc, outcalc), \
+		BUILD_SHADER_2(1024, indecl, outdecl, skincalc, outcalc) }
+#else
+// Just one bonecount, store it in first element
+#define BUILD_SHADER( indecl, outdecl, skincalc, outcalc ) \
+{\
+	BUILD_SHADER_2(82, indecl, outdecl, skincalc, outcalc), "", "", "", "", ""\
+}
+#endif
+// Shaders for each input type, and for various max bone counts (32, 64, 128, 256, 512 and 1024) and bone-per-vertex counts (1, 2, 4 bones per vertex supported, sparse array so third slot is empty).
+static const char *tfShaderSource[TFSHADER_SIZE][4][6] = {
+	// TFSHADER_POS
+	{
+#define IN_DECL "\n"
+#define OUT_DECL "\n"
+#define OUT_CALC "\n"
+		// 1 bone
+		BUILD_SHADER( "in " BONEINDEXTYPE1 " in_boneIndices;\n" IN_DECL,
+			OUT_DECL, 
+			"		getMatrix(int(in_boneIndices));\n",
+			OUT_CALC
+			),
+
+		// 2 bones
+		BUILD_SHADER( "in " BONEINDEXTYPE2 " in_boneIndices;\n in vec2 in_boneWeights;\n" IN_DECL,
+			OUT_DECL, 
+			"		getMatrix(int(in_boneIndices.x)) * in_boneWeights[0]  + \n" \
+			"		getMatrix(int(in_boneIndices.y)) * in_boneWeights[1] ;\n ",
+			OUT_CALC
+			),
+			// 3 bones
+		{"", "", "", "", "", ""},
+
+		// 4 bones
+		BUILD_SHADER( "in " BONEINDEXTYPE4 " in_boneIndices;\n in vec4 in_boneWeights;\n" IN_DECL,
+					OUT_DECL, 
+					"		getMatrix(int(in_boneIndices.x)) * in_boneWeights[0]  + \n" \
+					"		getMatrix(int(in_boneIndices.y)) * in_boneWeights[1]  + \n" \
+					"		getMatrix(int(in_boneIndices.z)) * in_boneWeights[2]  + \n" \
+					"		getMatrix(int(in_boneIndices.w)) * in_boneWeights[3] ;\n",
+					OUT_CALC
+				)
+	}
+	,
+	// TFSHADER_POSNORM
+	{
+#undef IN_DECL
+#undef OUT_DECL
+#undef OUT_CALC
+#define IN_DECL "in vec3 in_normal;\n"
+#define OUT_DECL "out vec3 out_normal;\n"
+#define OUT_CALC "	out_normal = normalize( (vec4(in_normal.xyz, 0.0) * localToWorldMatrix)).xyz;\n"
+		// 1 bone
+		BUILD_SHADER( "in " BONEINDEXTYPE1 " in_boneIndices;\n" IN_DECL,
+			OUT_DECL, 
+			"		getMatrix(int(in_boneIndices));\n",
+			OUT_CALC
+			),
+
+			// 2 bones
+			BUILD_SHADER( "in " BONEINDEXTYPE2 " in_boneIndices;\n in vec2 in_boneWeights;\n" IN_DECL,
+			OUT_DECL, 
+			"		getMatrix(int(in_boneIndices.x)) * in_boneWeights[0]  + \n" \
+			"		getMatrix(int(in_boneIndices.y)) * in_boneWeights[1] ;\n ",
+			OUT_CALC
+			),
+			// 3 bones
+		{"", "", "", "", "", ""},
+
+			// 4 bones
+			BUILD_SHADER( "in " BONEINDEXTYPE4 " in_boneIndices;\n in vec4 in_boneWeights;\n" IN_DECL,
+			OUT_DECL, 
+			"		getMatrix(int(in_boneIndices.x)) * in_boneWeights[0]  + \n" \
+			"		getMatrix(int(in_boneIndices.y)) * in_boneWeights[1]  + \n" \
+			"		getMatrix(int(in_boneIndices.z)) * in_boneWeights[2]  + \n" \
+			"		getMatrix(int(in_boneIndices.w)) * in_boneWeights[3] ;\n",
+			OUT_CALC
+			)
+	},
+// TFSHADER_POSNORMTAN
+	{
+#undef IN_DECL
+#undef OUT_DECL
+#undef OUT_CALC
+#define IN_DECL "in vec3 in_normal;\n in vec4 in_tangent;\n"
+#define OUT_DECL "out vec3 out_normal;\n out vec4 out_tangent;\n"
+#define OUT_CALC "	out_normal = normalize( ( vec4(in_normal.xyz, 0.0) * localToWorldMatrix)).xyz;\n" \
+				"	out_tangent = vec4( normalize( ( vec4(in_tangent.xyz, 0.0) * localToWorldMatrix)).xyz, in_tangent.w);\n"
+		// 1 bone
+		BUILD_SHADER( "in " BONEINDEXTYPE1 " in_boneIndices;\n" IN_DECL,
+			OUT_DECL, 
+			"		getMatrix(int(in_boneIndices));\n",
+			OUT_CALC
+			),
+
+			// 2 bones
+			BUILD_SHADER( "in " BONEINDEXTYPE2 " in_boneIndices;\n in vec2 in_boneWeights;\n" IN_DECL,
+			OUT_DECL, 
+			"		getMatrix(int(in_boneIndices.x)) * in_boneWeights[0]  + \n" \
+			"		getMatrix(int(in_boneIndices.y)) * in_boneWeights[1] ;\n ",
+			OUT_CALC
+			),
+			// 3 bones
+		{"", "", "", "", "", ""},
+
+			// 4 bones
+			BUILD_SHADER( "in " BONEINDEXTYPE4 " in_boneIndices;\n in vec4 in_boneWeights;\n" IN_DECL,
+			OUT_DECL, 
+			"		getMatrix(int(in_boneIndices.x)) * in_boneWeights[0]  + \n" \
+			"		getMatrix(int(in_boneIndices.y)) * in_boneWeights[1]  + \n" \
+			"		getMatrix(int(in_boneIndices.z)) * in_boneWeights[2]  + \n" \
+			"		getMatrix(int(in_boneIndices.w)) * in_boneWeights[3] ;\n",
+			OUT_CALC
+			)
+		}
+
+#undef IN_DECL
+#undef OUT_DECL
+#undef OUT_CALC
+
+};
+
+#undef BUILD_SHADER
+#undef BUILD_SHADER_2
+#undef STRINGIFY
+#undef MATRIX_DECL
+#undef BUILD_MATRIX
+
+static const char skinFS[] = 
+	"#version 300 es\n"
+	"\n"
+	"precision lowp float;\n"
+	"out vec4 outcol;\n"
+	"void main(void) { outcol = vec4(1.0, 1.0, 1.0, 1.0); }\n";
+	
+enum TfSkinShaderChannel
+{
+	kTFC_Position		= VERTEX_FORMAT1(Vertex),
+	kTFC_Normal			= VERTEX_FORMAT1(Normal),
+	kTFC_Tangent		= VERTEX_FORMAT1(Tangent)
+};
+
+static GLuint tfTransformFeedback = 0;
+static GLuint GetTransformFeedbackObject(void)
+{
+	if(!tfTransformFeedback)
+		GLES_CHK(glGenTransformFeedbacks(1, &tfTransformFeedback));
+	return tfTransformFeedback;
+}
+
+// Note: we might not support all formats all the time.
+static bool DoesVertexFormatQualifyForTransformFeedback(UInt32 shaderChannelsMap)
+{
+	// Must have position, and if has tangents, must have normals as well.
+	bool qualify = (shaderChannelsMap & kTFC_Position) != 0;
+	if ((shaderChannelsMap & kTFC_Tangent) != 0)
+		qualify &= (shaderChannelsMap & kTFC_Normal) != 0;
+
+	return qualify;
+
+}
+
+static UInt32 roundUpToNextPowerOf2(UInt32 in)
+{
+	// Round up to nearest power of 2
+	// http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+	in--;
+	in |= in >> 1;
+	in |= in >> 2;
+	in |= in >> 4;
+	in |= in >> 8;
+	in |= in >> 16;
+	in++;
+	return in;
+}
+// Get the bones bit index based on bone count. Assumes bonecount is power of 2
+static int getBonesBits(UInt32 boneCount)
+{
+	// Calculate ln2
+	// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn
+
+	static const int MultiplyDeBruijnBitPosition2[32] = 
+	{
+		0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 
+		31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
+	};
+	UInt32 res = MultiplyDeBruijnBitPosition2[(UInt32)(boneCount * 0x077CB531U) >> 27];
+
+	if(res < 5) // Minimum size is 32 (= 0)
+		return 0;
+
+	return res-5; // Adjust so that 32 = 0, 64 = 1 etc.
+}
+
+static void print_long_string(std::string in)
+{
+	int offs = 0;
+	int len = in.length();
+	const int split = 200;
+	do 
+	{
+		printf_console(in.substr(offs, split).c_str());
+		offs+=split;
+	} while (offs < len);
+	
+}
+
+// maxBonesBits == Max bone count: 0 = 32, 1 = 64, etc until 5 = 1024
+static TFShader * GetTransformFeedbackShaderProgram(UInt32 shaderChannelsMap, UInt32 bonesPerVertex, UInt32 maxBonesBits)
+{
+	// Check if already created
+	TFShaderMap::iterator itr = tfShaders.find(shaderChannelsMap + (bonesPerVertex << 16) + (maxBonesBits << 19));
+	if(itr != tfShaders.end())
+	{
+		return &(itr->second);
+	}
+
+	// There are only 3 different combinations, and they are always in order. We'll just cut the array length at the call site.
+	const char *varyings[] = {"out_pos", "out_normal", "out_tangent"};
+	GLuint varyingCount = 0;
+	int shaderIdx = 0;
+	if(shaderChannelsMap & kTFC_Tangent)
+	{
+		shaderIdx = TFSHADER_POSNORMTAN;
+		varyingCount = 3;
+	}
+	else if(shaderChannelsMap & kTFC_Normal)
+	{
+		shaderIdx = TFSHADER_POSNORM;
+		varyingCount = 2;
+	}
+	else
+	{
+		shaderIdx = TFSHADER_POS;
+		varyingCount = 1;
+	}
+
+	TFShader res;
+
+	GLint status = 0;
+	GLint shaderLen = 0;
+	const char *code;
+	int i;
+	// Create the fragment shader if it doesn't exist already
+	if(tfFragShader == 0)
+	{
+		tfFragShader = glCreateShader(GL_FRAGMENT_SHADER);
+		shaderLen = strlen(skinFS);
+		code = &skinFS[0];
+		GLES_CHK(glShaderSource(tfFragShader, 1, &code, &shaderLen));
+		GLES_CHK(glCompileShader(tfFragShader));
+		glGetShaderiv(tfFragShader, GL_COMPILE_STATUS, &status);
+		if(status != GL_TRUE)
+		{
+			char temp[512] = "";
+			GLint len = 512;
+			glGetShaderInfoLog(tfFragShader, 512, &len, temp );
+
+			printf_console("ERROR: Unable to compile Transform Feedback fragment shader!\n Error log:\n%s", temp);
+			return 0;
+		}
+	}
+	res.program = glCreateProgram();
+	res.vertShader = glCreateShader(GL_VERTEX_SHADER);
+	shaderLen = strlen(tfShaderSource[shaderIdx][bonesPerVertex-1][maxBonesBits]);
+	code = &tfShaderSource[shaderIdx][bonesPerVertex-1][maxBonesBits][0];
+	GLES_CHK(glShaderSource(res.vertShader, 1, &code, &shaderLen));
+	GLES_CHK(glCompileShader(res.vertShader));
+	glGetShaderiv(res.vertShader, GL_COMPILE_STATUS, &status);
+	if(status != GL_TRUE)
+	{
+		char temp[512] = "";
+		GLint len = 512;
+		glGetShaderInfoLog(res.vertShader, 512, &len, temp );
+
+		printf_console("ERROR: Unable to compile Transform Feedback vertex shader!\n Error log:\n%s", temp);
+		print_long_string(code);
+		return 0;
+	}
+	GLES_CHK(glAttachShader(res.program, res.vertShader));
+	GLES_CHK(glAttachShader(res.program, tfFragShader));
+
+	GLES_CHK(glTransformFeedbackVaryings(res.program, varyingCount, varyings, GL_INTERLEAVED_ATTRIBS));
+
+	GLES_CHK(glLinkProgram(res.program));
+
+	glGetProgramiv(res.program, GL_LINK_STATUS, &status);
+	if(status != GL_TRUE)
+	{
+		char temp[512] = "";
+		GLint len = 512;
+		glGetProgramInfoLog(res.program, 512, &len, temp );
+		printf_console("ERROR: Unable to link Transform Feedback shader! Error: \n%s", temp);
+		print_long_string(code);
+		return 0;
+	}
+
+#if USE_UNIFORM_BLOCK_FOR_BONES
+	res.bonesLocation = glGetUniformBlockIndex(res.program, "MtxBlock");
+#else
+	res.bonesLocation = glGetUniformLocation(res.program, "bones");
+#endif
+
+	// Get the attribute locations. Some of these may be missing so clear the glerror afterwards
+	for(i = 0; i < TFATTRLOC_SIZE; i++)
+	{
+		res.attribLocations[i] = glGetAttribLocation(res.program, tfShaderAttribNames[i]);
+	}
+	// Clear gl error
+	glGetError();
+
+	// Insert into map and return
+	return &(tfShaders.insert(std::make_pair(shaderChannelsMap + (bonesPerVertex << 16) + (maxBonesBits << 19), res)).first->second);
+
+}
+
+static void ReleaseShader(std::pair<UInt32, TFShader> it)
+{
+	it.second.Release();
+}
+
+void TransformFeedbackSkinningInfo::CleanupTransformFeedbackShaders(void)
+{
+	std::for_each(tfShaders.begin(), tfShaders.end(), ReleaseShader);
+	tfShaders.clear();
+
+	if(tfTransformFeedback)
+	{
+		glDeleteTransformFeedbacks(1, &tfTransformFeedback);
+		tfTransformFeedback = NULL;
+	}
+	if(tfFragShader)
+	{
+		glDeleteShader(tfFragShader);
+		tfFragShader = 0;
+	}
+}
+
+TransformFeedbackSkinningInfo::~TransformFeedbackSkinningInfo()
+{
+#define DEL_BUFFER(x) if(x != 0) { GLES_CHK(glDeleteBuffers(1, &x)); x = 0; }
+	DEL_BUFFER(m_SourceVBO);
+#undef DEL_BUFFER
+	if(m_MatrixBuffer)
+		m_MatrixBuffer->Release();
+}
+
+//! Get Vertex size in floats
+UInt32 TransformFeedbackSkinningInfo::GetVertexSize()
+{
+	// Vertex data size
+	UInt32 res = (GetStride() / 4);
+	// Add skin info size
+	if(GetBonesPerVertex() == 1)
+		return res + 1; // Index
+	else if(GetBonesPerVertex() == 2)
+		return res + 4; // 2 indices, 2 weights
+	else
+		return res + 8; // 4 indices, 4 weights
+}
+
+bool TransformFeedbackSkinningInfo::EnsureBuffer()
+{
+	bool dirty = false;
+	if(m_SourceVBO == 0)
+	{
+		GLES_CHK(glGenBuffers(1, &m_SourceVBO));
+		dirty = true;
+	}
+	GLsizei size = GetVertexSize() * GetVertexCount() * sizeof(float);
+	if(m_SourceVBOSize < size)
+	{
+		GLES_CHK(glBindBuffer(GL_UNIFORM_BUFFER, m_SourceVBO));
+		GLES_CHK(glBufferData(GL_UNIFORM_BUFFER, size, NULL, GL_STATIC_DRAW));
+		m_SourceVBOSize = size;
+		dirty = true;
+		GLES_CHK(glBindBuffer(GL_UNIFORM_BUFFER, 0));
+	}
+	return dirty;
+}
+
+
+void TransformFeedbackSkinningInfo::UpdateSourceData(const void *vertData, const BoneInfluence *skinData, bool dirty)
+{
+	dirty |= EnsureBuffer();
+
+	if(!dirty)
+		return;
+
+	std::vector<float> vboData;
+	vboData.resize(GetVertexSize() * GetVertexCount());
+
+	float *dest = &vboData[0];
+	float *vertsrc = (float *)vertData;
+	int vertsize = GetStride() / sizeof(float);
+	const BoneInfluence *bonesrc4 = skinData;
+	const BoneInfluence2 *bonesrc2 = (BoneInfluence2 *)skinData;
+	const int *bonesrc1 = (int *)skinData;
+
+	for(int i = 0; i < GetVertexCount(); i++)
+	{
+		std::copy(vertsrc, vertsrc+vertsize, dest);
+		dest += vertsize;
+		vertsrc += vertsize;
+		switch(GetBonesPerVertex())
+		{
+		default:
+		case 1:
+#if USE_INT_ATTRIBS
+			memcpy(dest, bonesrc1, sizeof(int));
+			dest++;
+			bonesrc1++;
+#else
+			*(dest++) = (float) *(bonesrc1++);
+#endif
+			break;
+		case 2:
+			// Copy weights
+			std::copy(&bonesrc2->weight[0], (&bonesrc2->weight[0])+2, dest);
+			dest += 2;
+#if USE_INT_ATTRIBS
+			memcpy(dest, &bonesrc2->boneIndex[0], sizeof(int)*2);
+			dest+= 2;
+#else
+			*(dest++) = (float) bonesrc2->boneIndex[0];
+			*(dest++) = (float) bonesrc2->boneIndex[1];
+#endif
+			bonesrc2++;
+
+			break;
+		case 4:
+			// Copy weights
+			std::copy(&bonesrc4->weight[0], (&bonesrc4->weight[0])+4, dest);
+			dest += 4;
+#if USE_INT_ATTRIBS
+			memcpy(dest, &bonesrc4->boneIndex[0], sizeof(int)*4);
+			dest+= 4;
+#else
+			*(dest++) = (float) bonesrc4->boneIndex[0];
+			*(dest++) = (float) bonesrc4->boneIndex[1];
+			*(dest++) = (float) bonesrc4->boneIndex[2];
+			*(dest++) = (float) bonesrc4->boneIndex[3];
+#endif
+			bonesrc4++;
+
+			break;
+		}
+	}
+	GLES_CHK(glBindBuffer(GL_UNIFORM_BUFFER, m_SourceVBO));
+	GLES_CHK(glBufferSubData(GL_UNIFORM_BUFFER, 0, vboData.size() * sizeof(float), &vboData[0]));
+	GLES_CHK(glBindBuffer(GL_UNIFORM_BUFFER, 0));
+
+}
+
+
+void TransformFeedbackSkinningInfo::UpdateSourceBones( const int boneCount, const Matrix4x4f* cachedPose )
+{
+	int i;
+	int inputSize = boneCount * 4 * 3 * sizeof(float);
+
+#if USE_UNIFORM_BLOCK_FOR_BONES
+	m_BoneCount = roundUpToNextPowerOf2(boneCount);
+#else
+	m_BoneCount = 82;
+#endif
+
+	UInt32 realBufSize = m_BoneCount * 4 * 3 * sizeof(float);
+
+	// This basically shouldn't happen but just in case (should be released in SkinMesh)
+	if(m_MatrixBuffer)
+	{
+		m_MatrixBuffer->Release();
+	}
+
+	float *dest = NULL;
+
+#if USE_UNIFORM_BLOCK_FOR_BONES
+	m_MatrixBuffer = GetBufferManagerGLES30()->AcquireBuffer(realBufSize, GL_DYNAMIC_DRAW);
+
+	if(gGraphicsCaps.gles30.useMapBuffer)
+	{
+		m_MatrixBuffer->RecreateStorage(realBufSize, GL_DYNAMIC_DRAW);
+		dest = (float *)m_MatrixBuffer->Map(0, realBufSize, GL_MAP_WRITE_BIT|GL_MAP_INVALIDATE_BUFFER_BIT);
+	}
+	else
+#endif
+	{
+		m_CachedPose.resize(realBufSize / sizeof(float));
+		dest = &m_CachedPose[0];
+	}
+	
+	int realBoneCount = boneCount;
+	if(boneCount > m_BoneCount)
+		realBoneCount = m_BoneCount;
+
+	for(i = 0; i < realBoneCount; i++)
+	{
+		Matrix4x4f mat = cachedPose[i];
+		mat.Transpose();
+		float *src = mat.GetPtr();
+		std::copy(src, src+12, dest);
+		dest+=12;
+	}
+
+#if USE_UNIFORM_BLOCK_FOR_BONES
+	if(gGraphicsCaps.gles30.useMapBuffer)
+	{
+		m_MatrixBuffer->Unmap();
+	}
+	else
+	{
+		m_MatrixBuffer->RecreateWithData(realBufSize, GL_DYNAMIC_DRAW, (void *)&m_CachedPose[0]);
+	}
+	m_MatrixBuffer->RecordUpdate();
+#endif
+}
+
+// In GfxDeviceGLES30.cpp
+void GLSLUseProgramGLES30(UInt32 programID);
+
+void TransformFeedbackSkinningInfo::SkinMesh( bool last )
+{
+
+	static GLuint s_WorkaroundTFBuf = 0;
+
+	// Qualcomm, srsly?
+	if(s_WorkaroundTFBuf == 0)
+	{
+		glGenBuffers(1, &s_WorkaroundTFBuf);
+		glBindBuffer(GL_COPY_WRITE_BUFFER, s_WorkaroundTFBuf);
+		glBufferData(GL_COPY_WRITE_BUFFER, 1024, NULL, GL_DYNAMIC_DRAW);
+		glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
+	}
+
+#if USE_UNIFORM_BLOCK_FOR_BONES
+	TFShader *shd = GetTransformFeedbackShaderProgram(GetChannelMap(), GetBonesPerVertex(), getBonesBits(m_BoneCount));
+#else
+	TFShader *shd = GetTransformFeedbackShaderProgram(GetChannelMap(), GetBonesPerVertex(), 0);
+#endif
+
+	Assert(shd);
+
+	GLuint tf = GetTransformFeedbackObject();
+	GLES3VBO *vbo = static_cast<GLES3VBO *>(GetDestVBO());
+	GLuint glvbo = vbo->GetSkinningTargetVBO();
+
+	GLES_CHK(glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, glvbo));
+
+
+	GLSLUseProgramGLES30(shd->program);
+
+#if USE_UNIFORM_BLOCK_FOR_BONES
+	GLES_CHK(glUniformBlockBinding(shd->program, shd->bonesLocation, 0));
+
+	if(m_MatrixBuffer)
+		GLES_CHK(glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_MatrixBuffer->GetBuffer()));
+#else
+
+	GLES_CHK(glUniform4fv(shd->bonesLocation, m_CachedPose.size() / 4, &m_CachedPose[0]));
+#endif
+
+	GLES_CHK(glBindBuffer(GL_ARRAY_BUFFER, m_SourceVBO));
+	GLuint stride = GetVertexSize() * sizeof(float);
+	GLES_CHK(glVertexAttribPointer(shd->attribLocations[TFATTRLOC_POS], 3, GL_FLOAT, GL_FALSE, stride, 0));
+	GLES_CHK(glEnableVertexAttribArray(shd->attribLocations[TFATTRLOC_POS]));
+
+	GLuint nextoffs = 12;
+
+	if(GetChannelMap() & kTFC_Normal)
+	{
+		GLES_CHK(glVertexAttribPointer(shd->attribLocations[TFATTRLOC_NORM], 3, GL_FLOAT, GL_FALSE, stride, (void *)nextoffs));
+		GLES_CHK(glEnableVertexAttribArray(shd->attribLocations[TFATTRLOC_NORM]));
+		nextoffs += 12;
+	}
+	if(GetChannelMap() & kTFC_Tangent)
+	{
+		GLES_CHK(glVertexAttribPointer(shd->attribLocations[TFATTRLOC_TAN], 4, GL_FLOAT, GL_FALSE, stride, (void *)nextoffs));
+		GLES_CHK(glEnableVertexAttribArray(shd->attribLocations[TFATTRLOC_TAN]));
+		nextoffs += 16;
+	}
+
+	switch(GetBonesPerVertex())
+	{
+	default:
+	case 1:
+#if USE_INT_ATTRIBS
+		GLES_CHK(glVertexAttribIPointer(shd->attribLocations[TFATTRLOC_BONEIDX], 1, GL_INT, stride, (void *)nextoffs));	
+#else
+		GLES_CHK(glVertexAttribPointer(shd->attribLocations[TFATTRLOC_BONEIDX], 1, GL_FLOAT, GL_FALSE, stride, (void *)nextoffs));	
+#endif
+		GLES_CHK(glEnableVertexAttribArray(shd->attribLocations[TFATTRLOC_BONEIDX]));
+
+		break;
+	case 2:
+		GLES_CHK(glVertexAttribPointer(shd->attribLocations[TFATTRLOC_BONEWEIGHT], 2, GL_FLOAT, GL_FALSE, stride,(void *)nextoffs));
+		GLES_CHK(glEnableVertexAttribArray(shd->attribLocations[TFATTRLOC_BONEWEIGHT]));
+		nextoffs += 8;
+#if USE_INT_ATTRIBS
+		GLES_CHK(glVertexAttribIPointer(shd->attribLocations[TFATTRLOC_BONEIDX], 2, GL_INT, stride, (void *)nextoffs));	
+#else
+		GLES_CHK(glVertexAttribPointer(shd->attribLocations[TFATTRLOC_BONEIDX], 2, GL_FLOAT, GL_FALSE, stride, (void *)nextoffs));	
+#endif
+		GLES_CHK(glEnableVertexAttribArray(shd->attribLocations[TFATTRLOC_BONEIDX]));
+		break;
+
+	case 4:
+		GLES_CHK(glVertexAttribPointer(shd->attribLocations[TFATTRLOC_BONEWEIGHT], 4, GL_FLOAT, GL_FALSE, stride,(void *)nextoffs));
+		GLES_CHK(glEnableVertexAttribArray(shd->attribLocations[TFATTRLOC_BONEWEIGHT]));
+		nextoffs += 16;
+#if USE_INT_ATTRIBS
+		GLES_CHK(glVertexAttribIPointer(shd->attribLocations[TFATTRLOC_BONEIDX], 4, GL_INT, stride, (void *)nextoffs));	
+#else
+		GLES_CHK(glVertexAttribPointer(shd->attribLocations[TFATTRLOC_BONEIDX], 4, GL_FLOAT,GL_FALSE,  stride, (void *)nextoffs));	
+#endif
+		GLES_CHK(glEnableVertexAttribArray(shd->attribLocations[TFATTRLOC_BONEIDX]));
+
+		break;
+	}
+
+	GLES_CHK(glBeginTransformFeedback(GL_POINTS));
+
+	GLES_CHK(glEnable(GL_RASTERIZER_DISCARD));
+	GLES_CHK(glDrawArrays(GL_POINTS, 0, GetVertexCount()));
+	GLES_CHK(glDisable(GL_RASTERIZER_DISCARD));
+
+	GLES_CHK(glEndTransformFeedback());
+	
+
+	GLES_CHK(glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, s_WorkaroundTFBuf));
+	GLES_CHK(glBindBuffer(GL_ARRAY_BUFFER, 0));
+
+#if USE_UNIFORM_BLOCK_FOR_BONES
+
+	GLES_CHK(glBindBufferBase(GL_UNIFORM_BUFFER, 0, 0));
+	if(m_MatrixBuffer)
+	{
+		m_MatrixBuffer->RecordRender();
+		m_MatrixBuffer->Release();
+		m_MatrixBuffer = NULL;
+	}
+#endif
+	InvalidateVertexInputCacheGLES30();
+}