# [Shader] Game of Life or circuitry ?

So some guy posted not to long ago he was doing the game of life.

I thought about how to doing this with a shader and gave it a go.

Basically i just drew from a rendertarget to rendertarget with preservecontents on, so from 1 to 2. Then 2 to 1 and so on each frame. Drawing the results to the screen to see it depending on which rendertarget was in rotations that frame.
.
I started playing around with the rules and came up with something really neat that i wanted to share because it looks so cool.

I give you i dunno Circuitry ?. the shader is below if you would like to play around with it.

``````#if OPENGL
#define SV_POSITION POSITION
#else
#endif

//_______________________________________________________________
// common
//_______________________________________________________________
float4x4 gworld;
//float4x4 gworldviewprojection;

Texture2D TextureA;
sampler2D TextureSamplerA = sampler_state
{
Texture = <TextureA>;
//MinFilter = Anisotropic;
//MagFilter = Anisotropic;
//MipFilter = Point;
};

{
float4 Position : POSITION0;
float3 Normal : NORMAL0;
float4 Color : COLOR0;
float2 TexureCoordinateA : TEXCOORD0;
};
{
float4 Position : SV_Position;
//float3 Normal : TEXCOORD1;// removed cause it didn't work  NORMAL0;
float4 Color : COLOR0;
float2 TexureCoordinateA : TEXCOORD0;
};
{
float4 Color : COLOR0;
};

{
output.Position = mul(input.Position, gworld); // basically matrix identity
output.TexureCoordinateA = input.TexureCoordinateA;
output.Color = input.Color;
return output;
}

// aiming for a crystal latice, we remove the rule it cant grow and make it grow.
{

float texeldist = .002;
float4 col = tex2D(TextureSamplerA, input.TexureCoordinateA);
float4 col_right = tex2D(TextureSamplerA, input.TexureCoordinateA + float2(texeldist, .0f));
float4 col_left = tex2D(TextureSamplerA, input.TexureCoordinateA + float2(-texeldist, .0f));
float4 col_up = tex2D(TextureSamplerA, input.TexureCoordinateA + float2(.0f, -texeldist));
float4 col_down = tex2D(TextureSamplerA, input.TexureCoordinateA + float2(.0f, texeldist));

float ncount = 0;
if (col_right.x > .1) { ncount += 1.0; }
if (col_left.x > .1) { ncount += 1.0; }
if (col_up.x > .1) { ncount += 1.0; }
if (col_down.x > .1) { ncount += 1.0; }

if (ncount > 0) { col.x += ncount * .01; }

//if (col.x > .1) // the whole to the -1th
//if (col.x > .09) // 10 to the -second 10 *.01
//
if (col.x > .13416) // a value derived from the golden mean and the absolute ramajan value
{
if (ncount == 2 || ncount == 3)
{
// Only if its neighbour is equal to two or three days. it will survive into the next generation;
//col.x += .07; // lets use primes *.01  7 is the closest to the 1.61 value we desire

col.x += .03; // use prime 3 *.01
}
else
{
// if it is less than two, then it would die of loneliness if more than three, it will be dead because of crowding.
//col.x -= .07; // lets use primes *.01  7 is the closest to the 1.61 value we desire

col.x -= .07; // use primes *.01
}
}
else
{
// if you had not a cell, but it has three neighbors, will breed a new cell.
if (ncount == 3)
{
//col.x += .1449; // .09 * 1.61 // based on the golden ratio

col.x += .12; // 12 * .01
}
}

output.Color = saturate(col);
output.Color.w = 1.0;
return output;
}

{
pass
{