// NOTE- TEXTURE LOADING DISABLED (uses a dummy procedural tex. see "getTexture", replace it..
// compile & run on linux:
// g++ torusdemosdl.cpp -std=c++1y -lGLU -lXext -lGL -lSDL2 -lrt -lm -lpthread -o torusdemosdl && ./torusdemosdl

#include <math.h>
#include <string.h>
#define PI M_PI
#include <vector>
#include <array>

#include <SDL2/SDL.h>

#define GL_GLEXT_PROTOTYPES 1
//#include <SDL2/SDL_opengles2.h>
#include <SDL2/SDL_opengl.h>

using namespace std;
#ifndef GFX_LOGI
#define GFX_LOGI(X,...)
#endif

#define GFX_ERROR(X) printf("error");

enum
{	VertexAttrIndex_pos,VertexAttrIndex_color,VertexAttrIndex_norm,VertexAttrIndex_tex0,VertexAttrIndex_tex1,VertexAttrIndex_count
};



struct	TestVertex
{
	array<float,3>	pos;
	array<float,4>	color;
	array<float,3>	norm;
	array<float,2>	tex0;
};


struct	Mesh
{
	typedef int IndexType;
	enum {IndexSize = sizeof(IndexType) };
	int	vertexSize;
	typedef	::TestVertex Vertex;
	int	vbo;
	int	ibo;
	int	numVertices,numIndices;
};

int	g_Texture[5];
int	g_ShaderProgram,g_PixelShader,g_VertexShader;


inline auto SetMatrixProjectionFrustumDemo(float m[16], float left, float right, float bottom, float top, float fnear, float ffar)->void
{
    auto a=(right+left)/(right-left);
    auto b=(top+bottom)/(top-bottom);
    auto c=-(ffar+fnear)/(ffar-fnear);
    auto d=-(2*ffar*fnear/(ffar-fnear));
#define STORE4(D,I, X,Y,Z,W) (D)[0+I]=X; (D)[4+I]=Y; (D)[8+I]=Z; (D)[12+I]=W;
    STORE4(m,0, 2.f*fnear/(right-left), 0.f,0.f,0.f);
    STORE4(m,1, 0.f, 2.f*fnear/(top-bottom), 0.f,0.f);
    STORE4(m,2, a,b,c,-1.f);
    STORE4(m,3, 0.f,0.f,d,0.f);
#undef STORE4
}



int
GFX_CreateAndCompileShader(int shaderType, const char* source)
{
	int	shader = glCreateShader(shaderType);
	const char* pSrc[1]={source};
	int length[1] = {(int)strlen(source)};
	glShaderSource(shader, 1,pSrc,length);
	glCompileShader(shader);
	int	status;glGetShaderiv(shader,GL_COMPILE_STATUS,&status);
	if (status==GL_FALSE)
	{
		char	log[512]; int len;
		glGetShaderInfoLog(shader, 512,&len, log);
		printf("\n%s\n", source, log);
		printf("compile shader[%d] failed: \n%s\n", shader, log);
		exit (0);
	}
	else printf("create shader[%d] - compile suceeded\n",  shader);
	return	shader;
}

struct	ShaderProg;
struct	VertexShader
{
	const char*	name;
	const char*	source;
	VertexShader*	next;
	VertexShader*	nextOfProg;
	ShaderProg*		progsUsingMe;
};
struct	PixelShader
{
	const char*	name;
	const char* source;
	PixelShader*	next;
	PixelShader*	nextOfProg;
	ShaderProg*		progsUsingMe;
};
struct	ShaderProg
{
	ShaderProg*	next;
	ShaderProg*		vertexShader;
	PixelShader*	pixelShader;
//	VertexAttr		vta;
//	UniformTable			uniforms;
};

// Paired pixel and vertex shaders.

PixelShader*	g_PixelShaders;
VertexShader*	g_VertexShaders;
ShaderProg*	g_ShaderProgs;

struct ShaderProgRet {
	int pixel_shader;
	int vertex_shader;
	int program;
};

ShaderProgRet	GFX_CreateShaderProgram(
			const char* pixelShaderSource,
			const char* vertexShaderSource,
			int* pixelShaderOut,
			int* vertexShaderOut,
			int* programOut)
{
	*vertexShaderOut = GFX_CreateAndCompileShader(GL_VERTEX_SHADER, vertexShaderSource);
	*pixelShaderOut = GFX_CreateAndCompileShader(GL_FRAGMENT_SHADER, pixelShaderSource);
	int	prog = glCreateProgram();
	// assign attribute names before linking

	glAttachShader(prog, *pixelShaderOut);
	glAttachShader(prog, *vertexShaderOut);


	printf("linking verteshader[%d], pixelshader[%d] to program[%d]\n", *vertexShaderOut, *pixelShaderOut, prog);
	glLinkProgram(prog);

	int err;
	glGetProgramiv(prog,GL_LINK_STATUS,&err);
	if (err==GL_INVALID_VALUE || err==GL_INVALID_OPERATION) {
		char buffer[1024];int len;
		glGetProgramInfoLog(*programOut,1024,&len,buffer);
		printf("link program failed:");
		printf("%s", buffer);
	} else printf("link program status %d\n", err);
	*programOut = prog;
	return ShaderProgRet{*pixelShaderOut,*vertexShaderOut,prog};
}

//TODO: split into default uniforms, default vertex, default vertex-shader-out

#define PS_VS_INTERFACE0 \
"varying	vec4 v_pos;\n" \
"varying	vec4 v_color;\n" \
"varying	vec3 v_norm;\n" \
"varying	vec2 v_tex0;\n" \
"varying	vec3 v_tex1;\n" \
"varying	vec4 v_tangent;\n"\
"varying	vec4 v_binormal;\n"


#define PS_VERTEX_FORMAT0 \
"layout(location=0) in vec3 a_pos;\n" \
"layout(location=1) in vec4 a_color;\n" \
"layout(location=2) in vec3 a_norm;\n" \
"layout(location=3) in vec2 a_tex0;\n" \

#define SHADER_UNIFORMS \
"layout(location=0) uniform mat4 uMatProj;\n" \
"layout(location=4) uniform mat4 uMatModelView;\n" \
"layout(location=8) uniform vec4 uAmbient;\n" \
"layout(location=9) uniform vec4 uDiffuseDX;\n" \
"layout(location=10) uniform vec4 uDiffuseDY;\n" \
"layout(location=11) uniform vec4 uDiffuseDZ;\n" \
"layout(location=12) uniform vec4 uFogColor;\n" \
"layout(location=13) uniform vec4 uFogFalloff;\n" \
"layout(location=14) uniform vec4 uSpecularDir;\n" \
"layout(location=15) uniform float uSpecularPower;\n" \
"layout(location=16) uniform vec4 uSpecularColor;\n" \
"layout(location=17) uniform vec4 uLightPos;\n" \
"layout(location=18) uniform vec4 uLightColor;\n" \
"layout(location=19) uniform vec4 uLightFalloff;\n" \
"layout(location=20) uniform sampler2D uTex0;" \
"layout(location=21) uniform sampler2D uTex1;" \


const char g_VS_Default[]=
"#version 330\n"
"#extension GL_ARB_explicit_uniform_location : require\n"
"#define varying out\n"
PS_VERTEX_FORMAT0
PS_VS_INTERFACE0
SHADER_UNIFORMS
"void main() {\n"
"	vec4 epos = uMatModelView * vec4(a_pos.xyz,1.0);\n"
"	vec3 enorm = (uMatModelView * vec4(a_norm.xyz,0.0)).xyz;\n"
"	vec4 spos=uMatProj * epos;\n"
"	gl_Position = spos;\n"
"	v_pos = epos;\n"
"	v_color = a_color;\n"
"	v_tex0 = a_tex0;\n"
"	v_tex1 = a_pos.xyz;\n"
"	v_norm = enorm;\n"
"}";

const char g_VS_PassThru[]=
"#version 330\n"
"#extension GL_ARB_explicit_uniform_location : require\n"
"#define varying out\n"
PS_VERTEX_FORMAT0
PS_VS_INTERFACE0
SHADER_UNIFORMS
"void main() {\n"
"	vec4 epos = uMatModelView * vec4(a_pos.xyz,1.0);\n"
"	vec3 enorm = (uMatModelView * vec4(a_norm.xyz,0.0)).xyz;\n"
"	vec4 spos=uMatProj * epos;\n"
"	gl_Position = vec4(a_pos.xyz,1.0);\n"
"	v_pos = epos;\n"
"	v_color = a_color;\n"
"	v_tex0 = a_tex0;\n"
"	v_tex1 = a_pos.xyz;\n"
"	v_norm = enorm;\n"
"}";

/*
cases:
VSO:
	static scene
	animation,3bone
PS:
	2textures
	3textures
 */

const char g_PS_Alpha[]=
"#version 330\n"
"#extension GL_ARB_explicit_uniform_location : require\n"
"#define varying in\n"
PS_VS_INTERFACE0
SHADER_UNIFORMS

"vec4 applyFog(vec3 pos, vec4 color){\n"
"	return mix(color,uFogColor,  clamp(-uFogFalloff.x-pos.z*uFogFalloff.y,0.0,1.0));\n"
"}\n"
"vec4 pointlight(vec3 pos, vec3 norm,vec3 lpos, vec4 color, vec4 falloff) {\n"
"	vec3 dv=lpos-pos;\n"
"	float d2=sqrt(dot(dv,dv));\n"
"	float f=clamp( 1.0-(d2/falloff.x),0.0,1.0);\n"
"	vec3 lv=normalize(dv);\n"
"	return clamp(dot(lv,norm),0.0,1.0) * f*color;\n"
"}\n"
"void main() { \n"
"	float inva=(v_color.w),a=(1-v_color.w);\n"
"	vec4 t0=texture2D(uTex0, v_tex0);\n"
"	vec4 t1=texture2D(uTex1, v_tex0);\n"
"	float a0=t0.x*0.4+t0.y*0.6+t0.z*0.25;\n"
"	float a1=t1.x*0.4+t1.y*0.6+t1.z*0.25;\n"
"	float highlight=max(0.f,dot(v_norm,uSpecularDir.xyz));"
	"	highlight=(highlight*highlight);highlight=highlight*highlight;"
"	vec4 surfaceColor=mix(t0,t1,v_color.w);\n"
"	vec4 surfaceSpec=clamp(4*(surfaceColor-vec4(0.5,0.5,0.5,0.0)), vec4(0.0,0.0,0.0,0.0),vec4(1.0,1.0,1.0,1.0));\n"
"	vec4 spec=highlight*uSpecularColor*surfaceSpec;\n"
"	vec4 diff=uAmbient+v_norm.x*uDiffuseDX+v_norm.y*uDiffuseDY+v_norm.z*uDiffuseDZ;\n"
"	float lx=0.5,ly=0.5;\n"
"	diff+=pointlight(v_pos.xyz,v_norm.xyz, vec3(lx,ly,-1.0),		vec4(1.0,0.0,0.0,0.0),vec4(1.0,0.0,0.0,0.0));\n"
"	diff+=pointlight(v_pos.xyz,v_norm.xyz, vec3(lx,-ly,-1.0), 	vec4(0.0,1.0,0.0,0.0),vec4(1.0,0.0,0.0,0.0));\n"
"	diff+=pointlight(v_pos.xyz,v_norm.xyz, vec3(-lx,-ly,-1.0),	vec4(0.0,0.0,1.0,0.0),vec4(1.0,0.0,0.0,0.0));\n"
"	diff+=pointlight(v_pos.xyz,v_norm.xyz, vec3(-lx,ly,-1.0), 	vec4(0.5,0.0,0.5,0.0),vec4(1.0,0.0,0.0,0.0));\n"
"	gl_FragColor = applyFog(v_pos.xyz,surfaceColor*diff*vec4(v_color.xyz,0.0)*2.f+spec);\n"
"}";

const char g_PS_Add[]=
"#version 330\n"
"#extension GL_ARB_explicit_uniform_location : require\n"
"#define varying in\n"
PS_VS_INTERFACE0
SHADER_UNIFORMS
"void main() { \n"
"	float inva=(v_color.w),a=(1-v_color.w);\n"
"	vec4 t0=texture2D(s_Tex0, v_tex0);\n"
"	vec4 t1=texture2D(s_Tex1, v_tex0);\n"
"	float a0=t0.x*0.4+t0.y*0.6+t0.z*0.25;\n"
"	float a1=t1.x*0.4+t1.y*0.6+t1.z*0.25;\n"
"	float highlight=max(0.f,dot(v_norm,uSpecularDir.xyz));\n"
"	highlight=(highlight*highlight);highlight=highlight*highlight;\n"
"	vec4 surfaceColor=t0+(t1-vec4(0.5f,0.5f,0.5f,0.0f))*v_color.w;\n"
"	vec4 surfaceSpec=clamp(4*(surfaceColor-Vec4(0.5,0.5,0.5,0.0)), vec4(0.0,0.0,0.0,0.0),vec4(1.0,1.0,1.0,1.0));\n"
"	vec4 spec=highlight*uSpecularColor*surfaceSpec;\n"
"	vec4 diff=uAmbient+vso_norm.x*uDiffuseDX+vso_norm.y*uDiffuseDY+vso_norm.z*uDiffuseDZ;"
"	gl_FragColor =surfaceColor*diff*Vec4(v_color.xyz,0.0)*2.f+spec;\n"
"}";



/*
	enum vertexMode
	{
		singleBone
		matrixPalette
	};
	// just do everything this way for the moment
	enum PixelMode
	{
		vertexAlphaBlend
	}
*/

void	CreateShaders()
{
	GFX_CreateShaderProgram(g_PS_Alpha, g_VS_Default,  &g_VertexShader,&g_PixelShader, &g_ShaderProgram);
}

struct	GridMesh : Mesh
{
	GridMesh(int	usize, int vsize);
};


/*
// number of shaders:-
lights 1-4	x
skinning 1,3 x
texturecoords x

pixel shaders:-
simple
2layer
3layer alpha blend
3layer sea-blend

GetShader(numLights, numTexcoords, numBones);
*/

#define SETARRAY2(dst, v0,v1) { dst[0]=v0; dst[1]=v1;}
#define SETARRAY3(dst, v0,v1,v2) { dst[0]=v0; dst[1]=v1; dst[2]=v2;}

void
FillTorusVertices(TestVertex* dv, int numU,int numV)
{
	int	i,j;
	float fi=0.f, fj=0.f, dfi=1.f/(float)(numU-1),  dfj=1.f/(float)(numV-1);

	float rx=0.05f,ry=rx*0.33f;
	const float pi=3.14159265,pi2=pi*2.f;
	for (fj=0.f,j=0; j<numV; j++,fj+=dfj)
	{
		for (fi=0.f,i=0; i<numU; i++,fi+=dfi, dv++)
		{
			int dvi=i+j*numU;
			float cx = sin(2.f*pi*fi);
			float sx = cos(2.f*pi*fi);
			float sy = sin(2.f*pi*fj);
			float cy = cos(2.f*pi*fj);
			SETARRAY3(dv->norm,(sy)*cx,(sy)*sx,cy)
			SETARRAY3(dv->pos, (rx+sy*ry)*cx, (rx+sy*ry)*sx, ry*cy);
//			printf("vertex[i]=%.3f %.3f %.3f\n",dvi,dv->pos0],dv->pos[1],dv->pos[2]);
			SETARRAY2(dv->tex0, fi*8.f,fj*2.f);
			auto outf= (sy*0.125f+(1.f-0.125f));
//			dv->color=0xffffffff;
			dv->color[0]=outf*((sin(fi*pi2*6.f)+sin(fj*pi2*1.f))*0.5f*0.05f+0.5f);
			dv->color[1]=outf*((sin(fi*pi2*5.f)+sin(fj*pi2*2.f))*0.5f*0.05f+0.5f);
			dv->color[2]=outf*((sin(fi*pi2*4.f)+sin(fj*pi2*3.f))*0.5f*0.05f+0.5f);
			dv->color[3]=((i&7)<4)?1.f:0.f;
		}
	}
}
template<typename T>
auto CreateBuffer(const T* data,size_t num_elems,  int bufferType)->int {
	GLuint	id;
	size_t size = num_elems*sizeof(T);
	glGenBuffers(1,&id);
    GFX_LOGI("buffer created %d size=%d\n",id, (int)size);
	glBindBuffer(bufferType, id);

	glBufferData(bufferType, size, data, GL_STATIC_DRAW);
    auto err=glGetError();
    if (err!=GL_NO_ERROR) {
        if (err==GL_OUT_OF_MEMORY){
            GFX_LOGI("out of memory attempting to alloc %lu bytes\n",size);
        }
        GFX_ERROR(err);
    }

	glBindBuffer(bufferType, 0);
	return	id;
}

GridMesh::GridMesh(int	numU, int numV)
{
	auto m=this;
	m->numVertices=numU*numV;
	m->numIndices = (numV-1)*(2*numU+2);
	vector<TestVertex>	vertices; vertices.resize(numU*numV);
	m->vertexSize = sizeof(Vertex);
	int	i,j;
	FillTorusVertices(&vertices[0], numU,numV);

	vector<IndexType>	indices; indices.resize(m->numIndices);
	// per strip..
	int	dvi=0,vi=0;
	for (j=0; j<(numV-1); j++)
	{
		// per quad
		indices[dvi++]= j*numU+0;	// start with degenerate
		for (i=0; i<numU; i++)
		{
			indices[dvi++] = j*numU + i;
			indices[dvi++] = (j+1)*numU + i;
		}
		indices[dvi]= indices[dvi-1];	// end with degenerate
	}
	printf("index debug%d %d %d %d\n",m->IndexSize, m->numIndices, dvi, (int)sizeof(IndexType)*dvi);
	m->vbo = CreateBuffer(&vertices[0],m->numVertices, GL_ARRAY_BUFFER);
	m->ibo = CreateBuffer(&indices[0],m->numIndices, GL_ELEMENT_ARRAY_BUFFER);

}

void	TestGl_Idle();

float	angle=0.f;
GridMesh*	g_pGridMesh;


void	RenderGridMeshFromClientMem(GridMesh* msh)
{
	int	i;
	int	clientState[3]={GL_VERTEX_ARRAY,GL_COLOR_ARRAY,GL_TEXTURE_COORD_ARRAY};
	for (i=0; i<3; i++) glEnableClientState(clientState[i]);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

	std::vector<TestVertex>	vert; vert.resize(16*16);

	FillTorusVertices(&vert[0],16,16);

	int	stride=sizeof(vert[0]);
	TestVertex* baseVertex=&vert[0];
	glVertexPointer(3, GL_FLOAT, stride, (void*) &baseVertex->pos);
	glColorPointer(4,GL_UNSIGNED_BYTE, stride, (void*) &baseVertex->color);
	glTexCoordPointer(2, GL_FLOAT, stride, (void*) &baseVertex->tex0);

	glDrawArrays(GL_POINTS, 0, 16*16);

	for (i=0; i<3; i++) glDisableClientState(clientState[i]);
}


void	RenderGridMeshFromBuffer(GridMesh* msh)
{
	int	i;
	int	clientState[3]={GL_VERTEX_ARRAY,GL_COLOR_ARRAY,GL_TEXTURE_COORD_ARRAY};
	for (i=0; i<3; i++) glEnableClientState(clientState[i]);

	glBindBuffer(GL_ARRAY_BUFFER, msh->vbo);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, msh->ibo);



	int	stride=sizeof(TestVertex);
	TestVertex* baseVertex=(TestVertex*)0;
	glVertexPointer(3, GL_FLOAT, stride, (void*) &baseVertex->pos);
	glColorPointer(4,GL_FLOAT, stride, (void*) &baseVertex->color);
	glTexCoordPointer(2, GL_FLOAT, stride, (void*) &baseVertex->tex0);

	glDrawElements(GL_TRIANGLE_STRIP, msh->numIndices, GL_UNSIGNED_INT,0);

	for (i=0; i<3; i++) glDisableClientState(clientState[i]);
}

inline void MatrixStoreIdentity4x4Demo(float m[16]){
    int i; for (i=0; i<16; i++) m[i]=0.f;
    for (i=0; i<4; i++) { m[i+i*4]=1.f;}
}
inline  void MatrixMul4x4Demo(float  result[16],const  float  a[16],const  float  b[16]) {
    int  i,j,k;
    for (i=0; i<4; i++) {
        for (j=0; j<4; j++) {
            float sum=0.f;
            for (k=0; k<4; k++) {
                sum+=a[j*4+k]*b[k*4+i];
            }
            result[j*4+i]=sum;
        }
    }
}


enum {
	SU_MatProj = 0,
	SU_MatModelView = 4,
	SU_Ambient = 8,
	SU_DiffuseDX = 9,
	SU_DiffuseDY = 10,
	SU_DiffuseDZ = 11,
	SU_FogColor = 12,
	SU_FogFalloff = 13,
	SU_SpecularDir = 14,
	SU_SpecularPower = 15,
	SU_SpecularColor = 16,
	SU_LightPos = 17,
	SU_LightColor = 18,
	SU_LightFalloff = 19,
	SU_Tex0 = 21,
	SU_Tex1 = 22,
};
struct Vector4f {float x,y,z,w;};
void SetUniform(int index, const Vector4f& v) {
	glUniform4f(index,v.x,v.y,v.z,v.w);
}

Vector4f g_FogColor={0.25f,0.5f,0.5f,1.f};
void	RenderGridMeshShader(GridMesh* msh,int t0,int t1)
{

	int	i;
	glBindBuffer(GL_ARRAY_BUFFER, msh->vbo);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, msh->ibo);

	int	stride=sizeof(TestVertex);
	TestVertex* baseVertex=(TestVertex*)0;
	glEnableVertexAttribArray(VertexAttrIndex_pos);
	glEnableVertexAttribArray(VertexAttrIndex_color);
	glEnableVertexAttribArray(VertexAttrIndex_tex0);
	glEnableVertexAttribArray(VertexAttrIndex_norm);

	glUniform1i(SU_Tex0, 0);
	glUniform1i(SU_Tex1, 1);
	// specular highlight, only one supported
	SetUniform(SU_SpecularDir, Vector4f{0.0,0.707f,0.707f,0.f});
	SetUniform(SU_SpecularColor, Vector4f{1.f,0.75f,0.5f,0.f});
	// describe a spherical harmonic - essentially a 4x4 matrix transforming normal vector into a color
	// aproximatly it's an ambient color and variation of color along x,y,z axes.
	// you can approximate environment lights this way.
	SetUniform(SU_Ambient, Vector4f{0.25f,0.25f,0.25f,1.f});
	SetUniform(SU_DiffuseDX, Vector4f{0.0f,0.0f,0.25f,1.f});
	SetUniform(SU_DiffuseDY, Vector4f{0.5f,0.5f,0.5f,1.f});
	SetUniform(SU_DiffuseDZ, Vector4f{0.25f,0.0f,0.0f,1.f});
	// simple depth based fog
	SetUniform(SU_FogColor, g_FogColor);
	SetUniform(SU_FogFalloff, Vector4f{0.5f,0.25f,0.0f,0.f});

	glActiveTexture(GL_TEXTURE0+0);	glBindTexture(GL_TEXTURE_2D, t0);
	glActiveTexture(GL_TEXTURE0+1);	glBindTexture(GL_TEXTURE_2D, t1);

	// describe the vertex layout in the vertex buffer..
	glVertexAttribPointer(VertexAttrIndex_pos,	3,GL_FLOAT, GL_FALSE,	stride, (void*) &baseVertex->pos);
	glVertexAttribPointer(VertexAttrIndex_color,	4,GL_FLOAT, GL_FALSE,	stride, (void*) &baseVertex->color);
	glVertexAttribPointer(VertexAttrIndex_tex0,	2, GL_FLOAT, GL_FALSE,	stride, (void*) &baseVertex->tex0);
	glVertexAttribPointer(VertexAttrIndex_norm,	3, GL_FLOAT, GL_FALSE,	stride, (void*) &baseVertex->norm);

	glDrawElements(GL_TRIANGLE_STRIP, msh->numIndices, GL_UNSIGNED_INT,0);

}


void
DrawImmediateQuadXY()
{
	glBegin(GL_TRIANGLE_STRIP);

	glColor3f(1.f,0.f,0.f);
	glVertex3f(-1.f,-1.f,0.f);

	glColor3f(0.f,1.f,0.f);
	glVertex3f(1.f,-1.f,0.f);

	glColor3f(0.f,0.f,1.f);
	glVertex3f(-1.f,1.f,0.f);

	glColor3f(0.f,1.f,0.f);
	glVertex3f(1.f,1.f,0.f);
	glEnd();
}

float g_angle=0.f;
int	g_frame=0;

void
MatrixRotate(float m[16], int axis, float angle) {
	MatrixStoreIdentity4x4Demo(m);
	static int axis0[3]={1,0,0};
	static int axis1[3]={2,2,1};
	int	i0=axis0[axis];
	int	i1=axis1[axis];
	float s= sin(angle),c=cos(angle);
	m[i0*4+i0]=c;
	m[i0*4+i1]=s;
	m[i1*4+i0]=-s;
	m[i1*4+i1]=c;
}
void
MatrixTranslate(float m[16], float x, float y, float z) {
	MatrixStoreIdentity4x4Demo(m);
	m[12]=x;
	m[13]=y;
	m[14]=z;
}
int g_NumTorus = 4096;
void	ShaderTest_Render()
{

	g_angle+=0.0025f;
	glClearColor(g_FogColor.x,g_FogColor.y,g_FogColor.z,g_FogColor.w);
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
	float matI[16],matMVP[16], matMV[16], matP[16], matRotX[16],matRotY[16],matTrans[16], matRotXY[16];
	MatrixStoreIdentity4x4Demo(matI);
	SetMatrixProjectionFrustumDemo(matP,-0.5f,0.5f,-0.5f,0.5f,0.5f,5.f);
	int	i;
	float r0 = 0.5f;
	float r1 = 0.1f;
	float sda=0.1f;
	float a0=g_angle*1.1f+0.1f, a1=g_angle*1.09f+1.5f;
	float a2=g_angle*1.05f+0.5f, a3=g_angle*1.11f;
	float a4=g_angle*1.11f+0.7f, a5=g_angle*1.105f;
	float da0=2*PI*0.071f*sda;
	float da1=2*PI*0.042f*sda;
	float da2=2*PI*0.081f*sda;
	float da3=2*PI*0.091f*sda;
	float da4=2*PI*0.153f*sda;
	float da5=2*PI*0.1621f*sda;

	for (i=0; i<g_NumTorus; i++,a0+=da0,a1+=da1,a2+=da2,a3+=da3,a4+=da4,a5+=da5)
	{
		MatrixTranslate(matTrans, cos(a0)*r0+cos(a3)*r1 , cos(a1)*r0+cos(a4)*r1, cos(a2)*r0+cos(a5)*r1 -2.f*r0);
		MatrixRotate(matRotX, 0, a0);
		MatrixRotate(matRotY, 1, a1*0.245f);
		MatrixMul4x4Demo(matRotXY, matRotX, matRotY);
		MatrixMul4x4Demo(matMV, matRotXY, matTrans);
		MatrixMul4x4Demo(matMVP, matP,matMV);

		glUseProgram(g_ShaderProgram);
		glUniformMatrix4fvARB(SU_MatProj, 1,  GL_FALSE, matP);
		glUniformMatrix4fvARB(SU_MatModelView, 1, GL_FALSE, matMV);

		RenderGridMeshShader(g_pGridMesh,g_Texture[1+(i&3)],g_Texture[1+((1+i)&3)]);
	}
	glFlush();
	g_frame++;
}

void	CreateTexture() {
//	static_assert(sizeof(GLuint)==sizeof(int));
	glGenTextures(1,(GLuint*)&g_Texture[0]);
	glBindTexture(GL_TEXTURE_2D,g_Texture[0]);
	glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );

	int	usize=256,vsize=256;
	void* buffer = malloc(usize*vsize*4);
	int	i,j;
	int* dst=(int*) buffer;
	for (j=0; j<vsize; j++) {
		for (i=0; i<usize;i++) {
			dst[i+j*usize] = i+j*256+255*256*256;
		}
	}
	int	m;
	for (m=0; m<8; m++) {
		glTexImage2D(GL_TEXTURE_2D, m, GL_RGB, usize,vsize, 0, GL_RGB, GL_UNSIGNED_BYTE,buffer);
	}
	free(buffer);
	glBindTexture(GL_TEXTURE_2D,0);
	g_Texture[1]=g_Texture[0];
	g_Texture[2]=g_Texture[0];
	g_Texture[3]=g_Texture[0];
	g_Texture[4]=g_Texture[0];
	/*
	g_Texture[1] = getTexture("data/rocktile.tga");
	g_Texture[4] = getTexture("data/pebbles_texture.tga");
	g_Texture[3] = getTexture("data/grass.tga");
	g_Texture[2] = getTexture("data/cliffs.tga");
	*/

}

// Shader sources
const GLchar* triangle_vertexSource =
    "attribute vec4 position;    \n"
    "void main()                  \n"
    "{                            \n"
    "   gl_Position = vec4(position.xyz, 1.0);  \n"
    "}                            \n";
const GLchar* triangle_fragmentSource =
    "precision mediump float;\n"
    "void main()                                  \n"
    "{                                            \n"
    "  gl_FragColor = vec4 (1.0, 1.0, 1.0, 1.0 );\n"
    "}\n";

GLfloat g_triangle_vertices[] = {0.0f, 0.5f, 0.5f, -0.5f, -0.5f, -0.5f};
GLuint g_triangle_vao;
GLuint g_triangle_vbo;

int g_triangle_shaderProgram;
void init_triangle() {

    glGenVertexArrays(1, &g_triangle_vao);
    glBindVertexArray(g_triangle_vao);

    // Create a Vertex Buffer Object and copy the vertex data to it
    glGenBuffers(1, &g_triangle_vbo);


    glBindBuffer(GL_ARRAY_BUFFER, g_triangle_vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(g_triangle_vertices), g_triangle_vertices, GL_STATIC_DRAW);
	printf("1\n");


    // Create and compile the vertex shader
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &triangle_vertexSource, NULL);
    glCompileShader(vertexShader);

    // Create and compile the fragment shader
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &triangle_fragmentSource, NULL);
    glCompileShader(fragmentShader);

    // Link the vertex and fragment shader into a shader program
    g_triangle_shaderProgram = glCreateProgram();
    glAttachShader(g_triangle_shaderProgram, vertexShader);
    glAttachShader(g_triangle_shaderProgram, fragmentShader);
    // glBindFragDataLocation(shaderProgram, 0, "outColor");
    glLinkProgram(g_triangle_shaderProgram);
}
void draw_triangle(){

    glUseProgram(g_triangle_shaderProgram);
    GLint posAttrib = glGetAttribLocation(g_triangle_shaderProgram, "position");
    glBindVertexArray(g_triangle_vao);
    glEnableVertexAttribArray(posAttrib);
	glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 0, 0);
	glDrawArrays(GL_TRIANGLES, 0, 3);
}


int main(int argc, const char** argv)
{

	printf("hello SDL world\n");

	SDL_Init(SDL_INIT_EVERYTHING);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);

    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);

    SDL_GL_SetSwapInterval(0);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);


    auto wnd(
        SDL_CreateWindow("test", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
            1024, 1024, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN));
    auto glc = SDL_GL_CreateContext(wnd);
	SDL_ShowWindow(wnd);

	CreateShaders();
	CreateTexture();

	glDrawBuffer(GL_BACK);
	glEnable(GL_DEPTH_TEST);
	g_pGridMesh = new GridMesh(16,16);
	init_triangle();

	int frame=0;
	while (1){
        SDL_Event e;
        while(SDL_PollEvent(&e))
        {
            if(e.type == SDL_QUIT) std::terminate();
        }



		// draw the torus lisajous
		ShaderTest_Render();

		// Draw a single triangle (simpler demo)
	    // Specify the layout of the vertex data

		draw_triangle();


		printf("frame=%d",frame);
		frame++;

        SDL_GL_SwapWindow(wnd);
	}

}