#import "Common/ShaderLib/Instancing.glsllib"
#import "Common/ShaderLib/Skinning.glsllib"
#import "Common/ShaderLib/Lighting.glsllib"

uniform vec4 g_LightColor;
uniform vec4 g_LightPosition;
uniform vec4 g_AmbientLightColor;

out vec3 AmbientSum;
out vec4 DiffuseSum;
out vec3 SpecularSum;

attribute vec3 inPosition;
attribute vec2 inTexCoord;
attribute vec3 inNormal;

varying vec2 texCoord;

flat out vec2 offsetUV;
flat out vec2 offsetUV2;
flat out vec2 alphas;

varying vec3 vNormal;
varying vec3 vViewDir;
varying vec4 vLightDir;
varying vec3 lightVec;

uniform mat4 g_ModelViewMatrix;

uniform mat4 g_ModelViewProjectionMatrix;
uniform mat4 g_ModelMatrix;
uniform mat4 g_ModelWorldMatrix;

uniform int spherical; // 1 for spherical; 0 for cylindrical

#define M_PI 3.1415926535897932384626433832795

void main()
{
offsetUV = vec2(0.0,0.0);
int nTextures = 8;

float divider = float(nTextures);

mat4 modelView = g_WorldViewMatrix;

vec4 position = vec4(inPosition.x-0.5,inPosition.y,inPosition.z,1.0);

vec4 X = vec4(1.0,0.0,0.0,1.0);
vec4 Y = vec4(0.0,1.0,0.0,1.0);
vec4 Z = vec4(0.0,0.0,1.0,1.0);
vec4 O = vec4(0.0,0.0,0.0,1.0);

vec4 unitX = g_WorldViewMatrix * X;
vec4 unitY = g_WorldViewMatrix * Y;
vec4 unitZ = g_WorldViewMatrix * Z;
vec4 origin = g_WorldViewMatrix * O;

float scaleX = distance(unitX, origin);
float scaleY = distance(unitY, origin);
float scaleZ = distance(unitZ, origin);

float projuY2X = dot(normalize(unitY-origin),X);
float projuY2Y = dot(normalize(unitY-origin),Y);
float projuY2Z = dot(normalize(unitY-origin),Z);

float projuX2X = dot(normalize(unitX-origin),X);
float projuX2Y = dot(normalize(unitX-origin),Y);
float projuX2Z = dot(normalize(unitX-origin),Z);

float projuZ2X = dot(normalize(unitZ-origin),X);
float projuZ2Y = dot(normalize(unitZ-origin),Y);
float projuZ2Z = dot(normalize(unitZ-origin),Z);

float u = 0.0;
float v = 0.0;

float u2 = 0.0;
float v2 = 0.0;

float alpha = 1.0;
float alpha2 = 1.0;

float angle = 60.0/(divider-1.0);

if (projuY2Z < 0.0 || projuY2Y < 0.0) {
v = 0.0;
v2 = 0.0;
alpha2 = 1.0;
} else {
for (int i=1; i< nTextures+1;i++) {
if (projuY2Y > cos(M_PI*angle*float(i)/180.0)){
v = float(i-1);
v2 = float(i);
alpha2 = (projuY2Y -cos(M_PI*angle*float(i)/180.0))/(cos(M_PI*angle*float(i-1)/180.0)-cos(M_PI*angle*float(i)/180.0));
break;
}
}
}

if (v2 == divider) {
v2 = divider-1.0;
alpha2 = 1.0;
}

//v = 0.0;
//v2 = 0.0;

float angle2 = 360.0/divider*M_PI/180.0;

if (projuX2Y >= 0.0) {
for (int i=0; i<nTextures/2;i++){
if (projuX2X > cos(float(i+1)*angle2) && projuX2X <= cos(float(i)*angle2)) {
u = float(i);
u2 = float(i+1);
alpha = (projuX2X - cos(float(i+1)*angle2))/(cos(float(i)*angle2)-cos(float(i+1)*angle2));
break;
}
}
}else if (projuX2Y < 0.0) {
for (int i=nTextures/2;i<nTextures;i++){
if (projuX2X <= cos(float(i+1)*angle2) && projuX2X > cos(float(i)*angle2)) {
u = float(i);
u2 = float(i+1);
alpha = (projuX2X - cos(float(i+1)*angle2))/(cos(float(i)*angle2)-cos(float(i+1)*angle2));
break;
}
}
}

if (u2 == divider) {
u2 = 0.0;
}

offsetUV = vec2(u/divider, v/divider);
offsetUV2 = vec2(u2/divider, v2/divider);
alphas = vec2(alpha, alpha2);

// First column
modelView[0][0] = scaleX;
modelView[0][1] = 0.0;
modelView[0][2] = 0.0;

if (spherical == 1)
{
// Second column
modelView[1][0] = 0.0;
modelView[1][1] = scaleY;
modelView[1][2] = 0.0;
}

// Third column
modelView[2][0] = 0.0;
modelView[2][1] = 0.0;
modelView[2][2] = scaleZ;

vec4 P = g_ModelViewMatrix * vec4(inPosition,1.0);
//gl_Position = g_ProjectionMatrix * P;

vec4 uWX = g_WorldMatrix * X;
vec4 uWO = g_WorldMatrix * O;
float wScaleX = distance(uWX, uWO);


//ok gl_Position = g_WorldViewProjectionMatrix * vec4(inPosition, 1.0);
//ok gl_Position = g_ProjectionMatrix * g_WorldViewMatrix * vec4(inPosition,1.0);
//kind of ok but wrong gl_Position = g_ViewProjectionMatrix * g_WorldViewMatrix * vec4(inPosition,1.0);
//ok gl_Position = g_ViewProjectionMatrix * g_WorldMatrix * vec4(inPosition,1.0);
//gl_Position = g_ProjectionMatrix * g_ViewMatrix * g_WorldMatrix * vec4(inPosition,1.0);
gl_Position = g_ProjectionMatrix * modelView * position;
texCoord = vec2(1.0 - inTexCoord.x, inTexCoord.y) * 1.0/divider;

}