/**
* DrawCubeFacesEditor is a helper method for DrawCubeBlockEditor (for drawing faces specifically)
*/
private static CubeFace DrawCubeFacesEditor(CubeFace face, Cube cube, Atlas atlas)
{
string[] items = new string[6];
for (int i = 0; i < 6; i++)
{
items[i] = ((CubeFace)i).ToString();
}
Texture texture = atlas.GetMaterial().mainTexture;
GUILayout.BeginVertical("box");
face = (CubeFace)GUILayout.Toolbar((int)face, items);
Rect bigRect = GUILayoutUtility.GetAspectRect(items.Length);
for (int i = 0; i < items.Length; i++)
{
Rect position = bigRect;
position.width /= items.Length;
position.x += i * position.width;
Rect face_rect = cube.GetFace((CubeFace)i);
GUI.DrawTextureWithTexCoords(position, texture, face_rect);
}
GUILayout.EndVertical();
return(face);
}
public static Vector3[] GetFaceVertices(CubeFace face, float faceScale, Vector3 facePos)
{
Vector3[] faceVertices = new Vector3[4];
for (var i = 0; i < faceVertices.Length; i++)
{
switch (face)
{
case CubeFace.NORT:
faceVertices[i] = (_vertices[_faceTriangles[0][i]] * faceScale) + facePos;
break;
case CubeFace.WEST:
faceVertices[i] = (_vertices[_faceTriangles[1][i]] * faceScale) + facePos;
break;
case CubeFace.SOUTH:
faceVertices[i] = (_vertices[_faceTriangles[2][i]] * faceScale) + facePos;
break;
case CubeFace.EAST:
faceVertices[i] = (_vertices[_faceTriangles[3][i]] * faceScale) + facePos;
break;
case CubeFace.TOP:
faceVertices[i] = (_vertices[_faceTriangles[4][i]] * faceScale) + facePos;
break;
case CubeFace.BOTTOM:
faceVertices[i] = (_vertices[_faceTriangles[5][i]] * faceScale) + facePos;
break;
}
}
return(faceVertices);
}
static CubeTransformations()
{
// rotations for faces
Vector3[] faceRotations =
{
new Vector3(0, 0, 90),
new Vector3(0, 0, 0),
new Vector3(90, 0, 0),
new Vector3(180, 0, 0),
new Vector3(0, 0, -90),
new Vector3(-90, 0, 0),
};
// default tile is placed in the "up"-position
// all other tiles are rotated with the origin as pivot
Vector3 position = new Vector3(0, .5f, 0);
Transformations = new TRSTransformation[6];
for (CubeFace face = 0; (int)face < 6; face++)
{
Transformations[(int)face] = new TRSTransformation(position,
faceRotations[(int)face]);
}
}
static FlatTransformations()
{
// 1 ^= a whole face (3 tiles)
Vector3[] faceOffsets = new Vector3[6]
{
new Vector3(-1, 1 / 3f, 0),
new Vector3(-0.5f, 1, 0),
new Vector3(-0.5f, 1 / 3f, 0),
new Vector3(-0.5f, -1 / 3f, 0),
new Vector3(0, 1 / 3f, 0),
new Vector3(0.5f, 1 / 3f, 0)
};
Transformations = new TRSTransformation[6, 9];
for (CubeFace face = 0; (int)face < 6; face++)
{
for (int tile = 0; tile < 9; tile++)
{
TRSTransformation transform = new TRSTransformation(faceOffsets[(int)face], new Vector3(0));
transform.Position += new Vector3(1 / 6f * (tile % 3), -1 / 4.5f * (tile / 3), 0);
transform.Scale = new Vector3(1 / 6f, 1 / 4.5f, 1);
Transformations[(int)face, tile] = transform;
}
}
}
public void ChangeFaceSize(CubeFace face, int XSize, int YSize)
{
FaceModel faceModel = FaceModel.ModelsDictionary[face];
IntVector3 sizes = faceModel.GetRealSizes(XSize, YSize, balls.GetLength((int)faceModel.axes[2]));
CreateBoard(sizes);
}
/// <summary> Creates a CubeFace </summary>
/// <param name="parent">Associated parent reference as a QuadTree sibling</param>
/// <param name="pos">Position vector to render the cubeface at</param>
/// <param name="left">The x axis of the plane</param>
/// <param name="forward">The z axis of the plane</param>
/// <param name="scale">The scale of the plane</param>
/// <param name="size">The number of vertices in length/width to create (segments)</param>
private void Initialize(CubeFace parent, Vector3 pos, Vector3 left, Vector3 forward, float scale, int size)
{
this.parent = parent;
this.size = size;
this.scale = scale;
this.position = pos;
this.left = left;
this.forward = forward;
// Centre the plane!
position -= left * (scale / 2);
position -= forward * (scale / 2);
gameObject = new GameObject("CubePlane_" + scale + "_" + size + "_" + pos.ToString());
gameObject.isStatic = true;
gameObject.layer = 8; // To Raycast neighbours
material = new Material(Shader.Find("Standard"));
filter = gameObject.AddComponent <MeshFilter>();
renderer = gameObject.AddComponent <MeshRenderer>();
collider = gameObject.AddComponent <MeshCollider>();
// Ensure hierarchy
if (parent != null)
{
gameObject.transform.parent = parent.gameObject.transform;
}
Generate();
}
/// <summary>
/// Returns the rotation matrix for a given face
/// </summary>
private static Matrix4 RotationMatrixForFace(CubeFace face)
{
switch (face)
{
case CubeFace.LEFT:
return(Matrix4.CreateRotationX(Utility.ToRad(faceRotations[(int)face])));
case CubeFace.RIGHT:
return(Matrix4.CreateRotationX(Utility.ToRad(-faceRotations[(int)face])));
case CubeFace.UP:
return(Matrix4.CreateRotationY(Utility.ToRad(-faceRotations[(int)face])));
case CubeFace.DOWN:
return(Matrix4.CreateRotationY(Utility.ToRad(faceRotations[(int)face])));
case CubeFace.FRONT:
return(Matrix4.CreateRotationZ(Utility.ToRad(-faceRotations[(int)face])));
case CubeFace.BACK:
return(Matrix4.CreateRotationZ(Utility.ToRad(faceRotations[(int)face])));
default:
return(Matrix4.Identity);
}
}
/// <summary>
/// Returns true if face from parameter is directly connected to the face. (true unless its an opposing face)
/// </summary>
private static bool IsConnectedFace(CubeFace startFace, CubeFace endFace)
{
switch (startFace)
{
case CubeFace.Front:
return(endFace != CubeFace.Back);
case CubeFace.Top:
return(endFace != CubeFace.Bottom);
case CubeFace.Back:
return(endFace != CubeFace.Front);
case CubeFace.Bottom:
return(endFace != CubeFace.Top);
case CubeFace.Right:
return(endFace != CubeFace.Left);
case CubeFace.Left:
return(endFace != CubeFace.Right);
default: return(false);
}
}
void RotateCube(CubeFace face)
{
switch (face)
{
case CubeFace.Front:
toRotation = Quaternion.Euler(cubeFront);
break;
case CubeFace.Back:
toRotation = Quaternion.Euler(cubeBack);
break;
case CubeFace.Top:
toRotation = Quaternion.Euler(cubeTop);
break;
case CubeFace.Bottom:
toRotation = Quaternion.Euler(cubeBottom);
break;
case CubeFace.Right:
toRotation = Quaternion.Euler(cubeRigh);
break;
case CubeFace.Left:
toRotation = Quaternion.Euler(cubeLeft);
break;
default:
break;
}
cube.OnCubeRotate(face);
}
private void MapClicksToCreation(CubeFace face, int x, int y, IntVector3 position)
{
if (Input.GetMouseButton(0))
{
if (Input.GetKey(KeyCode.LeftControl))
{
boardData.NextTileObjective((int)face, x, y);
}
else if (Input.GetKey(KeyCode.LeftAlt))
{
boardData.NextTileType((int)face, x, y);
}
else
{
boardData.NextBall(position);
}
}
else if (Input.GetMouseButton(1))
{
if (Input.GetKey(KeyCode.LeftControl))
{
boardData.PreviousTileObjective((int)face, x, y);
}
else if (Input.GetKey(KeyCode.LeftAlt))
{
boardData.PreviousTileType((int)face, x, y);
}
else
{
boardData.PreviousBall(position);
}
}
}
/// <summary>
/// Map a 2d point on a given face of a unit cube to a corresponding point on a unit sphere.
/// </summary>
/// <returns>The to sphere point.</returns>
public static Vec3 CubeToSpherePoint(CubeFace face, double x, double y)
{
switch (face)
{
case CubeFace.Front:
return(CubeToSpherePoint(x, y, -0.5));
case CubeFace.Back:
return(CubeToSpherePoint(-x, y, 0.5));
case CubeFace.Left:
return(CubeToSpherePoint(-0.5, y, x));
case CubeFace.Right:
return(CubeToSpherePoint(0.5, y, -x));
case CubeFace.Top:
return(CubeToSpherePoint(x, 0.5, y));
case CubeFace.Bottom:
return(CubeToSpherePoint(x, -0.5, -y));
default:
return(new Vec3(0, 0, 0));
}
}
private static Vector2 GetCubeUV(CubeFace face, Vector2 sideUV, float expand_coef)
{
sideUV = (sideUV - 0.5f * Vector2.one) / expand_coef + 0.5f * Vector2.one;
switch (face)
{
case CubeFace.Bottom:
return(new Vector2(sideUV.x / 3, sideUV.y / 2));
case CubeFace.Front:
return(new Vector2((1 + sideUV.x) / 3, sideUV.y / 2));
case CubeFace.Back:
return(new Vector2((2 + sideUV.x) / 3, sideUV.y / 2));
case CubeFace.Right:
return(new Vector2(sideUV.x / 3, (1 + sideUV.y) / 2));
case CubeFace.Left:
return(new Vector2((1 + sideUV.x) / 3, (1 + sideUV.y) / 2));
case CubeFace.Top:
return(new Vector2((2 + sideUV.x) / 3, (1 + sideUV.y) / 2));
default:
return(Vector2.zero);
}
}
private static void CornerDown_YellowSide_EdgeDown(FTLPair pair)
{
CubeColor color = pair.Edge.GetColor(p => p.Face != DOWN);
CubeFace targetFace = Cube.GetFace(color);
while (pair.Edge.GetPosition(p => p.Face != DOWN).Face != targetFace)
{
DoMove(DOWN);
}
CubeFace faceToRot = pair.Edge.GetPosition(p => p.Face != DOWN).Face;
int direction = SolvingUtility.GetDelta(pair.Edge.GetColor(p => p.Face != DOWN),
faceToRot, DOWN);
// move edge in right position
DoMove(faceToRot, direction);
// pair the stones
while (pair.Corner.GetColorPosition(color).Face != targetFace)
{
DoMove(DOWN);
}
DoMove(faceToRot, -direction);
// handle as right paired
RightPairedDownLayer(pair);
}
public void UpdateTextureCube(
Texture textureCube,
IntPtr source,
uint sizeInBytes,
CubeFace face,
uint x,
uint y,
uint width,
uint height,
uint mipLevel,
uint arrayLayer)
{
StagingBlock stagingBlock = _memoryPool.Stage(source, sizeInBytes);
NoAllocUpdateTextureCubeEntry entry = new NoAllocUpdateTextureCubeEntry(
textureCube,
stagingBlock,
face,
x,
y,
width,
height,
mipLevel,
arrayLayer);
AddEntry(UpdateTextureCubeEntryID, ref entry);
}
private void rotationLineHolder()
{
CubeFace posFace = PositionFace;
switch (posFace)
{
case CubeFace.Front:
break;
case CubeFace.Right:
transform.Rotate(Vector3.up * 90);
break;
case CubeFace.Back:
transform.Translate(Vector3.forward * -40);
break;
case CubeFace.Left:
transform.Rotate(Vector3.up * 90);
transform.Translate(Vector3.forward * -40);
break;
case CubeFace.Up:
transform.Rotate(Vector3.right * 90);
break;
case CubeFace.Down:
transform.Rotate(Vector3.right * 90);
transform.Translate(Vector3.forward * -40);
break;
}
}
public override Color UVPatternAt(double u, double v, CubeFace face = CubeFace.None)
{
if (v > 0.8)
{
if (u < 0.2)
{
return(b);
}
if (u > 0.8)
{
return(c);
}
}
else if (v < 0.2)
{
if (u < 0.2)
{
return(d);
}
if (u > 0.8)
{
return(e);
}
}
return(a);
}
/// <summary>
/// Bringt einen weißen Kantenstein in die richtige Position relativ zum Pivot
/// </summary>
/// <param name="edge">Der weiße Kantenstein, der in die richtige Position gebracht wird</param>
protected void HandleStone(EdgeStone edge)
{
if (!edge.HasColor(WHITE))
{
throw new ArgumentException("Der Kantenstein muss eine weiße Fläche besitzen", nameof(edge));
}
CubeFace whitePosFace = edge.GetColorPosition(WHITE).Face;
switch (whitePosFace)
{
case UP:
HandleStoneWhiteFace(edge);
break;
case DOWN:
HandleStoneYellowFace(edge);
break;
case LEFT:
case FRONT:
case RIGHT:
case BACK:
int tile = edge.GetColorPosition(WHITE).Tile;
if (tile == 1 || tile == 7)
{
HandleFalseOrientatedStone(edge);
}
else
{
HandleStoneMiddleLayer(edge);
}
break;
}
}
public CubeFace getDominantFace()
{
Dictionary <CubeFace, int> faceCount = new Dictionary <CubeFace, int>();
int count;
foreach (var f in swipedFaces)
{
count = 0;
faceCount.TryGetValue(f.face, out count);
faceCount[f.face] = ++count;
}
CubeFace dominantFace = new CubeFace();
int max = Int32.MinValue;
foreach (var i in faceCount)
{
if (i.Value > max)
{
max = i.Value;
dominantFace = i.Key;
}
}
foreach (var i in faceCount)
{
if (i.Value == max && i.Key != dominantFace)
{
return(CubeFace.None);
}
}
return(dominantFace);
}
internal Quaternion GetFaceRotation(CubeFace faceNumber)
{
switch (faceNumber)
{
case CubeFace.X:
return(Quaternion.Euler(-90, 0, -90));
case CubeFace.MX:
return(Quaternion.Euler(-90, 0, 90));
case CubeFace.Y:
return(Quaternion.Euler(0, 0, 0));
case CubeFace.MY:
return(Quaternion.Euler(0, 180, 180));
case CubeFace.Z:
return(Quaternion.AngleAxis(180, Vector3.forward) * Quaternion.AngleAxis(90, Vector3.right));
case CubeFace.MZ:
return(Quaternion.Euler(-90, 0, 0));
default:
throw new UnhandledSwitchCaseException(faceNumber);
}
}
void IHasAttribute.InitAtrribute(XmlAttribute Attr)
{
switch(Attr.Name)
{
case "mips_generate":
MipGenerate = bool.Parse(Attr.Value);
break;
case "array_index":
ArrayIndex = uint.Parse(Attr.Value);
break;
case "mip_index":
MipIndex = uint.Parse(Attr.Value);
break;
case "depth":
Depth = uint.Parse(Attr.Value);
break;
case "face":
Face = (CubeFace)Enum.Parse(typeof(CubeFace),Attr.Value);
break;
default:
throw new Exception("Invalid Atrribute");
}
}
/// <summary>
/// Gibt den Farbunterschied eines weißen Kantensteins zurück
/// </summary>
/// <param name="edge">Der Kantenstein, dessen Farbunterschied bestimmt werden soll</param>
/// <returns></returns>
protected int GetDelta(EdgeStone edge)
{
CubeColor edgeColor = edge.GetColors().First(c => c != WHITE);
CubeFace face = edge.GetColorPosition(c => c != WHITE).Face;
return(SolvingUtility.GetDelta(edgeColor, face, UP));
}
public override void UpdateTextureCube(
Texture textureCube,
IntPtr source,
uint sizeInBytes,
CubeFace face,
uint x,
uint y,
uint width,
uint height,
uint mipLevel,
uint arrayLayer)
{
Texture2D deviceTexture = Util.AssertSubtype <Texture, D3D11Texture>(textureCube).DeviceTexture;
ResourceRegion resourceRegion = new ResourceRegion(
left: (int)x,
right: (int)x + (int)width,
top: (int)y,
bottom: (int)y + (int)height,
front: 0,
back: 1);
uint srcRowPitch = FormatHelpers.GetSizeInBytes(textureCube.Format) * width;
int subresource = GetSubresource(face, mipLevel, textureCube.MipLevels);
_context.UpdateSubresource(deviceTexture, subresource, resourceRegion, source, (int)srcRowPitch, 0);
}
private static void BuildFaceLight(CubeFace face, Map map, Vector3i pos, MeshBuilder mesh)
{
Vector3i dir = CubeBuilder.directions[(int)face];
Color color = BuildUtils.GetBlockLight(map, pos + dir);
mesh.AddFaceColor(color);
}
internal Vector3 GetTilePosition(CubeFace faceNumber, int sideIndex, int upIndex)
{
float width;
float height;
switch (faceNumber)
{
case CubeFace.X:
case CubeFace.MX:
width = currentModel.Z_SIZE;
height = currentModel.Y_SIZE;
break;
case CubeFace.Y:
case CubeFace.MY:
width = currentModel.X_SIZE;
height = currentModel.Z_SIZE;
break;
case CubeFace.Z:
case CubeFace.MZ:
width = currentModel.X_SIZE;
height = currentModel.Y_SIZE;
break;
default:
throw new UnhandledSwitchCaseException(faceNumber);
}
return(new Vector3(sideIndex - (width - 1) / 2, 0, upIndex - (height - 1) / 2) * TileSize);
}
/// <summary>
/// Turns a plane's vertices into a segment of a sphere
/// - Processes neighbour faces in order to remove gaps/tears
/// </summary>
/// <param name="face">The face in question (aint it an ugly one?)</param>
private void FinalizeFace(CubeFace face)
{
if (face.finalized)
{
return;
}
var verts = face.mesh.vertices;
for (int i = 0; i < verts.Length; i++)
{
verts[i] = verts[i].normalized * (scale + noise(verts[i], 2, 1.7f, 0.1f, scale / size));
}
face.mesh.vertices = verts;
face.mesh.RecalculateNormals();
face.mesh.RecalculateBounds();
ProcessNeighbours(face);
face.filter.sharedMesh = face.mesh;
face.collider.sharedMesh = face.mesh;
face.finalized = true;
}
public override Color UVPatternAt(double u, double v, CubeFace face = CubeFace.None)
{
switch (face)
{
case CubeFace.Left:
return(left.UVPatternAt(u, v));
case CubeFace.Right:
return(right.UVPatternAt(u, v));
case CubeFace.Front:
return(front.UVPatternAt(u, v));
case CubeFace.Back:
return(back.UVPatternAt(u, v));
case CubeFace.Up:
return(up.UVPatternAt(u, v));
case CubeFace.Down:
return(down.UVPatternAt(u, v));
default:
return(Color.Black);
}
}
public bool IsCellFaceVisible(CubeFace face, int x, int y, int z)
{
var isVisible = false;
switch (face)
{
case CubeFace.NORT:
isVisible = z == Depth - 1 || !IsCellVisible(x, y, z + 1);
break;
case CubeFace.SOUTH:
isVisible = z == 0 || !IsCellVisible(x, y, z - 1);
break;
case CubeFace.WEST:
isVisible = x == Depth - 1 || !IsCellVisible(x + 1, y, z);
break;
case CubeFace.EAST:
isVisible = x == 0 || !IsCellVisible(x - 1, y, z);
break;
case CubeFace.TOP:
isVisible = y == Height - 1 || !IsCellVisible(x, y + 1, z);
break;
case CubeFace.BOTTOM:
isVisible = y == 0 || !IsCellVisible(x, y - 1, z);
break;
}
return(isVisible);
}
private uint GetArrayLayer(CubeFace face)
{
switch (face)
{
case CubeFace.NegativeX:
return(1);
case CubeFace.PositiveX:
return(0);
case CubeFace.NegativeY:
return(3);
case CubeFace.PositiveY:
return(2);
case CubeFace.NegativeZ:
return(4);
case CubeFace.PositiveZ:
return(5);
default:
throw Illegal.Value <CubeFace>();
}
}
internal Vector3 GetFacePosition(CubeFace faceNumber)
{
Vector3 result;
switch (faceNumber)
{
case CubeFace.X:
result = Vector3.left * (float)currentModel.X_SIZE / 2;
break;
case CubeFace.MX:
result = Vector3.right * (float)currentModel.X_SIZE / 2;
break;
case CubeFace.Y:
result = Vector3.down * (float)currentModel.Y_SIZE / 2;
break;
case CubeFace.MY:
result = Vector3.up * (float)currentModel.Y_SIZE / 2;
break;
case CubeFace.Z:
result = Vector3.back * (float)currentModel.Z_SIZE / 2;
break;
case CubeFace.MZ:
result = Vector3.forward * (float)currentModel.Z_SIZE / 2;
break;
default:
throw new UnhandledSwitchCaseException(faceNumber);
}
return(result * TileSize);
}
public static float GetRotationToFace(this Vector3 vector, CubeFace face)
{
switch (face)
{
case CubeFace.X:
return(vector.x);
case CubeFace.Y:
return(vector.y);
case CubeFace.Z:
return(vector.z);
case CubeFace.MX:
return(vector.x + 90);
case CubeFace.MY:
return(vector.y + 90);
case CubeFace.MZ:
return(vector.z + 90);
default:
throw new UnhandledSwitchCaseException(face);
}
}
private CubeFace GetOpponentFace(CubeFace face)
{
switch (face)
{
case CubeFace.LEFT:
return(CubeFace.RIGHT);
case CubeFace.UP:
return(CubeFace.DOWN);
case CubeFace.FRONT:
return(CubeFace.BACK);
case CubeFace.DOWN:
return(CubeFace.UP);
case CubeFace.RIGHT:
return(CubeFace.LEFT);
case CubeFace.BACK:
return(CubeFace.FRONT);
default:
throw new ArgumentOutOfRangeException(nameof(face));
}
}
public bool IsMatch(Cube cube)
{
for (int f = 0; f < 4; f++)
{
CubeFace face = CubeSolver.MiddleLayerFaces[f];
CubeColor[] tiles =
{
cube.At(face, 6),
cube.At(face, 7),
cube.At(face, 8)
};
int delta0 = SolvingUtility.NormalizeCount(middleLayerColors[tiles[0]] - middleLayerColors[tiles[1]]);
int delta1 = SolvingUtility.NormalizeCount(middleLayerColors[tiles[0]] - middleLayerColors[tiles[2]]);
int delta2 = SolvingUtility.NormalizeCount(middleLayerColors[tiles[1]] - middleLayerColors[tiles[2]]);
if (delta0 != patternData[f][0] || delta1 != patternData[f][1] || delta2 != patternData[f][2])
{
return(false);
}
}
return(true);
}
public Cube2D(int size, CubeFace[,] c)
{
this.size = size;
this.projection = c;
if (!isValidProjection()) {
throw new InvalidDataException();
}
}
public RubikCube(CubeFace[,] projection, int size, Point3D o, TimeSpan duration, double len = 1, double space = 0.1)
{
this.size = size;
this.origin = o;
this.edge_len = len;
this.space = space;
this.projection = new Cube2D(size, projection);
this.animationDuration = duration;
createCubeFromProjection();
}
public Plane GetPlane(CubeFace face)
{
switch (face)
{
case CubeFace.Left: return new Plane(Vector3.Left, Position.X - Size.X / 2.0f);
case CubeFace.Right: return new Plane(Vector3.Right, Position.X + Size.X / 2.0f);
case CubeFace.Bottom: return new Plane(Vector3.Down, Position.Y - Size.Y / 2.0f);
case CubeFace.Top: return new Plane(Vector3.Up, Position.Y + Size.Y / 2.0f);
default: throw new ArgumentException();
}
}
public void save(string fileName, CubeFace[,] projection, List<KeyValuePair<Move, RotationDirection>> moves)
{
using (StreamWriter f = new StreamWriter(fileName)) {
for (int i = 0; i < size * 4; i++) {
for (int j = 0; j < size * 3; j++) {
f.Write(projection[i, j].ToString() + " ");
}
f.WriteLine();
}
foreach (var m in moves) {
f.WriteLine("{0} {1}", m.Key, m.Value);
}
}
}
public CubeFace[,] read(string fileName, out List<KeyValuePair<Move, RotationDirection>> moves)
{
CubeFace[,] projection = new CubeFace[size * 4, size * 3];
using (StreamReader r = new StreamReader(fileName)) {
for (int i = 0; i < size * 4; i++) {
string[] line = null;
try {
line = r.ReadLine().Split(' ');
}
catch (NullReferenceException) {
throw new InvalidDataException();
}
for (int j = 0; j < size * 3; j++) {
try {
projection[i, j] = (CubeFace)Enum.Parse(typeof(CubeFace), line[j]);
}
catch (ArgumentException) {
throw new InvalidDataException();
}
catch (IndexOutOfRangeException) {
throw new InvalidDataException();
}
}
}
moves = new List<KeyValuePair<Move, RotationDirection>>();
while (!r.EndOfStream) {
string[] line = null;
line = r.ReadLine().Split(' ');
try {
moves.Add(new KeyValuePair<Move, RotationDirection>((Move)Enum.Parse(typeof(Move), line[0]),
(RotationDirection)Enum.Parse(typeof(RotationDirection), line[1])));
}
catch (ArgumentException) {
throw new InvalidDataException();
}
}
}
return projection;
}
public void OnCubeRotate(CubeFace face)
{
projection.Project(face);
}
public void OnCubeRotate(CubeFace face)
{
game.OnCubeRotate(face);
}
// Use this for initialization
void Start()
{
// Initialize values;
this.isWaitingMouseMovement = false;
this.undoStack = new Stack<MoveDone>();
this.redoStack = new Stack<MoveDone>();
this.randomNumberGenerator = new System.Random();
// Initialize the pending rotation queue
this.jobQueue = new Queue<IJob>();
// Initialize the facelist
this.cubeFaceList = new Dictionary<RotatableCubeFaceIndex, CubeFace>();
this.cubeFaceRotationRulesList = new Dictionary<RotatableCubeFaceIndex, CubeFaceRotationRules>();
//Initilizing and configuring the child cube faces into cube face
#region Acquire cube pieces
// Get the center cube piece
var centerCube = this.transform.FindChild("CenterCube").gameObject;
// Get all the center cube pieces
var centerWhite = this.transform.FindChild("CenterWhite").gameObject;
var centerRed = this.transform.FindChild("CenterRed").gameObject;
var centerBlue = this.transform.FindChild("CenterBlue").gameObject;
var centerOrange = this.transform.FindChild("CenterOrange").gameObject;
var centerGreen = this.transform.FindChild("CenterGreen").gameObject;
var centerYellow = this.transform.FindChild("CenterYellow").gameObject;
// Get all the corner pieces
var cornerWhiteRedBlue = this.transform.FindChild("CornerWhiteRedBlue").gameObject;
var cornerWhiteBlueOrange = this.transform.FindChild("CornerWhiteBlueOrange").gameObject;
var cornerWhiteOrangeGreen = this.transform.FindChild("CornerWhiteOrangeGreen").gameObject;
var cornerWhiteGreenRed = this.transform.FindChild("CornerWhiteGreenRed").gameObject;
var cornerYellowRedBlue = this.transform.FindChild("CornerYellowRedBlue").gameObject;
var cornerYellowBlueOrange = this.transform.FindChild("CornerYellowBlueOrange").gameObject;
var cornerYellowOrangeGreen = this.transform.FindChild("CornerYellowOrangeGreen").gameObject;
var cornerYellowGreenRed = this.transform.FindChild("CornerYellowGreenRed").gameObject;
// Get all the edge pieces
var edgeWhiteRed = this.transform.FindChild("EdgeWhiteRed").gameObject;
var edgeWhiteBlue = this.transform.FindChild("EdgeWhiteBlue").gameObject;
var edgeWhiteOrange = this.transform.FindChild("EdgeWhiteOrange").gameObject;
var edgeWhiteGreen = this.transform.FindChild("EdgeWhiteGreen").gameObject;
var edgeRedBlue = this.transform.FindChild("EdgeRedBlue").gameObject;
var edgeBlueOrange = this.transform.FindChild("EdgeBlueOrange").gameObject;
var edgeOrangeGreen = this.transform.FindChild("EdgeOrangeGreen").gameObject;
var edgeGreenRed = this.transform.FindChild("EdgeGreenRed").gameObject;
var edgeYellowRed = this.transform.FindChild("EdgeYellowRed").gameObject;
var edgeYellowBlue = this.transform.FindChild("EdgeYellowBlue").gameObject;
var edgeYellowOrange = this.transform.FindChild("EdgeYellowOrange").gameObject;
var edgeYellowGreen = this.transform.FindChild("EdgeYellowGreen").gameObject;
// Assign the correct center, edge and corner pieces to the white face
var whiteCubeFaceValues = new Dictionary<CubePieceIndex, GameObject>();
whiteCubeFaceValues.Add(CubePieceIndex.TopCenter, edgeWhiteOrange);
whiteCubeFaceValues.Add(CubePieceIndex.CenterLeft, edgeWhiteGreen);
whiteCubeFaceValues.Add(CubePieceIndex.Center, centerWhite);
whiteCubeFaceValues.Add(CubePieceIndex.CenterRight, edgeWhiteBlue);
whiteCubeFaceValues.Add(CubePieceIndex.BottomCenter, edgeWhiteRed);
whiteCubeFaceValues.Add(CubePieceIndex.Topleft, cornerWhiteOrangeGreen);
whiteCubeFaceValues.Add(CubePieceIndex.TopRight, cornerWhiteBlueOrange);
whiteCubeFaceValues.Add(CubePieceIndex.BottomLeft, cornerWhiteGreenRed);
whiteCubeFaceValues.Add(CubePieceIndex.BottomRight, cornerWhiteRedBlue);
var whiteCubeFace = new CubeFace(whiteCubeFaceValues, this.transform.up, centerWhite.transform.position);
// Assign the correct center, edge and corner pieces to the red face
var redCubeFaceValues = new Dictionary<CubePieceIndex, GameObject>();
redCubeFaceValues.Add(CubePieceIndex.TopCenter, edgeWhiteRed);
redCubeFaceValues.Add(CubePieceIndex.CenterLeft, edgeGreenRed);
redCubeFaceValues.Add(CubePieceIndex.Center, centerRed);
redCubeFaceValues.Add(CubePieceIndex.CenterRight, edgeRedBlue);
redCubeFaceValues.Add(CubePieceIndex.BottomCenter, edgeYellowRed);
redCubeFaceValues.Add(CubePieceIndex.Topleft, cornerWhiteGreenRed);
redCubeFaceValues.Add(CubePieceIndex.TopRight, cornerWhiteRedBlue);
redCubeFaceValues.Add(CubePieceIndex.BottomLeft, cornerYellowGreenRed);
redCubeFaceValues.Add(CubePieceIndex.BottomRight, cornerYellowRedBlue);
var redCubeFace = new CubeFace(redCubeFaceValues, this.transform.forward, centerRed.transform.position);
// Assign the correct center, edge and corner pieces to the blue face
var blueCubeFaceValues = new Dictionary<CubePieceIndex, GameObject>();
blueCubeFaceValues.Add(CubePieceIndex.TopCenter, edgeWhiteBlue);
blueCubeFaceValues.Add(CubePieceIndex.CenterLeft, edgeRedBlue);
blueCubeFaceValues.Add(CubePieceIndex.Center, centerBlue);
blueCubeFaceValues.Add(CubePieceIndex.CenterRight, edgeBlueOrange);
blueCubeFaceValues.Add(CubePieceIndex.BottomCenter, edgeYellowBlue);
blueCubeFaceValues.Add(CubePieceIndex.Topleft, cornerWhiteRedBlue);
blueCubeFaceValues.Add(CubePieceIndex.TopRight, cornerWhiteBlueOrange);
blueCubeFaceValues.Add(CubePieceIndex.BottomLeft, cornerYellowRedBlue);
blueCubeFaceValues.Add(CubePieceIndex.BottomRight, cornerYellowBlueOrange);
var blueCubeFace = new CubeFace(blueCubeFaceValues, this.transform.right * -1, centerBlue.transform.position);
// Assign the correct center, edge and corner pieces to the orange face
var orangeCubeFaceValues = new Dictionary<CubePieceIndex, GameObject>();
orangeCubeFaceValues.Add(CubePieceIndex.TopCenter, edgeWhiteOrange);
orangeCubeFaceValues.Add(CubePieceIndex.CenterLeft, edgeBlueOrange);
orangeCubeFaceValues.Add(CubePieceIndex.Center, centerOrange);
orangeCubeFaceValues.Add(CubePieceIndex.CenterRight, edgeOrangeGreen);
orangeCubeFaceValues.Add(CubePieceIndex.BottomCenter, edgeYellowOrange);
orangeCubeFaceValues.Add(CubePieceIndex.Topleft, cornerWhiteBlueOrange);
orangeCubeFaceValues.Add(CubePieceIndex.TopRight, cornerWhiteOrangeGreen);
orangeCubeFaceValues.Add(CubePieceIndex.BottomLeft, cornerYellowBlueOrange);
orangeCubeFaceValues.Add(CubePieceIndex.BottomRight, cornerYellowOrangeGreen);
var orangeCubeFace = new CubeFace(orangeCubeFaceValues, this.transform.forward * -1, centerOrange.transform.position);
// Assign the correct center, edge and corner pieces to the green face
var greenCubeFaceValues = new Dictionary<CubePieceIndex, GameObject>();
greenCubeFaceValues.Add(CubePieceIndex.TopCenter, edgeWhiteGreen);
greenCubeFaceValues.Add(CubePieceIndex.CenterLeft, edgeOrangeGreen);
greenCubeFaceValues.Add(CubePieceIndex.Center, centerGreen);
greenCubeFaceValues.Add(CubePieceIndex.CenterRight, edgeGreenRed);
greenCubeFaceValues.Add(CubePieceIndex.BottomCenter, edgeYellowGreen);
greenCubeFaceValues.Add(CubePieceIndex.Topleft, cornerWhiteOrangeGreen);
greenCubeFaceValues.Add(CubePieceIndex.TopRight, cornerWhiteGreenRed);
greenCubeFaceValues.Add(CubePieceIndex.BottomLeft, cornerYellowOrangeGreen);
greenCubeFaceValues.Add(CubePieceIndex.BottomRight, cornerYellowGreenRed);
var greenCubeFace = new CubeFace(greenCubeFaceValues, this.transform.right, centerGreen.transform.position);
// Assign the correct center, edge and corner pieces to the yellow face
var yellowCubeFaceValues = new Dictionary<CubePieceIndex, GameObject>();
yellowCubeFaceValues.Add(CubePieceIndex.TopCenter, edgeYellowRed);
yellowCubeFaceValues.Add(CubePieceIndex.CenterLeft, edgeYellowGreen);
yellowCubeFaceValues.Add(CubePieceIndex.Center, centerYellow);
yellowCubeFaceValues.Add(CubePieceIndex.CenterRight, edgeYellowBlue);
yellowCubeFaceValues.Add(CubePieceIndex.BottomCenter, edgeYellowOrange);
yellowCubeFaceValues.Add(CubePieceIndex.Topleft, cornerYellowGreenRed);
yellowCubeFaceValues.Add(CubePieceIndex.TopRight, cornerYellowRedBlue);
yellowCubeFaceValues.Add(CubePieceIndex.BottomLeft, cornerYellowOrangeGreen);
yellowCubeFaceValues.Add(CubePieceIndex.BottomRight, cornerYellowBlueOrange);
var yellowCubeFace = new CubeFace(yellowCubeFaceValues, this.transform.up * -1, centerYellow.transform.position);
// Assign the correct center, edge and corner pieces to the centerHorizontal face
var centerHorizontalCubeFaceValues = new Dictionary<CubePieceIndex, GameObject>();
centerHorizontalCubeFaceValues.Add(CubePieceIndex.TopCenter, centerOrange);
centerHorizontalCubeFaceValues.Add(CubePieceIndex.CenterLeft, centerGreen);
centerHorizontalCubeFaceValues.Add(CubePieceIndex.Center, centerCube);
centerHorizontalCubeFaceValues.Add(CubePieceIndex.CenterRight, centerBlue);
centerHorizontalCubeFaceValues.Add(CubePieceIndex.BottomCenter, centerRed);
centerHorizontalCubeFaceValues.Add(CubePieceIndex.Topleft, edgeOrangeGreen);
centerHorizontalCubeFaceValues.Add(CubePieceIndex.TopRight, edgeBlueOrange);
centerHorizontalCubeFaceValues.Add(CubePieceIndex.BottomLeft, edgeGreenRed);
centerHorizontalCubeFaceValues.Add(CubePieceIndex.BottomRight, edgeRedBlue);
var centerHorizontalCubeFace = new CubeFace(centerHorizontalCubeFaceValues, this.transform.up, centerCube.transform.position);
// Assign the correct center, edge and corner pieces to the centerVertical face
var centerVerticalCubeFaceValues = new Dictionary<CubePieceIndex, GameObject>();
centerVerticalCubeFaceValues.Add(CubePieceIndex.TopCenter, centerWhite);
centerVerticalCubeFaceValues.Add(CubePieceIndex.CenterLeft, centerOrange);
centerVerticalCubeFaceValues.Add(CubePieceIndex.Center, centerCube);
centerVerticalCubeFaceValues.Add(CubePieceIndex.CenterRight, centerRed);
centerVerticalCubeFaceValues.Add(CubePieceIndex.BottomCenter, centerYellow);
centerVerticalCubeFaceValues.Add(CubePieceIndex.Topleft, edgeWhiteOrange);
centerVerticalCubeFaceValues.Add(CubePieceIndex.TopRight, edgeWhiteRed);
centerVerticalCubeFaceValues.Add(CubePieceIndex.BottomLeft, edgeYellowOrange);
centerVerticalCubeFaceValues.Add(CubePieceIndex.BottomRight, edgeYellowRed);
var centerVerticalCubeFace = new CubeFace(centerVerticalCubeFaceValues, this.transform.right * -1, centerCube.transform.position);
// Assign the correct center, edge and corner pieces to the centerSideways face
var centerSidewaysCubeFaceValues = new Dictionary<CubePieceIndex, GameObject>();
centerSidewaysCubeFaceValues.Add(CubePieceIndex.TopCenter, centerWhite);
centerSidewaysCubeFaceValues.Add(CubePieceIndex.CenterLeft, centerGreen);
centerSidewaysCubeFaceValues.Add(CubePieceIndex.Center, centerCube);
centerSidewaysCubeFaceValues.Add(CubePieceIndex.CenterRight, centerBlue);
centerSidewaysCubeFaceValues.Add(CubePieceIndex.BottomCenter, centerYellow);
centerSidewaysCubeFaceValues.Add(CubePieceIndex.Topleft, edgeWhiteGreen);
centerSidewaysCubeFaceValues.Add(CubePieceIndex.TopRight, edgeWhiteBlue);
centerSidewaysCubeFaceValues.Add(CubePieceIndex.BottomLeft, edgeYellowGreen);
centerSidewaysCubeFaceValues.Add(CubePieceIndex.BottomRight, edgeYellowBlue);
var centerSidewaysCubeFace = new CubeFace(centerSidewaysCubeFaceValues, this.transform.forward, centerCube.transform.position);
// Add all the completed faces to the face list
this.cubeFaceList.Add(RotatableCubeFaceIndex.Top, whiteCubeFace);
this.cubeFaceList.Add(RotatableCubeFaceIndex.Front, redCubeFace);
this.cubeFaceList.Add(RotatableCubeFaceIndex.Right, blueCubeFace);
this.cubeFaceList.Add(RotatableCubeFaceIndex.Back, orangeCubeFace);
this.cubeFaceList.Add(RotatableCubeFaceIndex.Left, greenCubeFace);
this.cubeFaceList.Add(RotatableCubeFaceIndex.Bottom, yellowCubeFace);
this.cubeFaceList.Add(RotatableCubeFaceIndex.CenterHorizontal, centerHorizontalCubeFace);
this.cubeFaceList.Add(RotatableCubeFaceIndex.CenterVertical, centerVerticalCubeFace);
this.cubeFaceList.Add(RotatableCubeFaceIndex.CenterSideways, centerSidewaysCubeFace);
#endregion
// Configure the affected faces list while doing a clockwise rotation
// The affected faces are listed in the clockwise order, the corresponding boolean value indicates if the row needs to be flipped
// from the previous face
#region Assign cube rotation relationship
// Configure white face
var whiteCubeFaceAffectedFaces = new List<CubeFace>() { redCubeFace, greenCubeFace, orangeCubeFace, blueCubeFace };
var whiteCubeFaceAffectedRows = new List<CubeRowIndex>() { CubeRowIndex.Top, CubeRowIndex.Top, CubeRowIndex.Top, CubeRowIndex.Top };
var whiteCubeFaceRequireToFlip = new List<bool>() { false, false, false, false };
var whiteCubeFaceRotationRule = new CubeFaceRotationRules(whiteCubeFaceAffectedFaces, whiteCubeFaceAffectedRows, whiteCubeFaceRequireToFlip);
// Configure red face
var redCubeFaceAffectedFaces = new List<CubeFace>() { whiteCubeFace, blueCubeFace, yellowCubeFace, greenCubeFace };
var redCubeFaceAffectedRows = new List<CubeRowIndex>() { CubeRowIndex.Bottom, CubeRowIndex.Left, CubeRowIndex.Top, CubeRowIndex.Right };
var redCubeFaceRequireToFlip = new List<bool>() { true, false, true, false };
var redCubeFaceRotationRule = new CubeFaceRotationRules(redCubeFaceAffectedFaces, redCubeFaceAffectedRows, redCubeFaceRequireToFlip);
// Configure blue face
var blueCubeFaceAffectedFaces = new List<CubeFace>() { whiteCubeFace, orangeCubeFace, yellowCubeFace, redCubeFace };
var blueCubeFaceAffectedRows = new List<CubeRowIndex>() { CubeRowIndex.Right, CubeRowIndex.Left, CubeRowIndex.Right, CubeRowIndex.Right };
var blueCubeFaceRequireToFlip = new List<bool>() { false, true, true, false };
var blueCubeFaceRotationRule = new CubeFaceRotationRules(blueCubeFaceAffectedFaces, blueCubeFaceAffectedRows, blueCubeFaceRequireToFlip);
// Configure orange face
var orangeCubeFaceAffectedFaces = new List<CubeFace>() { whiteCubeFace, greenCubeFace, yellowCubeFace, blueCubeFace };
var orangeCubeFaceAffectedRows = new List<CubeRowIndex>() { CubeRowIndex.Top, CubeRowIndex.Left, CubeRowIndex.Bottom, CubeRowIndex.Right };
var orangeCubeFaceRequireToFlip = new List<bool>() { false, true, false, true };
var orangeCubeFaceRotationRule = new CubeFaceRotationRules(orangeCubeFaceAffectedFaces, orangeCubeFaceAffectedRows, orangeCubeFaceRequireToFlip);
// Configure green face
var greenCubeFaceAffectedFaces = new List<CubeFace>() { whiteCubeFace, redCubeFace, yellowCubeFace, orangeCubeFace };
var greenCubeFaceAffectedRows = new List<CubeRowIndex>() { CubeRowIndex.Left, CubeRowIndex.Left, CubeRowIndex.Left, CubeRowIndex.Right };
var greenCubeFaceRequireToFlip = new List<bool>() { true, false, false, true };
var greenCubeFaceRotationRule = new CubeFaceRotationRules(greenCubeFaceAffectedFaces, greenCubeFaceAffectedRows, greenCubeFaceRequireToFlip);
// Configure yellow face
var yellowCubeFaceAffectedFaces = new List<CubeFace>() { redCubeFace, blueCubeFace, orangeCubeFace, greenCubeFace };
var yellowCubeFaceAffectedRows = new List<CubeRowIndex>() { CubeRowIndex.Bottom, CubeRowIndex.Bottom, CubeRowIndex.Bottom, CubeRowIndex.Bottom };
var yellowCubeFaceRequireToFlip = new List<bool>() { false, false, false, false };
var yellowCubeFaceRotationRule = new CubeFaceRotationRules(yellowCubeFaceAffectedFaces, yellowCubeFaceAffectedRows, yellowCubeFaceRequireToFlip);
// Configure centerHorizontal face
var centerHorizontalCubeFaceAffectedFaces = new List<CubeFace>() { orangeCubeFace, blueCubeFace, redCubeFace, greenCubeFace };
var centerHorizontalCubeFaceAffectedRows = new List<CubeRowIndex>() { CubeRowIndex.CenterHorizontal, CubeRowIndex.CenterHorizontal, CubeRowIndex.CenterHorizontal, CubeRowIndex.CenterHorizontal };
var centerHorizontalCubeFaceRequireToFlip = new List<bool>() { false, false, false, false };
var centerHorizontalCubeFaceRotationRule = new CubeFaceRotationRules(centerHorizontalCubeFaceAffectedFaces, centerHorizontalCubeFaceAffectedRows, centerHorizontalCubeFaceRequireToFlip);
// Configure centerVertical face
var centerVerticalCubeFaceAffectedFaces = new List<CubeFace>() { whiteCubeFace, orangeCubeFace, yellowCubeFace, redCubeFace };
var centerVerticalCubeFaceAffectedRows = new List<CubeRowIndex>() { CubeRowIndex.CenterVertical, CubeRowIndex.CenterVertical, CubeRowIndex.CenterVertical, CubeRowIndex.CenterVertical };
var centerVerticalCubeFaceRequireToFlip = new List<bool>() { false, true, true, false };
var centerVerticalCubeFaceRotationRule = new CubeFaceRotationRules(centerVerticalCubeFaceAffectedFaces, centerVerticalCubeFaceAffectedRows, centerVerticalCubeFaceRequireToFlip);
// Configure centerSideways face
var centerSidewaysCubeFaceAffectedFaces = new List<CubeFace>() { whiteCubeFace, blueCubeFace, yellowCubeFace, greenCubeFace };
var centerSidewaysCubeFaceAffectedRows = new List<CubeRowIndex>() { CubeRowIndex.CenterHorizontal, CubeRowIndex.CenterVertical, CubeRowIndex.CenterHorizontal, CubeRowIndex.CenterVertical };
var centerSidewaysCubeFaceRequireToFlip = new List<bool>() { true, false, true, false };
var centerSidewaysCubeFaceRotationRule = new CubeFaceRotationRules(centerSidewaysCubeFaceAffectedFaces, centerSidewaysCubeFaceAffectedRows, centerSidewaysCubeFaceRequireToFlip);
// Add all of the rotation rules to the rotation rule list
this.cubeFaceRotationRulesList.Add(RotatableCubeFaceIndex.Top, whiteCubeFaceRotationRule);
this.cubeFaceRotationRulesList.Add(RotatableCubeFaceIndex.Front, redCubeFaceRotationRule);
this.cubeFaceRotationRulesList.Add(RotatableCubeFaceIndex.Right, blueCubeFaceRotationRule);
this.cubeFaceRotationRulesList.Add(RotatableCubeFaceIndex.Back, orangeCubeFaceRotationRule);
this.cubeFaceRotationRulesList.Add(RotatableCubeFaceIndex.Left, greenCubeFaceRotationRule);
this.cubeFaceRotationRulesList.Add(RotatableCubeFaceIndex.Bottom, yellowCubeFaceRotationRule);
this.cubeFaceRotationRulesList.Add(RotatableCubeFaceIndex.CenterHorizontal, centerHorizontalCubeFaceRotationRule);
this.cubeFaceRotationRulesList.Add(RotatableCubeFaceIndex.CenterVertical, centerVerticalCubeFaceRotationRule);
this.cubeFaceRotationRulesList.Add(RotatableCubeFaceIndex.CenterSideways, centerSidewaysCubeFaceRotationRule);
#endregion
// Test Code
// this.jobQueue.Enqueue(new JobRotateByMouse(RotatableCubeFaceIndex.Front, this, true, false));
// this.jobQueue.Enqueue(new JobStabilize(RotatableCubeFaceIndex.Front, this));
// this.jobQueue.Enqueue(new JobReassignFaces(RotatableCubeFaceIndex.Front, this));
}
private void AddUV (List<Vector2> uvs, int blockType, CubeFace face, bool isOnTop) {
Vector2 offSet = Vector2.zero;
float padding = 5f;
Vector2 padding0 = new Vector2 (padding / 1024f, padding / 1024f);
Vector2 padding1 = new Vector2 (padding / 1024f, - padding / 1024f);
Vector2 padding2 = new Vector2 (- padding / 1024f, - padding / 1024f);
Vector2 padding3 = new Vector2 (- padding / 1024f, padding / 1024f);
if (blockType == 1) {
offSet = new Vector2 (0f, 3f/4f);
}
else if (blockType == 2) {
uvs.Add (new Vector2 (0f, 0f));
uvs.Add (new Vector2 (0f, 1f));
uvs.Add (new Vector2 (1f, 1f));
uvs.Add (new Vector2 (1f, 0f));
return;
}
else if (blockType == 3) {
offSet = new Vector2 (1f/4f, 3f/4f);
}
else if (blockType == 4) {
offSet = new Vector2 (1f/2f, 3f/4f);
}
else if (blockType == 5) {
offSet = new Vector2 (3f/4f, 3f/4f);
}
if (face == CubeFace.Top) {
uvs.Add (offSet + new Vector2 (0f, 1f/8f) + padding0);
uvs.Add (offSet + new Vector2 (0f, 2f/8f) + padding1);
uvs.Add (offSet + new Vector2 (1f/8f, 2f/8f) + padding2);
uvs.Add (offSet + new Vector2 (1f/8f, 1f/8f) + padding3);
}
else if ((face == CubeFace.Side) && isOnTop) {
uvs.Add (offSet + new Vector2 (1f/8f, 1f/8f) + padding0);
uvs.Add (offSet + new Vector2 (1f/8f, 2f/8f) + padding1);
uvs.Add (offSet + new Vector2 (2f/8f, 2f/8f) + padding2);
uvs.Add (offSet + new Vector2 (2f/8f, 1f/8f) + padding3);
}
else if (((face == CubeFace.Side) && !isOnTop) || (face == CubeFace.Bottom)) {
uvs.Add (offSet + new Vector2 (0f, 0f) + padding0);
uvs.Add (offSet + new Vector2 (0f, 1f/8f) + padding1);
uvs.Add (offSet + new Vector2 (1f/8f, 1f/8f) + padding2);
uvs.Add (offSet + new Vector2 (1f/8f, 0f) + padding3);
}
}
private Dictionary<CubeFace, Material> setFaceColorsFromProjection(int x, int y, int z, CubeFace[,] p)
{
Dictionary<Tuple<int, int, int>, Dictionary<CubeFace, Material>> colors = new Dictionary<Tuple<int, int, int>, Dictionary<CubeFace, Material>> {
{new Tuple<int, int, int>(0, 0, 0), new Dictionary<CubeFace, Material>{
{CubeFace.L, faceColors[p[3,2]]},
{CubeFace.B, faceColors[p[2,3]]},
{CubeFace.D, faceColors[p[3,3]]},
}},
{new Tuple<int, int, int>(1, 0, 0), new Dictionary<CubeFace, Material>{
{CubeFace.D, faceColors[p[3,4]]},
{CubeFace.B, faceColors[p[2,4]]},
}},
{new Tuple<int, int, int>(2, 0, 0), new Dictionary<CubeFace, Material>{
{CubeFace.R, faceColors[p[3,6]]},
{CubeFace.B, faceColors[p[2,5]]},
{CubeFace.D, faceColors[p[3,5]]},
}},
{new Tuple<int, int, int>(0, 0, 1), new Dictionary<CubeFace, Material>{
{CubeFace.L, faceColors[p[4,2]]},
{CubeFace.D, faceColors[p[4,3]]},
}},
{new Tuple<int, int, int>(1, 0, 1), new Dictionary<CubeFace, Material>{
{CubeFace.D, faceColors[p[4,4]]},
}},
{new Tuple<int, int, int>(2, 0, 1), new Dictionary<CubeFace, Material>{
{CubeFace.R, faceColors[p[4,6]]},
{CubeFace.D, faceColors[p[4,5]]},
}},
{new Tuple<int, int, int>(0, 0, 2), new Dictionary<CubeFace, Material>{
{CubeFace.L, faceColors[p[5,2]]},
{CubeFace.F, faceColors[p[6,3]]},
{CubeFace.D, faceColors[p[5,3]]},
}},
{new Tuple<int, int, int>(1, 0, 2), new Dictionary<CubeFace, Material>{
{CubeFace.F, faceColors[p[6,4]]},
{CubeFace.D, faceColors[p[5,4]]},
}},
{new Tuple<int, int, int>(2, 0, 2), new Dictionary<CubeFace, Material>{
{CubeFace.R, faceColors[p[5,6]]},
{CubeFace.F, faceColors[p[6,5]]},
{CubeFace.D, faceColors[p[5,5]]},
}},
{new Tuple<int, int, int>(0, 1, 0), new Dictionary<CubeFace, Material>{
{CubeFace.L, faceColors[p[3,1]]},
{CubeFace.B, faceColors[p[1,3]]},
}},
{new Tuple<int, int, int>(1, 1, 0), new Dictionary<CubeFace, Material>{
{CubeFace.B, faceColors[p[1,4]]},
}},
{new Tuple<int, int, int>(2, 1, 0), new Dictionary<CubeFace, Material>{
{CubeFace.R, faceColors[p[3,7]]},
{CubeFace.B, faceColors[p[1,5]]},
}},
{new Tuple<int, int, int>(0, 1, 1), new Dictionary<CubeFace, Material>{
{CubeFace.L, faceColors[p[4,1]]},
}},/*
{new Tuple<int, int, int>(1, 1, 1), new Dictionary<CubeFace, Material>{
{CubeFace.B, faceColors[p[1,4]]}, //empty because we are in the middle of the cube!
}},*/
{new Tuple<int, int, int>(2, 1, 1), new Dictionary<CubeFace, Material>{
{CubeFace.R, faceColors[p[4,7]]},
}},
{new Tuple<int, int, int>(0, 1, 2), new Dictionary<CubeFace, Material>{
{CubeFace.L, faceColors[p[5,1]]},
{CubeFace.F, faceColors[p[7,3]]},
}},
{new Tuple<int, int, int>(1, 1, 2), new Dictionary<CubeFace, Material>{
{CubeFace.F, faceColors[p[7,4]]},
}},
{new Tuple<int, int, int>(2, 1, 2), new Dictionary<CubeFace, Material>{
{CubeFace.R, faceColors[p[5,7]]},
{CubeFace.F, faceColors[p[7,5]]},
}},
{new Tuple<int, int, int>(0, 2, 0), new Dictionary<CubeFace, Material>{
{CubeFace.L, faceColors[p[3,0]]},
{CubeFace.B, faceColors[p[0,3]]},
{CubeFace.U, faceColors[p[11,3]]},
}},
{new Tuple<int, int, int>(1, 2, 0), new Dictionary<CubeFace, Material>{
{CubeFace.U, faceColors[p[11,4]]},
{CubeFace.B, faceColors[p[0,4]]},
}},
{new Tuple<int, int, int>(2, 2, 0), new Dictionary<CubeFace, Material>{
{CubeFace.R, faceColors[p[3,8]]},
{CubeFace.B, faceColors[p[0,5]]},
{CubeFace.U, faceColors[p[11,5]]},
}},
{new Tuple<int, int, int>(0, 2, 1), new Dictionary<CubeFace, Material>{
{CubeFace.L, faceColors[p[4,0]]},
{CubeFace.U, faceColors[p[10,3]]},
}},
{new Tuple<int, int, int>(1, 2, 1), new Dictionary<CubeFace, Material>{
{CubeFace.U, faceColors[p[10,4]]},
}},
{new Tuple<int, int, int>(2, 2, 1), new Dictionary<CubeFace, Material>{
{CubeFace.R, faceColors[p[4,8]]},
{CubeFace.U, faceColors[p[10,5]]},
}},
{new Tuple<int, int, int>(0, 2, 2), new Dictionary<CubeFace, Material>{
{CubeFace.L, faceColors[p[5,0]]},
{CubeFace.F, faceColors[p[8,3]]},
{CubeFace.U, faceColors[p[9,3]]},
}},
{new Tuple<int, int, int>(1, 2, 2), new Dictionary<CubeFace, Material>{
{CubeFace.U, faceColors[p[9,4]]},
{CubeFace.F, faceColors[p[8,4]]},
}},
{new Tuple<int, int, int>(2, 2, 2), new Dictionary<CubeFace, Material>{
{CubeFace.R, faceColors[p[5,8]]},
{CubeFace.F, faceColors[p[8,5]]},
{CubeFace.U, faceColors[p[9,5]]},
}},
};
return colors[new Tuple<int, int, int>(x, y, z)];
}
public SwipedFace(CubeFace f, SwipeDirection direction, int layer)
{
this.face = f;
this.direction = direction;
this.layer = layer;
}
/// <summary>
///
/// </summary>
/// <param name="origin"></param>
/// <param name="rightHanded"></param>
public void SetupCameraCubeFace ( Vector3 origin, CubeFace cubeFace, float near, float far )
{
Matrix view = Matrix.Identity;
Matrix proj = Matrix.Identity;
switch (cubeFace) {
case CubeFace.FacePosX : view = Matrix.LookAtLH( origin, -Vector3.UnitX + origin, Vector3.UnitY ); break;
case CubeFace.FaceNegX : view = Matrix.LookAtLH( origin, Vector3.UnitX + origin, Vector3.UnitY ); break;
case CubeFace.FacePosY : view = Matrix.LookAtLH( origin, -Vector3.UnitY + origin,-Vector3.UnitZ ); break;
case CubeFace.FaceNegY : view = Matrix.LookAtLH( origin, Vector3.UnitY + origin, Vector3.UnitZ ); break;
case CubeFace.FacePosZ : view = Matrix.LookAtLH( origin, -Vector3.UnitZ + origin, Vector3.UnitY ); break;
case CubeFace.FaceNegZ : view = Matrix.LookAtLH( origin, Vector3.UnitZ + origin, Vector3.UnitY ); break;
}
SetupCamera( view, 2*near, 2*near, near, far, 1, 0 );
}
private static extern PixelData Internal_GetPixels(IntPtr thisPtr, CubeFace face, int mipLevel);
private static extern void Internal_SetPixels(IntPtr thisPtr, PixelData data, CubeFace face, int mipLevel);
/// <summary>
/// Sets pixels for the specified mip level of the specified face.
/// </summary>
/// <param name="data">Pixels to assign to the specified mip level. Pixel data must match the mip level size
/// and texture pixel format.</param>
/// <param name="face">Face of the cube to access.</param>
/// <param name="mipLevel">Mip level to set pixels for. Top level (0) is the highest quality.</param>
public void SetPixels(PixelData data, CubeFace face = CubeFace.PositiveX, int mipLevel = 0)
{
Internal_SetPixels(mCachedPtr, data, face, mipLevel);
}
private static extern AsyncOp Internal_GetGPUPixels(IntPtr thisPtr, CubeFace face, int mipLevel);
public static TextureTarget GetTextureCubeTarget(CubeFace cubeFace)
{
if ((int)cubeFace < 0 || (int)cubeFace >= _CubeTargets.Length)
throw new ArgumentOutOfRangeException("cubeFace");
return (_CubeTargets[(int)cubeFace]);
}
public static CubeFace TransformFace(CubeFace face, OpenCog.Map.OCBlockDirection dir) {
if(face == CubeFace.Top || face == CubeFace.Bottom) {
return face;
}
//Front, Right, Back, Left
//0 90 180 270
int angle = 0;
if(face == CubeFace.Right) angle = 90;
if(face == CubeFace.Back) angle = 180;
if(face == CubeFace.Left) angle = 270;
if(dir == OpenCog.Map.OCBlockDirection.X_MINUS) angle += 90;
if(dir == OpenCog.Map.OCBlockDirection.Z_MINUS) angle += 180;
if(dir == OpenCog.Map.OCBlockDirection.X_PLUS) angle += 270;
angle %= 360;
if(angle == 0) return CubeFace.Front;
if(angle == 90) return CubeFace.Right;
if(angle == 180) return CubeFace.Back;
if(angle == 270) return CubeFace.Left;
return CubeFace.Front;
}
public UnityEngine.Vector2[] GetFaceUV(CubeFace face, OpenCog.Map.OCBlockDirection dir) {
face = TransformFace(face, dir);
return _texCoords[ (int)face ];
}
public CubeFace getDominantFace()
{
Dictionary<CubeFace, int> faceCount = new Dictionary<CubeFace,int>();
int count;
foreach(var f in swipedFaces){
count = 0;
faceCount.TryGetValue(f.face, out count);
faceCount[f.face] = ++count;
}
CubeFace dominantFace = new CubeFace();
int max = Int32.MinValue;
foreach (var i in faceCount) {
if (i.Value > max) {
max = i.Value;
dominantFace = i.Key;
}
}
foreach (var i in faceCount) {
if (i.Value == max && i.Key != dominantFace) {
return CubeFace.None;
}
}
return dominantFace;
}
/// <summary>
/// Reads texture pixels directly from the GPU. This is similar to <see cref="GetPixels"/> but the texture doesn't
/// need to be created with <see cref="TextureUsage.CPUCached"/>, and the data will contain any updates performed by
/// the GPU. This method can be potentially slow as it introduces a CPU-GPU synchronization point. Additionally
/// this method is asynchronous which means the data is not available immediately.
/// </summary>
/// <param name="face">Face of the cube to access.</param>
/// <param name="mipLevel">Mip level to retrieve pixels for. Top level (0) is the highest quality.</param>
/// <returns><see cref="AsyncOp"/> object that will contain <see cref="PixelData"/> object when the operation
/// completes.</returns>
public AsyncOp GetGPUPixels(CubeFace face = CubeFace.PositiveX, int mipLevel = 0)
{
return Internal_GetGPUPixels(mCachedPtr, face, mipLevel);
}
/// <summary>
/// Gets render target surface for given mip level.
/// </summary>
/// <param name="mipLevel"></param>
/// <returns></returns>
public DepthStencilSurface GetSurface ( CubeFace face )
{
return surfaces[ (int)face ];
}
/// <summary>
/// Returns pixels for the specified mip level of the specified face. Pixels will be read from system memory,
/// which means the texture has to be created with <see cref="TextureUsage.CPUCached"/>. If the texture was updated
/// from the GPU the pixels retrieved from this method will not reflect that, and you should use
/// <see cref="GetGPUPixels"/> instead.
/// </summary>
/// <param name="face">Face of the cube to access.</param>
/// <param name="mipLevel">Mip level to retrieve pixels for. Top level (0) is the highest quality.</param>
/// <returns>A set of pixels for the specified mip level.</returns>
public PixelData GetPixels(CubeFace face = CubeFace.PositiveX, int mipLevel = 0)
{
return Internal_GetPixels(mCachedPtr, face, mipLevel);
}
private void filterMoves(CubeFace f)
{
List<SwipedFace> filteredSwipedFaces = new List<SwipedFace>();
foreach (var i in swipedFaces) {
if (i.face == f) {
filteredSwipedFaces.Add(i);
}
}
this.swipedFaces = filteredSwipedFaces;
}
/// <summary>
/// Gets render target surface for given mip level.
/// </summary>
/// <param name="mipLevel"></param>
/// <returns></returns>
public RenderTargetSurface GetSurface( int mipLevel, CubeFace face )
{
return surfaces[ mipLevel, (int)face ];
}
protected static VertexPositionNormalColorTexture[] CreateQuad(CubeFace face, Vector3 offset,
Vector2[] texture, int textureOffset, int indiciesOffset, out int[] indicies, Color color)
{
indicies = new[] { 0, 1, 3, 1, 2, 3 };
for (int i = 0; i < indicies.Length; i++)
indicies[i] += ((int)face * 4) + indiciesOffset;
var quad = new VertexPositionNormalColorTexture[4];
var unit = CubeMesh[(int)face];
var normal = CubeNormals[(int)face];
var faceColor = new Color(FaceBrightness[(int)face] * color.ToVector3());
for (int i = 0; i < 4; i++)
{
quad[i] = new VertexPositionNormalColorTexture(offset + unit[i], normal, faceColor, texture[textureOffset + i]);
}
return quad;
}
/// <summary>
/// Create a face of the cube
/// </summary>
/// <param name="f">The face that needs to be created</param>
/// <param name="m">Materal to be applied to the face</param>
private void createFace(CubeFace f, Material m)
{
Point3D p0 = new Point3D();
Point3D p1 = new Point3D();
Point3D p2 = new Point3D();
Point3D p3 = new Point3D();
switch (f) {
case CubeFace.F:
/**
* /--------/
* 0-------3 |
* | | |
* | | /
* 1-------2/
*/
p0.X = origin.X;
p0.Y = origin.Y + edge_len;
p0.Z = origin.Z + edge_len;
p1.X = origin.X;
p1.Y = origin.Y;
p1.Z = origin.Z + edge_len;
p2.X = origin.X + edge_len;
p2.Y = origin.Y;
p2.Z = origin.Z + edge_len;
p3.X = origin.X + edge_len;
p3.Y = origin.Y + edge_len;
p3.Z = origin.Z + edge_len;
break;
case CubeFace.R:
/**
* /--------3
* /-------0 |
* | | |
* | | 2
* |-------1/
*/
p0.X = origin.X + edge_len;
p0.Y = origin.Y + edge_len;
p0.Z = origin.Z + edge_len;
p1.X = origin.X + edge_len;
p1.Y = origin.Y;
p1.Z = origin.Z + edge_len;
p2.X = origin.X + edge_len;
p2.Y = origin.Y;
p2.Z = origin.Z;
p3.X = origin.X + edge_len;
p3.Y = origin.Y + edge_len;
p3.Z = origin.Z;
break;
case CubeFace.B:
/**
* 3--------0
* /-------/ |
* | | | |
* | 2 ----|-1
* |-------|/
*/
p0.X = origin.X + edge_len;
p0.Y = origin.Y + edge_len;
p0.Z = origin.Z;
p1.X = origin.X + edge_len;
p1.Y = origin.Y;
p1.Z = origin.Z;
p2 = origin;
p3.X = origin.X;
p3.Y = origin.Y + edge_len;
p3.Z = origin.Z;
break;
case CubeFace.L:
/**
* 0--------/
* 3-------/ |
* | | | |
* | 1 ----|-/
* 2-------|/
*/
p0.X = origin.X;
p0.Y = origin.Y + edge_len;
p0.Z = origin.Z;
p1 = origin;
p2.X = origin.X;
p2.Y = origin.Y;
p2.Z = origin.Z + edge_len;
p3.X = origin.X;
p3.Y = origin.Y + edge_len;
p3.Z = origin.Z + edge_len;
break;
case CubeFace.U:
/**
* 0--------3
* 1-------2 |
* | | |
* | | |
* |-------|/
*/
p0.X = origin.X;
p0.Y = origin.Y + edge_len;
p0.Z = origin.Z;
p1.X = origin.X;
p1.Y = origin.Y + edge_len;
p1.Z = origin.Z + edge_len;
p2.X = origin.X + edge_len;
p2.Y = origin.Y + edge_len;
p2.Z = origin.Z + edge_len;
p3.X = origin.X + edge_len;
p3.Y = origin.Y + edge_len;
p3.Z = origin.Z;
break;
case CubeFace.D:
/**
* /--------/
* /-------/ |
* | | | |
* | 0 ----|-1
* 3-------|2
*/
p0 = origin;
p1.X = origin.X + edge_len;
p1.Y = origin.Y;
p1.Z = origin.Z;
p2.X = origin.X + edge_len;
p2.Y = origin.Y;
p2.Z = origin.Z + edge_len;
p3.X = origin.X;
p3.Y = origin.Y;
p3.Z = origin.Z + edge_len;
break;
}
ModelVisual3D r1 = new ModelVisual3D();
ModelVisual3D r2 = new ModelVisual3D();
r1.Content = Helpers.createTriangleModel(p0, p1, p2, m);
r2.Content = Helpers.createTriangleModel(p0, p2, p3, m);
this.Children.Add(r1);
this.Children.Add(r2);
}
