+Unity Runtime codeHEADmaster

1 files changed, 438 insertions, 0 deletions

diff --git a/Runtime/GfxDevice/opengles20/_DebugStuffGLES20.cpp b/Runtime/GfxDevice/opengles20/_DebugStuffGLES20.cpp
new file mode 100644
index 0000000..a72f01a
--- /dev/null
+++ b/Runtime/GfxDevice/opengles20/_DebugStuffGLES20.cpp
@@ -0,0 +1,438 @@
+#include "UnityPrefix.h"
+#include "AssertGLES20.h"
+#include "IncludesGLES20.h"
+#include "Runtime/Math/Matrix4x4.h"
+#include "_DebugStuffGLES20.h"
+#include "VBOGLES20.h"
+
+void PrintMatrix(const char* name, const Matrix4x4f& m)
+{
+	printf_console("Outputing:%s\n------------\n"
+		"mat4 mat = (%.2f, %.2f, %.2f, %2f,\n"
+		"%.2f, %.2f, %.2f, %2f,\n"
+		"%.2f, %.2f, %.2f, %2f,\n"
+		"%.2f, %.2f, %.2f, %2f);\n\n",name,
+		m[0],	m[1],	m[2],	m[3],
+		m[4],	m[5],	m[6],	m[7],
+		m[8],	m[9],	m[10],	m[11],
+		m[12],	m[13],	m[14],	m[15]);
+}
+void _Debug::MiniLoopGLES20()
+{
+
+		#define VERTEX_ARRAY	0
+	float pfIdentity[] =
+	{
+		1.0f,0.0f,0.0f,0.0f,
+		0.0f,1.0f,0.0f,0.0f,
+		0.0f,0.0f,1.0f,0.0f,
+		0.0f,0.0f,0.0f,1.0f
+	};
+
+	// Fragment and vertex shaders code
+	char* pszFragShader = "\
+		void main (void)\
+		{\
+			gl_FragColor = vec4(1.0, 1.0, 0.66 ,1.0);\
+		}";
+	char* pszVertShader = "\
+		attribute highp vec3	myVertex;\
+		uniform mediump mat4	myPMVMatrix;\
+		void main(void)\
+		{\
+		gl_Position = myPMVMatrix * vec4(myVertex,1.0);\
+		}";
+
+
+		GLuint uiFragShader, uiVertShader;		/* Used to hold the fragment and vertex shader handles */
+	GLuint uiProgramObject;					/* Used to hold the program handle (made out of the two previous shaders */
+
+	// Create the fragment shader object
+	uiFragShader = glCreateShader(GL_FRAGMENT_SHADER);
+
+	// Load the source code into it
+	glShaderSource(uiFragShader, 1, (const char**)&pszFragShader, NULL);
+
+	// Compile the source code
+	glCompileShader(uiFragShader);
+
+	// Check if compilation succeeded
+	GLint bShaderCompiled;
+	bShaderCompiled = 0;
+    glGetShaderiv(uiFragShader, GL_COMPILE_STATUS, &bShaderCompiled);
+
+	if (!bShaderCompiled)
+	{
+#ifndef NO_GDI
+		// An error happened, first retrieve the length of the log message
+		int i32InfoLogLength, i32CharsWritten;
+		glGetShaderiv(uiFragShader, GL_INFO_LOG_LENGTH, &i32InfoLogLength);
+
+		// Allocate enough space for the message and retrieve it
+		char* pszInfoLog = new char[i32InfoLogLength];
+        glGetShaderInfoLog(uiFragShader, i32InfoLogLength, &i32CharsWritten, pszInfoLog);
+
+		printf_console(pszInfoLog);
+		// Displays the error in a dialog box
+		delete[] pszInfoLog;
+#endif
+		return;
+	}
+
+	// Loads the vertex shader in the same way
+	uiVertShader = glCreateShader(GL_VERTEX_SHADER);
+	glShaderSource(uiVertShader, 1, (const char**)&pszVertShader, NULL);
+	glCompileShader(uiVertShader);
+    glGetShaderiv(uiVertShader, GL_COMPILE_STATUS, &bShaderCompiled);
+	if (!bShaderCompiled)
+	{
+#ifndef NO_GDI
+		int i32InfoLogLength, i32CharsWritten;
+		glGetShaderiv(uiVertShader, GL_INFO_LOG_LENGTH, &i32InfoLogLength);
+		char* pszInfoLog = new char[i32InfoLogLength];
+        glGetShaderInfoLog(uiVertShader, i32InfoLogLength, &i32CharsWritten, pszInfoLog);
+		printf_console(pszInfoLog);
+		delete[] pszInfoLog;
+#endif
+		return;
+	}
+
+	// Create the shader program
+    uiProgramObject = glCreateProgram();
+	// Bind the custom vertex attribute "myVertex" to location VERTEX_ARRAY
+    glBindAttribLocation(uiProgramObject, VERTEX_ARRAY, "myVertex");
+	// Attach the fragment and vertex shaders to it
+    glAttachShader(uiProgramObject, uiFragShader);
+    glAttachShader(uiProgramObject, uiVertShader);
+
+
+
+	// Link the program
+    glLinkProgram(uiProgramObject);
+
+	// Check if linking succeeded in the same way we checked for compilation success
+    GLint bLinked;
+    glGetProgramiv(uiProgramObject, GL_LINK_STATUS, &bLinked);
+	if (!bLinked)
+	{
+#ifndef NO_GDI
+		int i32InfoLogLength, i32CharsWritten;
+		glGetProgramiv(uiProgramObject, GL_INFO_LOG_LENGTH, &i32InfoLogLength);
+		char* pszInfoLog = new char[i32InfoLogLength];
+		glGetProgramInfoLog(uiProgramObject, i32InfoLogLength, &i32CharsWritten, pszInfoLog);
+		printf_console(pszInfoLog);
+		delete[] pszInfoLog;
+#endif
+		return;
+	}
+
+
+		// Actually use the created program
+    glUseProgram(uiProgramObject);
+	GLESAssert();
+
+	// Sets the clear color.
+	// The colours are passed per channel (red,green,blue,alpha) as float values from 0.0 to 1.0
+	glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
+	GLESAssert();
+
+	// We're going to draw a triangle to the screen so create a vertex buffer object for our triangle
+	GLuint	ui32Vbo; // Vertex buffer object handle
+	
+	// Interleaved vertex data
+	GLfloat afVertices[] = {	-0.1f,-0.4f,0.0f, // Position
+								0.4f ,-0.4f,0.0f,
+								0.0f ,0.4f ,0.0f};
+
+	// Generate the vertex buffer object (VBO)
+	glGenBuffers(1, &ui32Vbo);
+	GLESAssert();
+
+	// Bind the VBO so we can fill it with data
+	glBindBuffer(GL_ARRAY_BUFFER, ui32Vbo);
+	GLESAssert();
+
+	// Set the buffer's data
+	unsigned int uiSize = 3 * (sizeof(GLfloat) * 3); // Calc afVertices size (3 vertices * stride (3 GLfloats per vertex))
+	glBufferData(GL_ARRAY_BUFFER, uiSize, afVertices, GL_STATIC_DRAW);
+	GLESAssert();
+
+	glClearDepthf(1.0f);									
+	glEnable(GL_DEPTH_TEST);							
+	glDepthFunc(GL_LEQUAL);	
+	glDisable(GL_CULL_FACE);
+	printf_console("Loop launched\n");
+	while (1) 
+	{
+		glClearColor(1.0f, 1.0f, 0.0f, 1.0f);
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+		GLESAssert();
+
+
+		/*
+			Bind the projection model view matrix (PMVMatrix) to
+			the associated uniform variable in the shader
+		*/
+
+		// First gets the location of that variable in the shader using its name
+		int i32Location = glGetUniformLocation(uiProgramObject, "myPMVMatrix");
+
+		// Then passes the matrix to that variable
+		glUniformMatrix4fv( i32Location, 1, GL_FALSE, pfIdentity);
+		GLESAssert();
+
+		/*
+			Enable the custom vertex attribute at index VERTEX_ARRAY.
+			We previously binded that index to the variable in our shader "vec4 MyVertex;"
+		*/
+		glEnableVertexAttribArray(VERTEX_ARRAY);
+		GLESAssert();
+
+		// Sets the vertex data to this attribute index
+		glVertexAttribPointer(VERTEX_ARRAY, 3, GL_FLOAT, GL_FALSE, 0, 0);
+
+		/*
+			Draws a non-indexed triangle array from the pointers previously given.
+			This function allows the use of other primitive types : triangle strips, lines, ...
+			For indexed geometry, use the function glDrawElements() with an index list.
+		*/
+		glDrawArrays(GL_TRIANGLES, 0, 3);
+		GLESAssert();
+
+		void PresentContextGLES();
+		PresentContextGLES();
+   }
+}
+int	_Debug::CreateDefaultShader (bool texturing)
+{
+	char* strVertexShader = NULL;
+	char* strFragmentShader = NULL;
+	if (texturing)
+	{
+		strVertexShader = 
+			"attribute highp vec3 _glesVertex;\n"
+			"attribute highp vec4 _glesUV0;\n"
+			"uniform mediump mat4 _glesMVP;\n"
+			"varying mediump vec2 _glesVarUV0;\n"
+			"void main(void)\n"
+			"{\n"
+			"	gl_Position = _glesMVP * vec4(_glesVertex,1.0);\n"
+			"	_glesVarUV0 = _glesUV0.st;\n"
+			"}";
+
+		strFragmentShader = 
+			"uniform sampler2D texDiffuse;\n"
+			"varying mediump vec2 _glesVarUV0;\n"
+			"void main (void)\n"
+			"{\n"
+			"	gl_FragColor = texture2D(texDiffuse, _glesVarUV0);\n"
+			"}";
+	}
+	else
+	{
+		strVertexShader = 
+			"attribute highp vec3 _glesVertex;\n"
+			"uniform mediump mat4 _glesMVP;\n"
+			"void main(void)\n"
+			"{\n"
+			"	gl_Position = _glesMVP * vec4(_glesVertex,1.0);\n"
+			"}";
+
+
+		strFragmentShader = 
+			"void main (void)\n"
+			"{\n"
+			"	gl_FragColor = vec4(1.0, 1.0, 0.66 ,1.0);\n"
+			"}";
+
+	}
+	return CreateShader(strVertexShader, strFragmentShader);
+
+}
+int	_Debug::CreateShader(const char* vertexShader, const char* fragmenShader)
+{
+	GLuint vertShader, fragShader;
+	GLuint shader;
+
+	GLint compiled, linked;
+	
+	//Vertex shader
+	GLES_CHK(vertShader = glCreateShader(GL_VERTEX_SHADER));
+	GLES_CHK(glShaderSource(vertShader, 1, (const char**)&vertexShader, NULL));
+	GLES_CHK(glCompileShader(vertShader));
+
+	compiled = 0;
+    GLES_CHK(glGetShaderiv(vertShader, GL_COMPILE_STATUS, &compiled));
+
+	if (!compiled)
+	{
+		int i32InfoLogLength, i32CharsWritten;
+		GLES_CHK(glGetShaderiv(vertShader, GL_INFO_LOG_LENGTH, &i32InfoLogLength));
+		char* pszInfoLog = new char[i32InfoLogLength];
+        GLES_CHK(glGetShaderInfoLog(vertShader, i32InfoLogLength, &i32CharsWritten, pszInfoLog));
+		printf_console(pszInfoLog);
+		delete[] pszInfoLog;
+		return 0;
+	}
+
+	//Fragment shader
+	GLES_CHK(fragShader = glCreateShader(GL_FRAGMENT_SHADER));
+	GLES_CHK(glShaderSource(fragShader, 1, (const char**)&fragmenShader, NULL));
+	GLES_CHK(glCompileShader(fragShader));
+
+	compiled = 0;
+    GLES_CHK(glGetShaderiv(fragShader, GL_COMPILE_STATUS, &compiled));
+
+	if (!compiled)
+	{
+		int i32InfoLogLength, i32CharsWritten;
+		GLES_CHK(glGetShaderiv(fragShader, GL_INFO_LOG_LENGTH, &i32InfoLogLength));
+		char* pszInfoLog = new char[i32InfoLogLength];
+        GLES_CHK(glGetShaderInfoLog(fragShader, i32InfoLogLength, &i32CharsWritten, pszInfoLog));
+		printf_console(pszInfoLog);
+		delete[] pszInfoLog;
+		return 0;
+	}
+
+	// Final Step, attacha and link shaders
+    shader = glCreateProgram();
+    (glBindAttribLocation(shader, GL_VERTEX_ARRAY, "_glesVertex"));
+	(glBindAttribLocation(shader, GL_TEXTURE_ARRAY0, "_glesUV0"));
+
+    GLES_CHK(glAttachShader(shader, fragShader));
+    GLES_CHK(glAttachShader(shader, vertShader));
+    GLES_CHK(glLinkProgram(shader));
+
+	linked = 0;
+    GLES_CHK(glGetProgramiv(shader, GL_LINK_STATUS, &linked));
+	if (!linked)
+	{
+		int i32InfoLogLength, i32CharsWritten;
+		GLES_CHK(glGetProgramiv(shader, GL_INFO_LOG_LENGTH, &i32InfoLogLength));
+		char* pszInfoLog = new char[i32InfoLogLength];
+		GLES_CHK(glGetProgramInfoLog(shader, i32InfoLogLength, &i32CharsWritten, pszInfoLog));
+		printf_console(pszInfoLog);
+		delete[] pszInfoLog;
+		return 0;
+	}
+	return shader;
+}
+
+int	_Debug::CreateDefaultVBO	(bool texCoords)
+{
+	float verts[] = 
+	{
+		-0.5f, -0.5f, 0.0f,
+		 0.5f, -0.5f, 0.0f,
+		 0.5f,  0.5f, 0.0f,
+		-0.5f, -0.5f, 0.0f,
+		 0.5f,  0.5f, 0.0f,
+	    -0.5f,  0.5f, 0.0f
+	};
+
+	float vertsUV[] = 
+	{
+		-0.5f, -0.5f, 0.0f,
+		 0.0f,  0.0f, 
+		 0.5f, -0.5f, 0.0f,
+		 1.0f,  0.0f, 
+		 0.5f,  0.5f, 0.0f,
+		 1.0f,  1.0f, 
+		-0.5f, -0.5f, 0.0f,
+		 0.0f,  0.0f, 
+		 0.5f,  0.5f, 0.0f,
+		 1.0f,  1.0f, 
+	    -0.5f,  0.5f, 0.0f,
+		 0.0f,  1.0f, 
+	};
+
+	if (texCoords)
+	{
+		return CreateVBO(vertsUV, 6, sizeof(float) * 5);
+	}
+	else
+	{
+		return CreateVBO(vertsUV, 6, sizeof(float) * 3);
+	}
+}
+
+
+int	_Debug::CreateVBO(const float* data, int vertexCount, int vertexSize)
+{
+	GLuint vbo;
+	GLES_CHK(glGenBuffers(1, &vbo));
+	GLES_CHK(glBindBuffer(GL_ARRAY_BUFFER, vbo));
+	GLES_CHK(glBufferData(GL_ARRAY_BUFFER, vertexSize * vertexCount, data, GL_STATIC_DRAW));
+	GLES_CHK(glBindBuffer(GL_ARRAY_BUFFER, 0));
+	return vbo;
+}
+
+void _Debug::SetUniformMatrix4x4f(int shaderID, const char* name, const Matrix4x4f& mat)
+{
+	int loc ;
+	GLES_CHK(loc = glGetUniformLocation(shaderID, name));
+
+	if (loc != -1)GLES_CHK(glUniformMatrix4fv(loc, 1, GL_FALSE, mat.GetPtr()));
+	else printf_console("Failed to find uniform %s\n", name);
+}
+void _Debug::SetUniformSample2D  (int shaderID, const char* name, int texUnit)
+{
+	int loc ;
+	GLES_CHK(loc = glGetUniformLocation(shaderID, name));
+
+	if (loc != -1)GLES_CHK(glUniform1i(loc, texUnit));
+	else printf_console("Failed to find uniform %s\n", name);
+}
+void _Debug::UseShader(int shaderID)
+{
+	GLES_CHK(glUseProgram(shaderID));
+}
+void _Debug::DrawVBO(int vboID, int vertexCount, bool texCoords)
+{
+	GLES_CHK(glBindBuffer(GL_ARRAY_BUFFER, vboID));
+	if (texCoords)
+	{
+		glEnableVertexAttribArray(GL_VERTEX_ARRAY);
+		glVertexAttribPointer(GL_VERTEX_ARRAY, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, 0);
+		glEnableVertexAttribArray(GL_TEXTURE_ARRAY0);
+		glVertexAttribPointer(GL_TEXTURE_ARRAY0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, (void*) (3 * sizeof(GLfloat)));
+
+		GLES_CHK(glDrawArrays(GL_TRIANGLES, 0, vertexCount));
+		
+		GLES_CHK(glDisableVertexAttribArray(GL_VERTEX_ARRAY));
+		GLES_CHK(glDisableVertexAttribArray(GL_TEXTURE_ARRAY0));
+	}
+	else
+	{
+		GLES_CHK(glEnableVertexAttribArray(GL_VERTEX_ARRAY));
+		GLES_CHK(glVertexAttribPointer(VERTEX_ARRAY, 3, GL_FLOAT, GL_FALSE, 0, 0));
+		GLES_CHK(glDrawArrays(GL_TRIANGLES, 0, vertexCount));
+		GLES_CHK(glDisableVertexAttribArray(GL_VERTEX_ARRAY));
+	}
+	GLES_CHK(glBindBuffer(GL_ARRAY_BUFFER, 0));
+}
+void _Debug::DisplayTextureMiniLoop(int textureID)
+{
+	bool texCoords = true;
+	int vbo = CreateDefaultVBO(texCoords);
+	int shader = CreateDefaultShader(texCoords);
+	GLES_CHK(glDisable(GL_DEPTH_TEST));							
+	GLES_CHK(glDisable(GL_CULL_FACE));
+	GLES_CHK(glDisable(GL_BLEND));
+	GLES_CHK(glBindFramebuffer (GL_FRAMEBUFFER, 0));
+	while (1) 
+	{
+		GLES_CHK(glClearColor(1.0f, 1.0f, 0.0f, 1.0f));
+		GLES_CHK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
+		GLES_CHK(glActiveTexture(GL_TEXTURE0));
+		GLES_CHK(glBindTexture(GL_TEXTURE_2D, textureID));
+		
+		UseShader(shader);
+		SetUniformMatrix4x4f(shader, "_glesMVP", Matrix4x4f::identity);
+		SetUniformSample2D(shader, "texDiffuse", 0);
+		DrawVBO(vbo, 6, texCoords);
+
+		void PresentContextGLES();
+		PresentContextGLES();
+	}
+}
\ No newline at end of file