vertex_program VoxelTexture_VP cg
{
   source VoxelTexture.cg
   entry_point voxeltexture_vp
   profiles vs_1_1

   default_params
    {
      param_named_auto world world_matrix
      param_named_auto viewProj viewproj_matrix
    }
}

fragment_program VoxelTexture_FP cg
{
   source VoxelTexture.cg
   entry_point voxeltexture_fp
   profiles ps_2_x ps_2_0
}

material VoxelTexture
{
   receive_shadows on
   technique
   {
      pass
      {
         vertex_program_ref VoxelTexture_VP
         {
         }
         
         fragment_program_ref VoxelTexture_FP
         {
         }
         
         texture_unit
         {
            texture Dirt.png 2d
            filtering anisotropic
                max_anisotropy 16
         }
      }
   }
}

#define VOXELCENTEROFFSET 0.5

void voxeltexture_vp(
   float4 inPosition         : POSITION,

   out float4 outPosition     : POSITION,
   out float4 outWorldPosition   : TEXCOORD0,

   uniform float4x4 world,
   uniform float4x4 viewProj)
{
   outWorldPosition = mul(world, inPosition);
   
   outPosition = mul(viewProj, outWorldPosition);
}

void voxeltexture_fp(
   float4 inWorldPosition       : TEXCOORD0,

   out float4 color         : COLOR,

   uniform sampler2D texture)
{
   float3 worldNormal = cross(ddy(inWorldPosition.xyz), ddx(inWorldPosition.xyz));
   worldNormal = normalize(worldNormal);
   //Right
    if(worldNormal.x > 0.5)
    {
        color = tex2D(texture, float2((1 - inWorldPosition.z) + VOXELCENTEROFFSET, (1 - inWorldPosition.y) + VOXELCENTEROFFSET));
    }
   //Left
   if(worldNormal.x < -0.5)
    {
        color = tex2D(texture, float2(inWorldPosition.z + VOXELCENTEROFFSET, (1 - inWorldPosition.y) + VOXELCENTEROFFSET));
    }
   //Top
    if(worldNormal.y > 0.5)
    {
        color = tex2D(texture, inWorldPosition.xz + VOXELCENTEROFFSET);
    }
   //Bottom
    if(worldNormal.y < -0.5)
    {
        color = tex2D(texture, float2(inWorldPosition.x + VOXELCENTEROFFSET, (1 - inWorldPosition.z) + VOXELCENTEROFFSET));
    }
   //Front
    if(worldNormal.z > 0.5)
    {
        color = tex2D(texture, float2(inWorldPosition.x + VOXELCENTEROFFSET, (1 - inWorldPosition.y) + VOXELCENTEROFFSET));
    }
   //Back
    if(worldNormal.z < -0.5)
    {
        color = tex2D(texture, float2((1 - inWorldPosition.x) + VOXELCENTEROFFSET, (1 - inWorldPosition.y) + VOXELCENTEROFFSET));
    }
}

if(worldNormal.x > 0.0)
if(worldNormal.x < 0.0)

color = tex2D(texture, float2((1 - inWorldPosition.x) + VOXELCENTEROFFSET, (1 - inWorldPosition.y) + VOXELCENTEROFFSET));

float4 col; //More useful to define this outside of the conditional
col = tex2D(texture, float2((1 - inWorldPosition.x) + VOXELCENTEROFFSET, (1 - inWorldPosition.y) + VOXELCENTEROFFSET));
color = col + float4(0.0, 0.0, 0.0, 1.0);

#define NUM_TEXTURES 256
#define NUM_NONTEX_MATERIALS 1 //Air is 0 for me, so the first texture is actually material 1, so materialID - 1 to offset this
#define NUM_TEXTURES_PER_ROW 16
#define TEX_WIDTH_NORMALIZED (NUM_TEXTURES_PER_ROW / NUM_TEXTURES) //This is 16/256

            vector<PositionMaterial>::iterator vecItr;
            for(vecItr = vecVertices.begin(); vecItr != vecVertices.end(); vecItr++)
            {
               Vector3DFloat pos = vecItr->getPosition() * worldScale;
               pos += (Vector3DFloat(j * chunkSize, k * chunkSize, i * chunkSize) * worldScale);
               obj->position(pos.getX(), pos.getY(), pos.getZ());

               Ogre::ColourValue colVal;
               uint8_t matID = vecItr->getMaterial(); //+ 0.5;
               colVal.r = ((matID - NUM_NONTEX_MATERIALS) % NUM_TEXTURES_PER_ROW) * TEX_WIDTH_NORMALIZED; // - pixelOffset;
               unsigned int matY = (unsigned int) (matID / NUM_TEXTURES_PER_ROW);
               colVal.g = (float) (matY * TEX_WIDTH_NORMALIZED);
               colVal.b = 0.0f;
               colVal.a = 1.0f;
               obj->colour(colVal);
            }

#define VOXELCENTEROFFSET 0.5
#define WORLDSCALE 2.0
//Pixel size of the texture atlas
#define TEXATLASSIZE 256
//Pixel per single texture
#define TEXATLAS_TEXSIZE 16
//Number of textures per row
#define TEXATLAS_NUMTEX (TEXATLASSIZE / TEXATLAS_TEXSIZE)
//Size of a single texture in 0.0 - 1.0 values
#define TEXATLAS_TEXSIZE_NORMALIZED ((float)TEXATLAS_TEXSIZE / (float)TEXATLASSIZE)

void voxeltexture_vp(
   float4 inPosition         : POSITION,
   float4 inColor            : COLOR,

   out float4 outPosition     : POSITION,
   out float4 outWorldPosition   : TEXCOORD0,
   out float4 outColor         : TEXCOORD1,

   uniform float4x4 world,
   uniform float4x4 viewProj)
{
   outWorldPosition = mul(world, inPosition);
   
   outPosition = mul(viewProj, outWorldPosition);
   
   outColor = inColor;
}

void voxeltexture_fp(
   float4 inWorldPosition       : TEXCOORD0,
   float4 inColor            : COLOR,

   out float4 color         : COLOR,

   uniform sampler2D texAtlas)
{
   float3 worldNormal = cross(ddy(inWorldPosition.xyz / WORLDSCALE), ddx(inWorldPosition.xyz / WORLDSCALE));
   worldNormal = normalize(worldNormal);
   
   float2 pos;
   
   //Handle texture atlas
   int2 posColor;
   // X coordinate
   inColor.x /= TEXATLAS_TEXSIZE_NORMALIZED;
   posColor.x = (int) inColor.x;
   pos.x = posColor.x;
   // Y coordinate
   inColor.y /= TEXATLAS_TEXSIZE_NORMALIZED;
   posColor.y = (int) inColor.y;
   pos.y = posColor.y;
   
   //Right
    if(worldNormal.x > 0.5)
    {
      pos += float2(1 - inWorldPosition.z / WORLDSCALE + VOXELCENTEROFFSET, 1 - inWorldPosition.y / WORLDSCALE + VOXELCENTEROFFSET);
    }
   //Left
   if(worldNormal.x < -0.5)
    {
        pos += float2(inWorldPosition.z / WORLDSCALE + VOXELCENTEROFFSET, 1 - inWorldPosition.y / WORLDSCALE + VOXELCENTEROFFSET);
    }
   //Top
    if(worldNormal.y > 0.5)
    {
        pos += float2(inWorldPosition.xz / WORLDSCALE + VOXELCENTEROFFSET);
    }
   //Bottom
    if(worldNormal.y < -0.5)
    {
        pos += float2(inWorldPosition.x / WORLDSCALE + VOXELCENTEROFFSET, 1 - inWorldPosition.z / WORLDSCALE + VOXELCENTEROFFSET);
    }
   //Front
    if(worldNormal.z > 0.5)
    {
        pos += float2(inWorldPosition.x / WORLDSCALE + VOXELCENTEROFFSET, 1 - inWorldPosition.y / WORLDSCALE + VOXELCENTEROFFSET);
    }
   //Back
    if(worldNormal.z < -0.5)
    {
        pos += float2(1 - inWorldPosition.x / WORLDSCALE + VOXELCENTEROFFSET, 1 - inWorldPosition.y / WORLDSCALE + VOXELCENTEROFFSET);
    }
   
   color = tex2D(texAtlas, pos);
}

void GraphicsManager::UpdateManualObject(SimpleVolume<VoxelMat>& volData, WorldTerrain wTerra, Vector3DInt32 chunkNum)
{
   int i = chunkNum.getX();
   int j = chunkNum.getY();
   int k = chunkNum.getZ();

   char str[50];
   sprintf(str, "%d-%d-%d", k, i, j);

   Vector3DInt32 start(i * chunkSize, j * chunkSize, k * chunkSize);
   Vector3DInt32 end((i + 1) * chunkSize - 1, (j + 1) * chunkSize - 1, (k + 1) * chunkSize - 1);

   SurfaceMesh<PositionMaterial> mesh;
   CubicSurfaceExtractor<SimpleVolume, VoxelMat> surfaceExtractor(&volData, Region(start, end), &mesh);
   surfaceExtractor.execute();

   ManualObject *obj = manualObjects[str];

   obj->estimateVertexCount(mesh.getNoOfVertices());
   obj->estimateIndexCount(mesh.getNoOfIndices());

   vector<uint32_t> vecIndices = mesh.getIndices();
   vector<PositionMaterial> vecVertices = mesh.getVertices();

   obj->beginUpdate(0);

   vector<PositionMaterial>::iterator vecItr;
   for(vecItr = vecVertices.begin(); vecItr != vecVertices.end(); vecItr++)
   {
      Vector3DFloat pos = vecItr->getPosition() * worldScale;
      pos += (Vector3DFloat(i * chunkSize, j * chunkSize, k * chunkSize) * worldScale);
      obj->position(pos.getX(), pos.getY(), pos.getZ());
   }

   vector<uint32_t>::iterator indVec;
   for(indVec = vecIndices.begin(); indVec != vecIndices.end(); indVec++)
   {
      obj->index(*indVec);
   }

   obj->end();
}