Raenir Salazar fucked around with this message at 00:15 on Aug 28, 2015

float expon = 5.0f;

float interp1 = pow(sig_sides[0].value,expon);
vec4 col1 = sideColors[sig_sides[0].index];

float interp2 = pow(sig_sides[1].value,expon);
vec4 col2 = sideColors[sig_sides[1].index];

float interp3 = pow(sig_sides[2].value,expon);
vec4 col3 = sideColors[sig_sides[2].index];

fragColor = (mainColor + interp1*col1 + interp2*col2 + interp3*col3)/
            (1 + interp1 + interp2 + interp3);

Joda fucked around with this message at 06:22 on Aug 28, 2015

Raenir Salazar fucked around with this message at 22:26 on Aug 28, 2015

   for(int i = 0; i < dimensions; ++i) {
        for(int j = 0; j < dimensions; ++j) {
            double offsetY = (i % 2 == 1) ? 0.86602540378 : 0.0;
            points[i + dimensions*j] = glm::vec2(-i*1.5f,j*1.73205080757 + offsetY);
        }
    }

int grid_x = idx[0] % grid_dim;
int grid_y = idx[0] / grid_dim;

mainColor = texture(texture_uniform,ivec2(grid_x,grid_y)).r;

sideColors[0] = texture(texture_uniform,ivec2(grid_x + 1,
                                        (idx[0] % 2 == 1) ? grid_y + 1 : grid_y)
                                        ).r;

sideColors[1] = texture(texture_uniform,ivec2(grid_x,grid_y + 1)).r;

sideColors[2] = texture(texture_uniform,ivec2(grid_x - 1,
                                        (idx[0] % 2 == 1) ? grid_y + 1 : grid_y)
                                        ).r;

sideColors[3] = texture(texture_uniform,ivec2(grid_x - 1,
                                             (idx[0] % 2 == 1) ? grid_y : grid_y - 1)
                                             ).r;

sideColors[4] = texture(texture_uniform,ivec2(grid_x,grid_y - 1)).r;
sideColors[5] = texture(texture_uniform,ivec2(grid_x + 1,
                                         (idx[0] % 2 == 1) ? grid_y : grid_y - 1)
                                         ).r;

#version 330

in vec3 hex_coord;  //Contains interpolation values for (AF/CD,AB/DE,BC/EF)
flat in int mainColor;      //Contains array index of primary texture
flat in int sideColors[6];  //Contains array indices of 6 bordering textures
flat in int sig_sides[3];   //Expresses which indices are currently the 3 most significant.

uniform sampler2DArray tex_array;

out vec4 fragColor;

void main() {
    float expon = 10.0f;

    vec2 UV = vec2(1.0,1.0);

    vec4 col0 = texture(tex_array,vec3(UV,float(mainColor)));

    float interp1 = pow(hex_coord.x,expon);
    vec4 col1 = texture(tex_array,vec3(UV,float(sideColors[sig_sides[0]])));

    float interp2 = pow(hex_coord.y,expon);
    vec4 col2 = texture(tex_array,vec3(UV,float(sideColors[sig_sides[1]])));

    float interp3 = pow(hex_coord.z,expon);
    vec4 col3 = texture(tex_array,vec3(UV,float(sideColors[sig_sides[2]])));

    fragColor = (col0 + interp1*col1 + interp2*col2 + interp3*col3)/
                (1 + interp1 + interp2 + interp3);
}

Joda fucked around with this message at 00:49 on Aug 29, 2015

Joda fucked around with this message at 03:48 on Aug 30, 2015

parent's (svoSpatial (Node)) child named 1 before detaching is 1 (Geometry)
that child's parent before detaching is svoSpatial (Node)
parent's (svoSpatial (Node)) child named 1 after detaching is null
that child's parent after detaching is null

parent's (1 (Node)) child named 7 before detaching is 7 (Geometry)
that child's parent before detaching is 1 (Node)
parent's (1 (Node)) child named 7 after detaching is null
that child's parent after detaching is null


parent's (svoSpatial (Node)) child named 5 before detaching is 5 (Geometry)
that child's parent before detaching is svoSpatial (Node)
parent's (svoSpatial (Node)) child named 5 after detaching is 5 (Geometry) <-- !!!
that child's parent after detaching is null


parent's (1 (Node)) child named 7 before detaching is 7 (Node)
that child's parent before detaching is 1 (Node)
parent's (1 (Node)) child named 7 after detaching is null
that child's parent after detaching is null

gonadic io fucked around with this message at 07:46 on Aug 30, 2015

Raenir Salazar fucked around with this message at 04:03 on Aug 31, 2015

// E: AB - R
// F: ED - L
// A: EF - BL
// B: BC - TR
// C: CD - TL
// D: AF - BR

float3 hexDeltas[6];

// deltas in order of Top Right to Top Left going clockwise
hexDeltas[0] = int3(1,0,-1); // TR
hexDeltas[1] = int3(1,-1,0); // R
hexDeltas[2] = int3(0,-1,1); // BR
hexDeltas[3] = int3(-1,0,1); // BL
hexDeltas[4] = int3(-1,1,0); // L
hexDeltas[5] = int3(0,1,-1); // TL

// Firstly, convert given x,y,z coordinates in worldspace to axial/cube coordinates.
// Size equals 1 because by hand that's correct, but if fed to the shader and I do the calculations
// within the shader I get the completely wrong result.
float mSize = 1;

float q;
float r;

// World Space to Hex conversion: 
//[url]http://www.redblobgames.com/grids/hexagons/#pixel-to-hex[/url]
float2x2 matA = { sqrt(3)/3, -1/3,
	 				  0, 2/3 };

float1x2 matB = { HexOrigin.x, 
		  HexOrigin.z };

float1x2 matQR = mul(mul(matA,matB), 1/(-mSize));

q = matQR[0][0];
r = matQR[0][1];

// z because worldspace from the camera angle is X,Z instead of X,Y.
// Although strangely I need to flip x and y here and multiply by
// -size to get correct values.

float3 HexOriginCubeCoords = float3(-q-r,q,r);

// now we round..
// I'm not sure if these work.
// If I skip this step I find less tiles.
int rx = round(HexOriginCubeCoords.x);
int ry = round(HexOriginCubeCoords.y);
int rz = round(HexOriginCubeCoords.z);

float x_diff = abs(rx - HexOriginCubeCoords.x);
float y_diff = abs(ry - HexOriginCubeCoords.y);
float z_diff = abs(rz - HexOriginCubeCoords.z);

if (x_diff > y_diff && x_diff > z_diff)
{
	rx=-ry-rz;
}
else if (y_diff > z_diff)
{
	ry = -rx-rz;
}
else
{
	rz = -rx-ry;
}

int3 myHex = int3((rx),(ry),(rz));

// We now know for sure "where" our tile is in cube coordinates.
// Now we need to find out which textures are being used in neigbhouring hexes.

// Textures for current hex is mTexases[0]
// All surrounding hexes are from 1 to 6 clockwise TR to TL.
int mTexases[7]; 

float3 test = float3(0,0,0);
// ID:0 is reserved as "our" texture of the current hex.
// 1 to 6 go from top right clockwise to top left.
// Every hex has it's own texture, find out current hex and track it's texture.
// Loop for each pixel and check it's r,g,b aak it's xyz and compare with myHex.xyz
// If they match check the alpha channel where we store it's texture ID.

for (int m=0; m<Radius; m++)
{
    for (int k=0; k<Radius;k++)
    {
      float ecks = (k/Radius);
      float why = (m/Radius);
      if (round(tex2D(TexMap, float2(ecks,why)).x) == myHex.x
         && round(tex2D(TexMap, float2(ecks,why)).y) == myHex.y
         && round(tex2D(TexMap, float2(ecks,why)).z) == myHex.z)
      {
        mTexases[0] = tex2D(TexMap, float2(ecks,why)).a;
        test = float3(0,1,0);
        break;
      }
    }
}

// We do the same here but now we're also checking the surrounding hexes.
bool isFound = false;
for (int c=1; c < 7; c++)
{
  isFound = false;
  for (int m=0; m<Radius; m++)
  {
    for (int k=0; k<Radius;k++)
    {
      float ecks = k/Radius;
      float why = m/Radius;
      int3 temp = int3(hexDeltas[c-1].x + myHex.x, hexDeltas[c-1].y + 
      myHex.y, hexDeltas[c-1].z + myHex.z);
      if ((round(tex2D(TexMap, float2(ecks,why)).x) == temp.x)
          && (round(tex2D(TexMap, float2(ecks,why)).y) == temp.y)
          && (round(tex2D(TexMap, float2(ecks,why)).z) == temp.z))
      {
        mTexases[c] = tex2D(TexMap, float2(ecks,why)).a;
        test += float3(0,0,1);
        isFound = true;
      }
    }
  }
  if (!isFound)
  {
    mTexases[c] = 4;
  }
  
}
// The above strangely only works for the surrounding tiles of the only tile we find.
// This implies to me that the sampling code doesn't work as intended.
// Okay in theory we now have all of our surrounding textures.

// Blending code
float i,j;
float a[6];
int b[6];
float3 lookup[7];

float3 tempColor;
float iMin;
float iMax;
float temp = 0;
int intTemp = 0;
float interp;

// E: AB - R
// F: ED - L
// A: EF - BL
// B: BC - TR
// C: CD - TL
// D: AF - BR

a[0] = B; //
a[1] = E; //
a[2] = D; //
a[3] = A; //
a[4] = F; //
a[5] = C; //

b[0] = 0;
b[1] = 1;
b[2] = 2;
b[3] = 3;
b[4] = 4;
b[5] = 5;

// These are now the six textures the game currently 
// allows, will switch to texture atlas asap.
lookup[0] = tex2D(mHex, _UVs).rgb;
lookup[1] = tex2D(TR, _UVs).rgb;
lookup[2] = tex2D(R, _UVs).rgb;
lookup[3] = tex2D(BR, _UVs).rgb;
lookup[4] = tex2D(BL, _UVs).rgb;
lookup[5] = tex2D(L, _UVs).rgb;
lookup[6] = tex2D(TL, _UVs).rgb;

for (j=0;j<6;j++)
{
 iMin = j;
 for (i = j+1; i<6;i++)
 {
  if (a[i] < a[iMin]
)
  {
    iMin = i;
  }
 }

 if (iMin != j)
 {
  temp = 
a[j];
  a[j] = a[iMin];
  a[iMin] = temp;

  intTemp = 
b[j];
  b[j] = b[iMin];
  b[iMin] = intTemp;

  intTemp = mTexases[j+1];
  mTexases[j+1] = mTexases[iMin+1];
  mTexases[iMin+1] = intTemp;
 }
}

iMax = a[1];

float exp = 5.0;

float interp1 = pow(abs(a[0]-1),exp);
float interp2 = pow(abs(a[1]-1),exp);
float interp3 = pow(abs(a[2]-1),exp);

/*
tempColor = (interp1*lookup[b[0]+1] + 
	interp2*lookup[b[1]+1] +
	interp3*lookup[b[2]+1]) / (interp1 + interp2 + interp3);
*/
tempColor = (interp1*lookup[mTexases[1]] + 
	interp2*lookup[mTexases[2]] +
	interp3*lookup[mTexases[3]]) / (interp1 + interp2 + interp3);

float interp0 = pow(abs(a[0] - 1), 2.2);

//return lerp(lookup[mTexases[0]], tempColor, interp0);
return test;
//return float3(2/Radius,0,0);
//mSize /= 10;
//return float3(mSize / 2,0,0);
//return tex2D(TexMap, float2(0.6,0.1)).rgb;
//int3 temp2 = int3(hexDeltas[0].x + myHex.x, hexDeltas[0].y + 
//myHex.y, hexDeltas[0].z + myHex.z);
//return HexOrigin;
//return myHex;
//return float3(rx,ry,rz);
//return HexOriginCubeCoords;

Raenir Salazar fucked around with this message at 14:38 on Sep 2, 2015

Raenir Salazar fucked around with this message at 03:51 on Sep 4, 2015

Joda fucked around with this message at 06:40 on Sep 5, 2015

Raenir Salazar fucked around with this message at 04:31 on Sep 8, 2015

Raenir Salazar fucked around with this message at 17:19 on Sep 8, 2015

Sex Bumbo fucked around with this message at 18:45 on Sep 8, 2015

// E: AB - R
// F: ED - L
// A: EF - BL
// B: BC - TR
// C: CD - TL
// D: AF - BR

// Firstly, convert given x,y,z coordinates in worldspace to axial/cube coordinates.
float mSize = 1;

float column = ((HexOrigin.x * (float(sqrt(3)) / (3))) - (float(HexOrigin.z) / (3))) / mSize;
float row = (HexOrigin.z * (float(2) / (3))) / mSize;

// z because worldspace from the camera angle is X,Z instead of X,Y because reasons.

float3 HexOriginCubeCoords = float3(column,-column-row,row);

// now we round..

int rx = round(HexOriginCubeCoords.x);
int ry = round(HexOriginCubeCoords.y);
int rz = round(HexOriginCubeCoords.z);

float x_diff = abs(rx - HexOriginCubeCoords.x);
float y_diff = abs(ry - HexOriginCubeCoords.y);
float z_diff = abs(rz - HexOriginCubeCoords.z);

if (x_diff > y_diff && x_diff > z_diff)
{
    rx=-ry-rz;
}
else if (y_diff > z_diff)
{
    ry = -rx-rz;
}
else
{
	rz = -rx-ry;
}

int3 myHex_Cube = int3(rx,ry,rz);

// convert back to even-r
float q = myHex_Cube.x + ceil(float(myHex_Cube.z + (int(myHex_Cube.z) % 1)) / 2);
float r = myHex_Cube.z;

float2 mHexCoord = float2(q/(MapWidth - 1),1.0 - (-r/(MapHeight - 1)));

// We now know for sure "where" our tile is in cube coordinates.
// Now we need to find out which textures are being used in neigbhouring hexes.

int mTexases[7]; 

// ID:0 is reserved as "our" texture of the current hex.
// 1 to 6 go from top right clockwise to top left.
float3 _texLookupCol = tex2D(TexMap, mHexCoord).rgb;

// Main texture
mTexases[6] = (_texLookupCol.x * 4) + (_texLookupCol.y * 2) + (_texLookupCol.z * 1);

float2 directions_offset[2][6];

directions_offset[0][0] = float2(1,-1); // TR
directions_offset[0][1] = float2(1,0);  // R
directions_offset[0][2] = float2(1,1);  // BR
directions_offset[0][3] = float2(0,1);  // BL
directions_offset[0][4] = float2(-1,0); // L
directions_offset[0][5] = float2(0,-1); // TL

directions_offset[1][0] = float2(0,-1); // TR
directions_offset[1][1] = float2(1,0);  // R
directions_offset[1][2] = float2(0,1);  // BR
directions_offset[1][3] = float2(-1,+1);  // BL
directions_offset[1][4] = float2(-1,0); // L
directions_offset[1][5] = float2(-1,-1); // TL

// Top Right
int parity = int(r) & 1;
float2 direction = directions_offset[parity][5];
mHexCoord = float2((q+direction.x)/(MapWidth - 1),1.0 - (-(r+direction.y)/(MapHeight - 1)));
_texLookupCol = tex2D(TexMap, mHexCoord).rgb;
mTexases[0] = (_texLookupCol.x * 4) + (_texLookupCol.y * 2) + (_texLookupCol.z * 1);

// Right

direction = directions_offset[parity][4];
mHexCoord = float2((q+direction.x)/(MapWidth - 1),1.0 - (-(r+direction.y)/(MapHeight - 1)));
_texLookupCol = tex2D(TexMap, mHexCoord).rgb;
mTexases[1] = (_texLookupCol.x * 4) + (_texLookupCol.y * 2) + (_texLookupCol.z * 1);

// Bottom Right
direction = directions_offset[parity][3];
mHexCoord = float2((q+direction.x)/(MapWidth - 1),1.0 - (-(r+direction.y)/(MapHeight - 1)));
_texLookupCol = tex2D(TexMap, mHexCoord).rgb;
mTexases[2] = (_texLookupCol.x * 4) + (_texLookupCol.y * 2) + (_texLookupCol.z * 1);

// Bottom Left
direction = directions_offset[parity][2];
mHexCoord = float2((q+direction.x)/(MapWidth - 1),1.0 - (-(r+direction.y)/(MapHeight - 1)));
_texLookupCol = tex2D(TexMap, mHexCoord).rgb;
mTexases[3] = (_texLookupCol.x * 4) + (_texLookupCol.y * 2) + (_texLookupCol.z * 1);

// Left
direction = directions_offset[parity][1];
mHexCoord = float2((q+direction.x)/(MapWidth - 1),1.0 - (-(r+direction.y)/(MapHeight - 1)));
_texLookupCol = tex2D(TexMap, mHexCoord).rgb;
mTexases[4] = (_texLookupCol.x * 4) + (_texLookupCol.y * 2) + (_texLookupCol.z * 1);

// Top Left
direction = directions_offset[parity][0];
mHexCoord = float2((q+direction.x)/(MapWidth - 1),1.0 - (-(r+direction.y)/(MapHeight - 1)));
_texLookupCol = tex2D(TexMap, mHexCoord).rgb;
mTexases[5] = (_texLookupCol.x * 4) + (_texLookupCol.y * 2) + (_texLookupCol.z * 1);
// Okay in theory we now have all of our surrounding textures.


float i,j;
float a[6];
int b[6];
float3 lookup[7];

float3 tempColor;
float iMin;
float iMax;
float temp = 0;
int intTemp = 0;
float interp;

// E: AB - R
// F: ED - L
// A: EF - BL
// B: BC - TR
// C: CD - TL
// D: AF - BR

a[0] = B; //
a[1] = E; //
a[2] = D; //
a[3] = A; //
a[4] = F; //
a[5] = C; //

// These are now the six textures the game currently 
// allows, will switch to texture atlas asap.
lookup[0] = tex2D(_Tex0, _UVs).rgb; //grass
lookup[1] = tex2D(_Tex1, _UVs).rgb; // 
lookup[2] = tex2D(_Tex2, _UVs).rgb;
lookup[3] = tex2D(_Tex3, _UVs).rgb; // clay
lookup[4] = tex2D(_Tex4, _UVs).rgb;
lookup[5] = tex2D(_Tex5, _UVs).rgb; // desert
lookup[6] = tex2D(_Tex6, _UVs).rgb; // forest

for (j=0;j<6;j++)
{
 iMin = j;
 for (i = j+1; i<6;i++)
 {
  if (a[i] < a[iMin]
)
  {
    iMin = i;
  }
 }

 if (iMin != j)
 {
  temp = a[j];
  a[j] = a[iMin];
  a[iMin] = temp;

  intTemp = mTexases[j];
  mTexases[j] = mTexases[iMin];
  mTexases[iMin] = intTemp;
 }
}

iMax = a[1];

float exp = 5.0;

float interp1 = pow(abs(a[0]-1),exp);
float interp2 = pow(abs(a[1]-1),exp);
float interp3 = pow(abs(a[2]-1),exp);

tempColor = (interp1*lookup[mTexases[0]] + 
	interp2*lookup[mTexases[1]] +
	interp3*lookup[mTexases[2]]) / (interp1 + interp2 + interp3);

float interp0 = pow(abs(a[0] - 1), 2.2);

return lerp(lookup[mTexases[6]], tempColor, interp0);
//return lookup[mTexases[6]];

Raenir Salazar fucked around with this message at 03:54 on Sep 10, 2015

Joda fucked around with this message at 13:41 on Sep 10, 2015

Sex Bumbo fucked around with this message at 06:52 on Sep 14, 2015