2D Honeycomb Array

Foamy Ether - A Framework for a
Theory Of Everything

Conceived and written by Peter C.M. Hahn C.E.T.
Copyright © 2005-2008

//////////////////////////////////////////////////

// 2DhoneycombArray.thd

// Blank ether honeycomb array with alternating colors

//////////////////////////////////////////////////

// set background color

scene.backColor=RGB(42, 42, 42);

// turn gravity off

scene.gravity={0,0,0};

// remove shadows for faster rendering

scene.shadow = false;

// use degrees as metric for angles

factory.useDegrees = true;

// turn collision detection off so things don't blow up

factory.detectCollision = false;

// set colors

var green = RGB(0, 255, 0);

var white = RGB(255, 255, 255);

var red = RGB(255, 0, 0);

var yellow = RGB(255, 255, 0);

var blue = RGB(0, 255, 255);

// choose some default material

//Material (density, springConstant, dampingConstant, staticFriction, dynamicFriction, thresholdVelocity);

var mat = Material(1e-8, .0001, .00001, 1, 1);

factory.material = mat ;

// set spring and damper constants

var spngCnst = .00000001;

var dmpCnst = .00000005;

// set dimensions of array

var width = 13; // enter odd number of balls for array width 21

var depth = 35; // enter odd number of balls for array depth 51

var spacing = 10; // enter spacing between balls

var lineIncr = 8; // enter even number increment for line coloring

var ball = "";

var xLong = spacing*2;

var xShort = spacing;

var xOffset = spacing/2;

var zOffset = cos(30)*spacing;

// position camera in middle of array

// consider camera to be hovering over array looking down on x z plane

scene.camera = {spacing*width*1.5, -spacing*width*3, spacing*depth*0.4};

// point camera down at middle of array

scene.lookAt = {spacing*width*1.5, 0, spacing*depth*0.4};

// build array of spheres

var z = 0;

var place = 0;

var s = array();

for (z=0; z < depth; z++) {

s.append(array());

for (var x=0; x < width; x++) {

if (z%2 == 1){

ball = Sphere(1, {place,0,z*zOffset});

s[z].append(ball);

place += xLong;

ball = Sphere(1, {place,0,z*zOffset});

s[z].append(ball);

place += xShort;

}else{

ball = Sphere(1, {place+xOffset,0,z*zOffset});

s[z].append(ball);

place += xShort;

ball = Sphere(1, {place+xOffset,0,z*zOffset});

s[z].append(ball);

place += xLong;

}

place = 0;

}

// build array of springs and dampers attaching to balls on x axis

//build x springs on odd rows

var spx = array();

var dpx = array();

var dmpr = "";

var sprng = "";

var i = 0;

for (z=0; z < depth; z+=2) {

spx.append(array());

dpx.append(array());

for (var x=0; x < width*2-1; x+=2) {

// make spring and attach to adjacent spheres

sprng = Spring(s[z][x],{0,0,0},s[z][x+1],{0,0,0});

sprng.springConstant = spngCnst;

spx[i].append(sprng);

// make damper and attach to adjacent spheres

dmpr = Damper(s[z][x],{0,0,0},s[z][x+1],{0,0,0});

dmpr.damperConstant = dmpCnst;

dpx[i].append(dmpr);

}

i++;

}

//build x springs on even rows

var spx2 = array();

var dpx2 = array();

i = 0;

for (z=1; z < depth; z+=2) {

spx2.append(array());

dpx2.append(array());

for (var x=1; x < width*2-1; x+=2) {

// make spring and attach to adjacent spheres

sprng = Spring(s[z][x],{0,0,0},s[z][x+1],{0,0,0});

sprng.springConstant = spngCnst;

spx2[i].append(sprng);

// make damper and attach to adjacent spheres

dmpr = Damper(s[z][x],{0,0,0},s[z][x+1],{0,0,0});

dmpr.damperConstant = dmpCnst;

dpx2[i].append(dmpr);

}

i++;

}

//build z springs

var spz = array();

var dpz = array();

i = 0;

for (z=0; z < depth-1; z++) {

spz.append(array());

dpz.append(array());

for (var x=0; x < width*2; x++) {

// make spring and attach to adjacent spheres

sprng = Spring(s[z][x],{0,0,0},s[z+1][x],{0,0,0});

sprng.springConstant = spngCnst;

spz[i].append(sprng);

// make damper and attach to adjacent spheres

dmpr = Damper(s[z][x],{0,0,0},s[z+1][x],{0,0,0});

dmpr.damperConstant = dmpCnst;

dpz[i].append(dmpr);

}

i++;

}

//make outer balls stationary

//top

for (i=0; i < width*2; i++) {

s[0][i].static = true;

}

//bottom

for (i=0; i < width*2; i++) {

s[depth-1][i].static = true;

}

//left

for (i=0; i < depth; i++) {

s[i][0].static = true;

}

//right

for (i=0; i < depth; i++) {

s[i][width*2-1].static = true;

}

//make every lineIncr ball and damper green: verticle

for (var x=0; x < width*2; x+=lineIncr) {

for (z=0; z < depth-1; z++) {

dpz[z][x].color = green;

s[z][x].color = green;

dpz[z][x+1].color = green;

s[z+1][x+1].color = green;

}

//make every lineIncr damper green: horizontal

for (z=0; z < depth/2; z+=lineIncr/2) {

for (x=0; x < width; x++) {

dpx[z][x].color = green;

dpx[z+1][x].color = green;

}

for (x=0; x < width-1; x++) {

dpx2[z][x].color = green;

}

//make green to attach to horizontal line

for (x=0; x < width*2; x++) {

for (z=0; z < depth-1; z+=lineIncr) {

dpz[z][x].color = green;

dpz[z+1][x].color = green;

}

// color balls for horizontal line

for (z=0; z < depth-1; z+=lineIncr) {

for (x=0; x < width*2; x++) {

s[z][x].color = green;

s[z+1][x].color = green;

s[z+2][x].color = green;

}

//reduce damper value

dmpCnst = 1e-8;

for (x=2; x < width*2-2; x++) {

for (z=2; z < depth-3; z++) {

dpz[z][x].damperConstant = dmpCnst;

}

for (z=2; z < depth/2-1; z++) {

for (x=1; x < width-1; x++) {

dpx[z][x].damperConstant = dmpCnst;

}

for (z=1; z < depth/2-1; z++) {

for (x=0; x < width-1; x++) {

dpx2[z][x].damperConstant = dmpCnst;

}

WaitFrame();