/** * 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); }