public Quad SetupSubQuad(QuadPosition quadPosition)
{
var go = new GameObject(string.Format("Quad_{0}", quadPosition));
var mesh = GodManager.Instance.PrototypeMesh;
mesh.bounds = new Bounds(Vector3.zero, new Vector3(PlanetRadius * 2, PlanetRadius * 2, PlanetRadius * 2));
var quadComponent = go.AddComponent <Quad>();
quadComponent.Planetoid = this;
quadComponent.QuadMesh = mesh;
quadComponent.SetupCorners(quadPosition);
var gc = QuadGenerationConstants.Init(TerrainMaxHeight);
gc.planetRadius = PlanetRadius;
quadComponent.Position = quadPosition;
quadComponent.generationConstants = gc;
quadComponent.ShouldDraw = false;
if (qdtccc == null)
{
qdtccc = new QuadDistanceToClosestCornerComparer();
}
Quads.Add(quadComponent);
Quads.Sort(qdtccc);
return(quadComponent);
}
public void SetupCorners(QuadPosition quadPosition)
{
var v = Planetoid.PlanetRadius / 2;
switch (quadPosition)
{
case QuadPosition.Top:
quadCorners.topLeftCorner = new Vector3(-v, v, v);
quadCorners.bottomRightCorner = new Vector3(v, v, -v);
quadCorners.topRightCorner = new Vector3(v, v, v);
quadCorners.bottomLeftCorner = new Vector3(-v, v, -v);
break;
case QuadPosition.Bottom:
quadCorners.topLeftCorner = new Vector3(-v, -v, -v);
quadCorners.bottomRightCorner = new Vector3(v, -v, v);
quadCorners.topRightCorner = new Vector3(v, -v, -v);
quadCorners.bottomLeftCorner = new Vector3(-v, -v, v);
break;
case QuadPosition.Left:
quadCorners.topLeftCorner = new Vector3(-v, v, v);
quadCorners.bottomRightCorner = new Vector3(-v, -v, -v);
quadCorners.topRightCorner = new Vector3(-v, v, -v);
quadCorners.bottomLeftCorner = new Vector3(-v, -v, v);
break;
case QuadPosition.Right:
quadCorners.topLeftCorner = new Vector3(v, v, -v);
quadCorners.bottomRightCorner = new Vector3(v, -v, v);
quadCorners.topRightCorner = new Vector3(v, v, v);
quadCorners.bottomLeftCorner = new Vector3(v, -v, -v);
break;
case QuadPosition.Front:
quadCorners.topLeftCorner = new Vector3(v, v, v);
quadCorners.bottomRightCorner = new Vector3(-v, -v, v);
quadCorners.topRightCorner = new Vector3(-v, v, v);
quadCorners.bottomLeftCorner = new Vector3(v, -v, v);
break;
case QuadPosition.Back:
quadCorners.topLeftCorner = new Vector3(-v, v, -v);
quadCorners.bottomRightCorner = new Vector3(v, -v, -v);
quadCorners.topRightCorner = new Vector3(v, v, -v);
quadCorners.bottomLeftCorner = new Vector3(-v, -v, -v);
break;
default:
throw new ArgumentOutOfRangeException("quadPosition", quadPosition, null);
}
middleNormalized = CalculateMiddlePoint();
}
public static Vector3 FromQuadPositionMask(float r, byte[] sign, byte[] axis, QuadPosition quadPosition)
{
var indexOf = Array.IndexOf(Enum.GetValues(typeof(QuadPosition)), quadPosition);
var s = (sign[indexOf] == 1) ? -r : r;
var v = axis[indexOf];
var output = new Vector3(v == 0 ? s : 0.0f, v == 1 ? s : 0.0f, v == 2 ? s : 0.0f);
return(output);
}
void RenderQuad2(MeshContext context, Voxel voxel, Vector3 position, Direction direction)
{
var transformedDirection = TransformDirection(direction, voxel);
var quadPos = new QuadPosition(position, context, transformedDirection);
var flippedDir = FlipDirection(transformedDirection);
var flippedPosition = MoveByDirection(position, transformedDirection);
var flippedQuad = new QuadPosition(flippedPosition, context, flippedDir);
if (QuadPositions.Contains(flippedQuad))
{
QuadPositions.Remove(flippedQuad);
return;
}
QuadPositions.Add(quadPos);
}
public void SetupMainQuad(QuadPosition quadPosition)
{
GameObject go = new GameObject(string.Format("Quad_{0}", quadPosition));
go.transform.parent = QuadsRoot.transform;
go.transform.position = Vector3.zero;
go.transform.rotation = Quaternion.identity;
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
Mesh mesh = GetMesh(quadPosition);
mesh.bounds = new Bounds(Vector3.zero, new Vector3(PlanetRadius * 2, PlanetRadius * 2, PlanetRadius * 2));
Material material = MaterialHelper.CreateTemp(ColorShader, "Quad");
Quad quadComponent = go.AddComponent <Quad>();
quadComponent.Planetoid = this;
quadComponent.QuadMesh = mesh;
quadComponent.QuadMaterial = material;
if (Atmosphere != null)
{
Atmosphere.InitUniforms(null, quadComponent.QuadMaterial, false);
}
QuadGenerationConstants gc = QuadGenerationConstants.Init(TerrainMaxHeight);
gc.planetRadius = PlanetRadius;
gc.cubeFaceEastDirection = quadComponent.GetCubeFaceEastDirection(quadPosition);
gc.cubeFaceNorthDirection = quadComponent.GetCubeFaceNorthDirection(quadPosition);
gc.patchCubeCenter = quadComponent.GetPatchCubeCenter(quadPosition);
quadComponent.Position = quadPosition;
quadComponent.ID = QuadID.One;
quadComponent.generationConstants = gc;
quadComponent.SetupCorners(quadPosition);
quadComponent.ShouldDraw = true;
quadComponent.ReadyForDispatch = true;
Quads.Add(quadComponent);
MainQuads.Add(quadComponent);
}
public Vector3 GetPatchCubeCenter(QuadPosition quadPosition)
{
// NOTE : So, here i will construct vector with specific parameters.
// I need unit axis vector, depending on Quad Orientation [QuadPosition] with positive or negative value [Planet Radius].
// "Sign" will represent 'Is value negative or positive?'
// "Axis" will represent one component of vector, which should be 'valued' [X or Y or Z]. Other vector components will be zero...
// TOP (0.0, r, 0.0) SIGN 0 AXIS 0 Y
// BUTTOM (0.0, -r, 0.0) SIGN 1 AXIS 0 Y
// LEFT (-r, 0.0, 0.0) SIGN 1 AXIS 2 X
// RIGHT (r, 0.0, 0.0) SIGN 0 AXIS 2 X
// FRONT (0.0, 0.0, r) SIGN 0 AXIS 1 Z
// BACK (0.0, 0,0, -r) SIGN 1 AXIS 1 Z
var sign = new byte[] { 0, 1, 1, 0, 0, 1 };
var axis = new byte[] { 1, 1, 0, 0, 2, 2 };
return(BrainFuckMath.FromQuadPositionMask(Planetoid.PlanetRadius, sign, axis, quadPosition));
}
public Quad SetupSubQuad(QuadPosition quadPosition)
{
GameObject go = new GameObject(string.Format("Quad_{0}", quadPosition));
Mesh mesh = GetMesh(quadPosition);
mesh.bounds = new Bounds(Vector3.zero, new Vector3(PlanetRadius * 2, PlanetRadius * 2, PlanetRadius * 2));
Material material = MaterialHelper.CreateTemp(ColorShader, "Quad");
Quad quadComponent = go.AddComponent <Quad>();
quadComponent.Planetoid = this;
quadComponent.QuadMesh = mesh;
quadComponent.QuadMaterial = material;
quadComponent.SetupCorners(quadPosition);
if (Atmosphere != null)
{
Atmosphere.InitUniforms(null, quadComponent.QuadMaterial, false);
}
QuadGenerationConstants gc = QuadGenerationConstants.Init(TerrainMaxHeight);
gc.planetRadius = PlanetRadius;
quadComponent.Position = quadPosition;
quadComponent.generationConstants = gc;
quadComponent.ShouldDraw = false;
if (qdtccc == null)
{
qdtccc = new QuadDistanceToClosestCornerComparer();
}
Quads.Add(quadComponent);
Quads.Sort(qdtccc);
return(quadComponent);
}
private void SetupMainQuad(QuadPosition quadPosition)
{
var go = new GameObject(string.Format("Quad_{0}", quadPosition));
go.transform.parent = QuadsRoot.transform;
go.transform.position = Vector3.zero;
go.transform.rotation = Quaternion.identity;
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
var mesh = GodManager.Instance.PrototypeMesh;
mesh.bounds = new Bounds(Vector3.zero, new Vector3(PlanetRadius * 2, PlanetRadius * 2, PlanetRadius * 2));
var quadComponent = go.AddComponent <Quad>();
quadComponent.Planetoid = this;
quadComponent.QuadMesh = mesh;
var gc = QuadGenerationConstants.Init(TerrainMaxHeight);
gc.planetRadius = PlanetRadius;
gc.cubeFaceEastDirection = quadComponent.GetCubeFaceEastDirection(quadPosition);
gc.cubeFaceNorthDirection = quadComponent.GetCubeFaceNorthDirection(quadPosition);
gc.patchCubeCenter = quadComponent.GetPatchCubeCenter(quadPosition);
quadComponent.Position = quadPosition;
quadComponent.ID = QuadID.One;
quadComponent.generationConstants = gc;
quadComponent.SetupCorners(quadPosition);
quadComponent.ShouldDraw = true;
quadComponent.ReadyForDispatch = true;
Quads.Add(quadComponent);
MainQuads.Add(quadComponent);
}
public Quad GetMainQuad(QuadPosition position)
{
return(MainQuads.FirstOrDefault(q => q.Position == position));
}
private Vector3 GetPatchCubeCenterSplitted_Old(QuadPosition quadPosition, int id, bool staticX, bool staticY, bool staticZ)
{
var temp = Vector3.zero;
var r = Planetoid.PlanetRadius;
var v = Planetoid.PlanetRadius / 2;
var tempStatic = 0.0f;
var sign = new byte[][] { new byte[] { 4, 0, 5, 1 },
new byte[] { 7, 3, 6, 2 },
new byte[] { 4, 5, 6, 7 },
new byte[] { 1, 0, 3, 2 },
new byte[] { 0, 4, 2, 6 },
new byte[] { 5, 1, 7, 3 } };
var axis = new byte[] { 2, 2, 4, 4, 1, 1 };
var sideSign = sign[(int)quadPosition][id];
var sideAxis = axis[(int)quadPosition];
var maskVector = BrainFuckMath.MakeBitMask(sideSign);
var maskAxisVector = BrainFuckMath.MakeBitMask(sideAxis);
var vector = BrainFuckMath.ApplyBitMask(maskAxisVector, r, v);
var output = BrainFuckMath.ApplyBitMask(vector, maskVector);
temp = output;
// NOTE : So, here i will construct vector with specific parameters. Much slower than switch { ... }, but F**K OFF! I wanna brainfucking stuff, cuz i can!
// "Sign" will represent 'Wich component of vector what sign have?'
// "Axis" will represent 'What value shoud i use for vector component? Left or right? 1.0 or 0.0?'
// Example [Sign] - 110 - [-X, -Y, Z]
// Example [Axis] - 010 - [0.0, 1.0, 0.0]
// Example [Together] - - [-0.0, -0.0, 0.0]
// AXIS [2, 2, 4, 4, 1, 1]
// TOP (-v, r, v) :0 SIGN 100-4 AXIS 010-2 [4, 0, 5, 1]
// TOP (v, r, v) :1 SIGN 000-0 AXIS 010-2
// TOP (-v, r, -v) :2 SIGN 101-5 AXIS 010-2
// TOP (v, r, -v) :3 SIGN 001-1 AXIS 010-2
// ---------------------------------------------------
// BUTTOM (-v, -r, -v):0 SIGN 111-7 AXIS 010-2 [7, 3, 6, 2]
// BUTTOM (v, -r, -v) :1 SIGN 011-3 AXIS 010-2
// BUTTOM (-v, -r, v) :2 SIGN 110-6 AXIS 010-2
// BUTTOM (v, -r, v) :3 SIGN 010-2 AXIS 010-2
// ---------------------------------------------------
// LEFT (-r, v, v) :0 SIGN 100-4 AXIS 100-4 [4, 5, 6, 7]
// LEFT (-r, v, -v) :1 SIGN 101-5 AXIS 100-4
// LEFT (-r, -v, v) :2 SIGN 110-6 AXIS 100-4
// LEFT (-r, -v, -v):3 SIGN 111-7 AXIS 100-4
// ---------------------------------------------------
// RIGHT (r, v, -v) :0 SIGN 001-1 AXIS 100-4 [1, 0, 3, 2]
// RIGHT (r, v, v) :1 SIGN 000-0 AXIS 100-4
// RIGHT (r, -v, -v) :2 SIGN 011-3 AXIS 100-4
// RIGHT (r, -v, v) :3 SIGN 010-2 AXIS 100-4
// ---------------------------------------------------
// FRONT (v, v, r) :0 SIGN 000-0 AXIS 001-1 [0, 4, 2, 6]
// FRONT (-v, v, r) :1 SIGN 100-4 AXIS 001-1
// FRONT (v, -v, r) :2 SIGN 010-2 AXIS 001-1
// FRONT (-v, -v, r) :3 SIGN 110-6 AXIS 001-1
// ---------------------------------------------------
// BACK (-v, v, -r) :0 SIGN 101-5 AXIS 001-1 [5, 1, 7, 3]
// BACK (v, v, -r) :1 SIGN 001-1 AXIS 001-1
// BACK (-v, -v, -r):2 SIGN 111-7 AXIS 001-1
// BACK (v, -v, -r) :3 SIGN 011-3 AXIS 001-1
BrainFuckMath.LockAxis(ref tempStatic, ref temp, staticX, staticY, staticZ);
BrainFuckMath.CalculatePatchCubeCenter(LODLevel, Parent.generationConstants.patchCubeCenter, ref temp);
BrainFuckMath.UnlockAxis(ref temp, ref tempStatic, staticX, staticY, staticZ);
//Just make sure that our vector values is rounded...
//if(Planetoid.PlanetRadius % 2 == 0) temp = temp.RoundToInt();
//NOTE : FLOATING POINT PRECISION ANYWAY!
return(temp);
}
private Vector3 GetPatchCubeCenterSplitted_New(QuadPosition quadPosition, int id, bool staticX, bool staticY, bool staticZ)
{
// NOTE : Yaaahuuu!
var temp = Vector3.zero;
var tempStatic = 0.0f;
var pcc = Parent.generationConstants.patchCubeCenter;
var fed = Parent.generationConstants.cubeFaceEastDirection / 2.0f;
var fnd = Parent.generationConstants.cubeFaceNorthDirection / 2.0f;
switch (quadPosition)
{
case QuadPosition.Top:
{
if (id == 0)
{
temp = new Vector3(-fnd.x, pcc.y, -fed.z);
}
else if (id == 1)
{
temp = new Vector3(fnd.x, pcc.y, -fed.z);
}
else if (id == 2)
{
temp = new Vector3(-fnd.x, pcc.y, fed.z);
}
else if (id == 3)
{
temp = new Vector3(fnd.x, pcc.y, fed.z);
}
}
break;
case QuadPosition.Bottom:
{
if (id == 0)
{
temp = new Vector3(fnd.x, pcc.y, fed.z);
}
else if (id == 1)
{
temp = new Vector3(-fnd.x, pcc.y, fed.z);
}
else if (id == 2)
{
temp = new Vector3(fnd.x, pcc.y, -fed.z);
}
else if (id == 3)
{
temp = new Vector3(-fnd.x, pcc.y, -fed.z);
}
}
break;
case QuadPosition.Left:
{
if (id == 0)
{
temp = new Vector3(pcc.x, -fed.y, -fnd.z);
}
else if (id == 1)
{
temp = new Vector3(pcc.x, -fed.y, fnd.z);
}
else if (id == 2)
{
temp = new Vector3(pcc.x, fed.y, -fnd.z);
}
else if (id == 3)
{
temp = new Vector3(pcc.x, fed.y, fnd.z);
}
}
break;
case QuadPosition.Right:
{
if (id == 0)
{
temp = new Vector3(pcc.x, -fed.y, -fnd.z);
}
else if (id == 1)
{
temp = new Vector3(pcc.x, -fed.y, fnd.z);
}
else if (id == 2)
{
temp = new Vector3(pcc.x, fed.y, -fnd.z);
}
else if (id == 3)
{
temp = new Vector3(pcc.x, fed.y, fnd.z);
}
}
break;
case QuadPosition.Front:
{
if (id == 0)
{
temp = new Vector3(fed.x, -fnd.y, pcc.z);
}
else if (id == 1)
{
temp = new Vector3(-fed.x, -fnd.y, pcc.z);
}
else if (id == 2)
{
temp = new Vector3(fed.x, fnd.y, pcc.z);
}
else if (id == 3)
{
temp = new Vector3(-fed.x, fnd.y, pcc.z);
}
}
break;
case QuadPosition.Back:
{
if (id == 0)
{
temp = new Vector3(-fed.x, fnd.y, pcc.z);
}
else if (id == 1)
{
temp = new Vector3(fed.x, fnd.y, pcc.z);
}
else if (id == 2)
{
temp = new Vector3(-fed.x, -fnd.y, pcc.z);
}
else if (id == 3)
{
temp = new Vector3(fed.x, -fnd.y, pcc.z);
}
}
break;
}
BrainFuckMath.LockAxis(ref tempStatic, ref temp, staticX, staticY, staticZ);
temp += Parent.generationConstants.patchCubeCenter;
BrainFuckMath.UnlockAxis(ref temp, ref tempStatic, staticX, staticY, staticZ);
return(temp);
}
private Vector3 GetPatchCubeCenterSplitted(QuadPosition quadPosition, int id, bool staticX, bool staticY, bool staticZ, bool sexWithBrain = false)
{
return(sexWithBrain ? GetPatchCubeCenterSplitted_Old(quadPosition, id, staticX, staticY, staticZ) :
GetPatchCubeCenterSplitted_New(quadPosition, id, staticX, staticY, staticZ));
}
public Mesh GetMesh(QuadPosition position)
{
return(GodManager.Instance.PrototypeMesh);
}
public Vector3 GetPatchCubeCenterSplitted(QuadPosition quadPosition, int id, bool staticX, bool staticY, bool staticZ)
{
var temp = Vector3.zero;
var r = Planetoid.PlanetRadius;
var v = Planetoid.PlanetRadius / 2;
var tempStatic = 0.0f;
switch (quadPosition)
{
case QuadPosition.Top:
if (id == 0)
{
temp += new Vector3(-v, r, v);
}
else if (id == 1)
{
temp += new Vector3(v, r, v);
}
else if (id == 2)
{
temp += new Vector3(-v, r, -v);
}
else if (id == 3)
{
temp += new Vector3(v, r, -v);
}
break;
case QuadPosition.Bottom:
if (id == 0)
{
temp += new Vector3(-v, -r, -v);
}
else if (id == 1)
{
temp += new Vector3(v, -r, -v);
}
else if (id == 2)
{
temp += new Vector3(-v, -r, v);
}
else if (id == 3)
{
temp += new Vector3(v, -r, v);
}
break;
case QuadPosition.Left:
if (id == 0)
{
temp += new Vector3(-r, v, v);
}
else if (id == 1)
{
temp += new Vector3(-r, v, -v);
}
else if (id == 2)
{
temp += new Vector3(-r, -v, v);
}
else if (id == 3)
{
temp += new Vector3(-r, -v, -v);
}
break;
case QuadPosition.Right:
if (id == 0)
{
temp += new Vector3(r, v, -v);
}
else if (id == 1)
{
temp += new Vector3(r, v, v);
}
else if (id == 2)
{
temp += new Vector3(r, -v, -v);
}
else if (id == 3)
{
temp += new Vector3(r, -v, v);
}
break;
case QuadPosition.Front:
if (id == 0)
{
temp += new Vector3(v, v, r);
}
else if (id == 1)
{
temp += new Vector3(-v, v, r);
}
else if (id == 2)
{
temp += new Vector3(v, -v, r);
}
else if (id == 3)
{
temp += new Vector3(-v, -v, r);
}
break;
case QuadPosition.Back:
if (id == 0)
{
temp += new Vector3(-v, v, -r);
}
else if (id == 1)
{
temp += new Vector3(v, v, -r);
}
else if (id == 2)
{
temp += new Vector3(-v, -v, -r);
}
else if (id == 3)
{
temp += new Vector3(v, -v, -r);
}
break;
default:
throw new ArgumentOutOfRangeException("quadPosition", quadPosition, null);
}
BrainFuckMath.LockAxis(ref tempStatic, ref temp, staticX, staticY, staticZ);
BrainFuckMath.CalculatePatchCubeCenter(LODLevel, Parent.generationConstants.patchCubeCenter, ref temp);
BrainFuckMath.UnlockAxis(ref temp, ref tempStatic, staticX, staticY, staticZ);
//Just make sure that our vector values is rounded...
//if(Planetoid.PlanetRadius % 2 == 0) temp = temp.RoundToInt();
//NOTE : FLOATING POINT PRECISION ANYWAY!
return(temp);
}
public ColorForQuad(Color color, QuadPosition quadPosition)
{
this.color = color;
this.quadPosition = quadPosition;
}
public static bool Quad(ref Bitmap bmp, QuadPosition qp)
{
if (bmp.PixelFormat != PixelFormat.Format24bppRgb)
return false;
int w = bmp.Width;
int h = bmp.Height;
Bitmap tgt = new Bitmap(w * 2, h * 2, bmp.PixelFormat);
Graphics g = Graphics.FromImage(tgt);
switch (qp)
{
case QuadPosition.qpUpperLeft:
g.DrawImageUnscaled(bmp, 0, 0);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipX);
g.DrawImageUnscaled(bmp, w, 0);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipY);
g.DrawImageUnscaled(bmp, w, h);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipX);
g.DrawImageUnscaled(bmp, 0, h);
break;
case QuadPosition.qpUpperRight:
g.DrawImageUnscaled(bmp, w, 0);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipY);
g.DrawImageUnscaled(bmp, w, h);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipX);
g.DrawImageUnscaled(bmp, 0, h);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipY);
g.DrawImageUnscaled(bmp, 0, 0);
break;
case QuadPosition.qpLowerLeft:
g.DrawImageUnscaled(bmp, 0, h);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipY);
g.DrawImageUnscaled(bmp, 0, 0);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipX);
g.DrawImageUnscaled(bmp, w, 0);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipY);
g.DrawImageUnscaled(bmp, w, h);
break;
case QuadPosition.qpLowerRight:
g.DrawImageUnscaled(bmp, w, h);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipX);
g.DrawImageUnscaled(bmp, 0, h);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipY);
g.DrawImageUnscaled(bmp, 0, 0);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipX);
g.DrawImageUnscaled(bmp, w, 0);
break;
}
g.Dispose();
bmp.Dispose();
bmp = tgt;
return true;
}
