private void RealizeNode(MCMesh m) { Debug.Log("Realizing node!"); GameObject clone = UnityEngine.Object.Instantiate(MeshPrefab, new Vector3(0, 0, 0), Quaternion.identity); Color c = UtilFuncs.SinColor(m.nodeDepth * 3f); clone.GetComponent <MeshRenderer>().material.color = new Color(c.r, c.g, c.b, 0.9f); clone.transform.localScale = Vector3.one * (WorldSize * m.nodeSize / Resolution); clone.name = "Node " + m.nodeID + ", Depth " + m.nodeDepth; MeshFilter mf = clone.GetComponent <MeshFilter>(); Mesh um = new UnityEngine.Mesh(); um.SetVertices(m.Vertices); um.SetNormals(m.Normals); um.triangles = m.Triangles; mf.mesh = um; clone.GetComponent <Transform>().SetParent(Parent); clone.GetComponent <Transform>().SetPositionAndRotation(m.nodePosition * WorldSize, Quaternion.identity); UnityObjects[m.nodeID] = clone; }
GameObject Meshify(Chunks.Chunk chunk) { GameObject clone = Object.Instantiate(ChunkPrefab, new Vector3(0, 0, 0), Quaternion.identity); Color c = UtilFuncs.SinColor(chunk.LOD * 3f); clone.GetComponent <MeshRenderer>().material.color = new Color(c.r, c.g, c.b, 0.9f); clone.GetComponent <MeshRenderer>().material.SetInt("_LOD", chunk.LOD); clone.GetComponent <MeshRenderer>().material.SetVector("_ChunkPosition", new Vector4(chunk.Position.x, chunk.Position.y, chunk.Position.z)); clone.name = "BENCHMARK test Node " + chunk.Key + ", LOD " + chunk.LOD; MeshFilter mf = clone.GetComponent <MeshFilter>(); mf.mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32; mf.mesh.SetVertices(chunk.Vertices); mf.mesh.SetNormals(chunk.Normals); //mf.mesh.SetUVs(0, chunk.LOD1Vertices); //mf.mesh.SetUVs(1, chunk.LOD1Normals); mf.mesh.triangles = chunk.Triangles; clone.GetComponent <Transform>().SetPositionAndRotation(chunk.Position, Quaternion.identity); clone.GetComponent <Transform>().localScale = Vector3.one * ((float)MinimumChunkSize / (float)Resolution) * Mathf.Pow(2, chunk.LOD); chunk.UnityObject = clone; return(clone); }
public void MeshNode(Node node, ref float totalPolyganizeNodeTime, ref float totalAllBeforeTime, System.Diagnostics.Stopwatch sw) { sw.Start(); GameObject clone = Object.Instantiate(MeshPrefab, new Vector3(0, 0, 0), Quaternion.identity); Color c = UtilFuncs.SinColor(node.Depth * 3f); clone.GetComponent <MeshRenderer>().material.color = new Color(c.r, c.g, c.b, 0.9f); clone.transform.localScale = Vector3.one * (WorldSize * node.Size / Resolution); clone.name = "Node " + node.ID + ", Depth " + node.Depth; MeshFilter mf = clone.GetComponent <MeshFilter>(); sw.Stop(); totalAllBeforeTime += (float)sw.ElapsedMilliseconds / 1000f; sw.Reset(); sw.Start(); MCMesh mcm = SE.Octree.Ops.PolyganizeNode(node, WorldSize, Resolution); Mesh m = new Mesh(); m.SetVertices(mcm.Vertices); m.SetNormals(mcm.Normals); m.triangles = mcm.Triangles; mf.mesh = m; sw.Stop(); totalPolyganizeNodeTime += (float)sw.ElapsedMilliseconds / 1000f; clone.GetComponent <Transform>().SetParent(Parent); clone.GetComponent <Transform>().SetPositionAndRotation(node.Position * WorldSize, Quaternion.identity); UnityObjects[node.ID] = clone; }
public void ExtractSparseOctreeAux(Node node, RT.CS.Node sNode) { for (int i = 0; i < 8; i++) { Node child = node.children[i]; if (child != null) { if (sNode.children == null) { sNode.children = new RT.CS.Node[8]; } sNode.children[i] = new RT.CS.Node(child.position, child.size, sNode.level + 1, false); if (child.chunk != null) { sNode.leaf = true; sNode.color = UtilFuncs.SinColor(sNode.position.x + sNode.position.y + sNode.position.z); sNode.normal = Vector3.up; } else { ExtractSparseOctreeAux(child, sNode.children[i]); } } } }
public static MCMesh PolyganizeNode(Node node, float worldSize, int resolution) { float mul = node.Size; UtilFuncs.Sampler sample = (float x, float y, float z) => UtilFuncs.Sample( (((x * node.Size) / resolution) + node.Position.x) * worldSize, (((y * node.Size) / resolution) + node.Position.y) * worldSize, (((z * node.Size) / resolution) + node.Position.z) * worldSize); /*Node[] neighbors = FindNeighbors(root, node); * * int currentSide = 1; * * for(int i = 0; i < 6; i++) { * if(neighbors[i] != null && neighbors[i].Depth < node.Depth) { * lod |= (byte)currentSide; * } * currentSide = currentSide << (byte)1; * }*/ //node.LODSides = 0; sbyte[][][][] data = GenerateChunkData(resolution, sample); MCMesh m = SE.MarchingCubes.PolygonizeArea(new Vector3(0, 0, 0), node.LODSides, resolution, data); //Mesh m2 = new Mesh(); //m2.SetVertices(m.Vertices); //m2.SetNormals(m.Normals); //m2.triangles = m.Triangles; return(m); }
public void Start() { RaycastTexture = new Texture2D(Screen.width, Screen.height); material.SetTexture("_MainTex", RaycastTexture); root = GenerateOctree((float x, float y, float z) => UtilFuncs.Sphere(x, y, z, 0.8f), MaxLOD); Debug.Log("Generated Octree. ContainsSurface: " + root.ContainsSurface); }
public void ClearLastRayNodeList() { foreach (Node node in currentlyRayedNodes) { //Debug.Log("Clearing node..."); node.Color = UtilFuncs.SinColor(node.Depth); node.Color.a = 0.8f; } currentlyRayedNodes.Clear(); }
public virtual ColoredBox GetColoredBox() { ColoredBox box = new ColoredBox(); box.Center = GetCenter(); box.Color = UtilFuncs.SinColor(level * 2f); box.Color.a = 0.07f; box.Size = Vector3.one * (float)size; return(box); }
public static void DrawOctreeGizmosRecursive(Node node, int depth) { if (node == null) { return; } Gizmos.color = UtilFuncs.SinColor(depth); Gizmos.DrawWireCube(node.position + (Vector3.one * node.size) / 2, node.size * Vector3.one); for (int i = 0; i < 8; i++) { DrawOctreeGizmosRecursive(node.children[i], depth + 1); } }
public void ConstructNode(Node node, int maxDepth, UtilFuncs.Sampler sample) { node.Color = UtilFuncs.SinColor(node.Depth); node.Color.a = 0.8f; if (node.Depth == maxDepth) { node.IsLeaf = true; Vector3 center = node.Min + (Vector3.one * node.Size) / 2f; node.ContainsSurface = sample(center.x, center.y, 0) < 0 ? true : false; node.CompletelyFilled = node.ContainsSurface; } else { node.IsLeaf = false; node.Children = new Node[4]; node.CompletelyFilled = true; for (int i = 0; i < 4; i++) { //Debug.Log("Created child with depth " + (node.Depth + 1)); node.Children[i] = new Node(); node.Children[i].Parent = node; node.Children[i].Size = node.Size / 2f; node.Children[i].Min = node.Min + Constants.qoffsets[i] * (node.Size / 2f); node.Children[i].Depth = node.Depth + 1; ConstructNode(node.Children[i], maxDepth, sample); node.ContainsSurface |= node.Children[i].ContainsSurface; if (!node.Children[i].CompletelyFilled) { node.CompletelyFilled = false; } } if (!node.ContainsSurface) { node.Children = null; node.IsLeaf = true; } if (node.CompletelyFilled) // All children have surface { node.Children = null; node.IsLeaf = true; } } }
private void CreateInstances() { if (IsReady()) { _Instances = new GameObject[NumberInstances()]; Debug.Log($"Noise Move Demo: Created {_Instances.Length} objects to move"); for (int index = 0; index < _Instances.Length; index++) { GameObject instance = GameObject.Instantiate( Prefab, UtilFuncs.MakePosition(index, 0, Sizes, NoiseFunction), Quaternion.identity ); _Instances[index] = instance; } } else { Debug.LogWarning("Prefab setting still NULL"); } }
public void UploadChunk(Chunk chunk) { Interlocked.Decrement(ref NumChunksRemaining); //System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); //sw.Start(); if (chunk.State == ChunkState.Cancelled) { return; } //Debug.Log("Uploading chunk..."); chunk.State = ChunkState.Uploading; GameObject clone = UnityObjectPool.GetObject(); Color c = UtilFuncs.SinColor(chunk.LOD * 3f); clone.GetComponent <MeshRenderer>().material.color = new Color(c.r, c.g, c.b, 0.9f); clone.GetComponent <MeshRenderer>().material.SetInt("_LOD", chunk.LOD); clone.GetComponent <MeshRenderer>().material.SetVector("_ChunkPosition", new Vector4(chunk.Position.x, chunk.Position.y, chunk.Position.z)); clone.name = "Node " + chunk.Key + ", LOD " + chunk.LOD; MeshFilter mf = clone.GetComponent <MeshFilter>(); mf.mesh.SetVertices(chunk.Vertices); mf.mesh.SetNormals(chunk.Normals); //mf.mesh.SetUVs(0, chunk.LOD1Vertices); //mf.mesh.SetUVs(1, chunk.LOD1Normals); mf.mesh.triangles = chunk.Triangles; clone.GetComponent <Transform>().SetParent(Parent); clone.GetComponent <Transform>().SetPositionAndRotation(chunk.Position, Quaternion.identity); clone.GetComponent <Transform>().localScale = Vector3.one * ((float)MinimumChunkSize / (float)Resolution) * Mathf.Pow(2, chunk.LOD); chunk.State = ChunkState.Completed; chunk.UnityObject = clone; //sw.Stop(); //Debug.Log("Uploading mesh took " + sw.ElapsedMilliseconds + "ms"); }
public void Execute(int index) { Positions[index] = UtilFuncs.MakePosition(index, Time, Sizes, NoiseFunction); }
public static void DrawNode(Node node, float worldSize) { Gizmos.color = UtilFuncs.SinColor(((float)(node.Depth) * 15f)); UnityEngine.Gizmos.DrawWireCube((node.Position + new Vector3(node.Size / 2f, node.Size / 2f, node.Size / 2f)) * worldSize, node.Size * Vector3.one * worldSize); }
public static void GenerateRegularCell(Util.GridCell cell, List <Vector3> vertices, List <int> triangles, float isovalue) { Vector3[] vertlist = new Vector3[12]; int i, ntriang; int cubeindex; cubeindex = 0; if (cell.points[0].density < isovalue) { cubeindex |= 1; } if (cell.points[1].density < isovalue) { cubeindex |= 2; } if (cell.points[2].density < isovalue) { cubeindex |= 4; } if (cell.points[3].density < isovalue) { cubeindex |= 8; } if (cell.points[4].density < isovalue) { cubeindex |= 16; } if (cell.points[5].density < isovalue) { cubeindex |= 32; } if (cell.points[6].density < isovalue) { cubeindex |= 64; } if (cell.points[7].density < isovalue) { cubeindex |= 128; } /* Cube is entirely in/out of the surface */ if (Tables.edgeTable[cubeindex] == 0) { return; } /* Find the vertices where the surface intersects the cube */ if ((Tables.edgeTable[cubeindex] & 1) == 1) { vertlist[0] = UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[1]); } if ((Tables.edgeTable[cubeindex] & 2) == 2) { vertlist[1] = UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[2]); } if ((Tables.edgeTable[cubeindex] & 4) == 4) { vertlist[2] = UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[3]); } if ((Tables.edgeTable[cubeindex] & 8) == 8) { vertlist[3] = UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[0]); } if ((Tables.edgeTable[cubeindex] & 16) == 16) { vertlist[4] = UtilFuncs.Lerp(isovalue, cell.points[4], cell.points[5]); } if ((Tables.edgeTable[cubeindex] & 32) == 32) { vertlist[5] = UtilFuncs.Lerp(isovalue, cell.points[5], cell.points[6]); } if ((Tables.edgeTable[cubeindex] & 64) == 64) { vertlist[6] = UtilFuncs.Lerp(isovalue, cell.points[6], cell.points[7]); } if ((Tables.edgeTable[cubeindex] & 128) == 128) { vertlist[7] = UtilFuncs.Lerp(isovalue, cell.points[7], cell.points[4]); } if ((Tables.edgeTable[cubeindex] & 256) == 256) { vertlist[8] = UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[4]); } if ((Tables.edgeTable[cubeindex] & 512) == 512) { vertlist[9] = UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[5]); } if ((Tables.edgeTable[cubeindex] & 1024) == 1024) { vertlist[10] = UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[6]); } if ((Tables.edgeTable[cubeindex] & 2048) == 2048) { vertlist[11] = UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[7]); } /* Create the triangle */ ntriang = 0; for (i = 0; Tables.triTable[cubeindex][i] != -1; i += 3) { ntriang++; } for (i = 0; Tables.triTable[cubeindex][i] != -1; i++) { triangles.Add(vertices.Count); vertices.Add(vertlist[Tables.triTable[cubeindex][i]]); } }
public void Start() { root = GenerateQuadtree((float x, float y, float z) => UtilFuncs.Sphere(x, y, z, 0.8f), MaxLOD); Debug.Log("Generated Quadtree. ContainsSurface: " + root.ContainsSurface); }
public static void PolyganiseTetrahedron(Util.GridCell cell, List <Vector3> vertices, float isovalue) { int triangleIndex = 0; if (cell.points[0].density < isovalue) { triangleIndex |= 1; } if (cell.points[1].density < isovalue) { triangleIndex |= 2; } if (cell.points[2].density < isovalue) { triangleIndex |= 4; } if (cell.points[3].density < isovalue) { triangleIndex |= 8; } // these cases were taken from https://github.com/Calvin-L/MarchingTetrahedrons/blob/master/Decimate.cpp switch (triangleIndex) { case 0: case 15: break; case 0x01: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[1])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[2])); break; case 0x02: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[3])); break; case 0x04: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[1])); break; case 0x08: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[1])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[0])); break; case 0x03: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[1])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[3])); break; case 0x05: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[3])); break; case 0x09: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[1])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[2])); break; case 0x06: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[1])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[2])); break; case 0x0C: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[1])); break; case 0x0A: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[0])); break; case 0x07: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[3], cell.points[1])); break; case 0x0B: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[1])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[2], cell.points[0])); break; case 0x0D: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[0])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[3])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[1], cell.points[2])); break; case 0x0E: vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[1])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[2])); vertices.Add(UtilFuncs.Lerp(isovalue, cell.points[0], cell.points[3])); break; } }
/// <summary> /// Runs an CB opcode post code. This is for instruction that read an write /// on different clock cycles /// </summary> /// <param name="opcode">The opcode to run</param> /// <param name="n">The argument (if any) of the opcode</param> internal static void Run(CPU cpu, byte opcode, ushort n) { switch (opcode) { // RLC B: Rotate B left with carry case 0x00: { break; } // RLC C: Rotate C left with carry case 0x01: { break; } // RLC D: Rotate D left with carry case 0x02: { break; } // RLC E: Rotate E left with carry case 0x03: { break; } // RLC H: Rotate H left with carry case 0x04: { break; } // RLC L: Rotate L left with carry case 0x05: { break; } // RLC (HL): Rotate value pointed by HL left with carry // NOTE: two-stage opcode case 0x06: { var rotateCarry = UtilFuncs.RotateLeftAndCarry(cpu.Registers.TEMP); cpu._memory.Write(cpu.Registers.HL, rotateCarry.Item1); cpu.Registers.FC = rotateCarry.Item2; cpu.Registers.FZ = (byte)((rotateCarry.Item1 == 0) ? 1 : 0); cpu.Registers.FN = 0; cpu.Registers.FH = 0; break; } // RLC A: Rotate A left with carry case 0x07: { break; } // RRC B: Rotate B right with carry case 0x08: { break; } // RRC C: Rotate C right with carry case 0x09: { break; } // RRC D: Rotate D right with carry case 0x0A: { break; } // RRC E: Rotate E right with carry case 0x0B: { break; } // RRC H: Rotate H right with carry case 0x0C: { break; } // RRC L: Rotate L right with carry case 0x0D: { break; } // RRC (HL): Rotate value pointed by HL right with carry // NOTE: two-stage opcode case 0x0E: { var rotateCarry = UtilFuncs.RotateRightAndCarry(cpu.Registers.TEMP); cpu._memory.Write(cpu.Registers.HL, rotateCarry.Item1); cpu.Registers.FC = rotateCarry.Item2; cpu.Registers.FZ = (byte)((rotateCarry.Item1 == 0) ? 1 : 0); cpu.Registers.FN = 0; cpu.Registers.FH = 0; break; } // RRC A: Rotate A right with carry case 0x0F: { break; } // RL B: Rotate B left case 0x10: { break; } // RL C: Rotate C left case 0x11: { break; } // RL D: Rotate D left case 0x12: { break; } // RL E: Rotate E left case 0x13: { break; } // RL H: Rotate H left case 0x14: { break; } // RL L: Rotate L left case 0x15: { break; } // RL (HL): Rotate value pointed by HL left // NOTE: two-stage opcode case 0x16: { var rotateCarry = UtilFuncs.RotateLeftThroughCarry(cpu.Registers.TEMP, 1, cpu.Registers.FC); cpu._memory.Write(cpu.Registers.HL, rotateCarry.Item1); cpu.Registers.FC = rotateCarry.Item2; cpu.Registers.FZ = (byte)((rotateCarry.Item1 == 0) ? 1 : 0); cpu.Registers.FN = 0; cpu.Registers.FH = 0; break; } // RL A: Rotate A left case 0x17: { break; } // RR B: Rotate B right case 0x18: { break; } // RR C: Rotate C right case 0x19: { break; } // RR D: Rotate D right case 0x1A: { break; } // RR E: Rotate E right case 0x1B: { break; } // RR H: Rotate H right case 0x1C: { break; } // RR L: Rotate L right case 0x1D: { break; } // RR (HL): Rotate value pointed by HL right // NOTE: two-stage opcode case 0x1E: { var rotateCarry = UtilFuncs.RotateRightThroughCarry(cpu.Registers.TEMP, 1, cpu.Registers.FC); cpu._memory.Write(cpu.Registers.HL, rotateCarry.Item1); cpu.Registers.FC = rotateCarry.Item2; cpu.Registers.FZ = (byte)((rotateCarry.Item1 == 0) ? 1 : 0); cpu.Registers.FN = 0; cpu.Registers.FH = 0; break; } // RR A: Rotate A right case 0x1F: { break; } // SLA B: Shift B left preserving sign case 0x20: { break; } // SLA C: Shift C left preserving sign case 0x21: { break; } // SLA D: Shift D left preserving sign case 0x22: { break; } // SLA E: Shift E left preserving sign case 0x23: { break; } // SLA H: Shift H left preserving sign case 0x24: { break; } // SLA L: Shift L left preserving sign case 0x25: { break; } // SLA (HL): Shift value pointed by HL left preserving sign // NOTE: two-stage opcode case 0x26: { var shiftCarry = UtilFuncs.ShiftLeft(cpu.Registers.TEMP); cpu._memory.Write(cpu.Registers.HL, shiftCarry.Item1); cpu.Registers.FC = shiftCarry.Item2; cpu.Registers.FZ = (byte)((shiftCarry.Item1 == 0) ? 1 : 0); cpu.Registers.FN = 0; cpu.Registers.FH = 0; break; } // SLA A: Shift A left preserving sign case 0x27: { break; } case 0x28: { break; } // SRA C: Shift C right preserving sign case 0x29: { break; } // SRA D: Shift D right preserving sign case 0x2A: { break; } // SRA E: Shift E right preserving sign case 0x2B: { break; } // SRA H: Shift H right preserving sign case 0x2C: { break; } // SRA L: Shift L right preserving sign case 0x2D: { break; } // SRA (HL): Shift value pointed by HL right preserving sign // NOTE: two-stage opcode case 0x2E: { var shiftCarry = UtilFuncs.ShiftRightArithmetic(cpu.Registers.TEMP); cpu._memory.Write(cpu.Registers.HL, shiftCarry.Item1); cpu.Registers.FC = shiftCarry.Item2; cpu.Registers.FZ = (byte)((shiftCarry.Item1 == 0) ? 1 : 0); cpu.Registers.FN = 0; cpu.Registers.FH = 0; break; } // SRA A: Shift A right preserving sign case 0x2F: { break; } // SWAP B: Swap nybbles in B case 0x30: { break; } // SWAP C: Swap nybbles in C case 0x31: { break; } // SWAP D: Swap nybbles in D case 0x32: { break; } // SWAP E: Swap nybbles in E case 0x33: { break; } // SWAP H: Swap nybbles in H case 0x34: { break; } // SWAP L: Swap nybbles in L case 0x35: { break; } // SWAP (HL): Swap nybbles in value pointed by HL // NOTE: two-stage opcode case 0x36: { byte result = UtilFuncs.SwapNibbles(cpu.Registers.TEMP); cpu._memory.Write(cpu.Registers.HL, result); cpu.Registers.FZ = (byte)(result == 0 ? 1 : 0); cpu.Registers.FN = 0; cpu.Registers.FH = 0; cpu.Registers.FC = 0; break; } // SWAP A: Swap nybbles in A case 0x37: { break; } // SRL B: Shift B right case 0x38: { break; } // SRL C: Shift C right case 0x39: { break; } // SRL D: Shift D right case 0x3A: { break; } // SRL E: Shift E right case 0x3B: { break; } // SRL H: Shift H right case 0x3C: { break; } // SRL L: Shift L right case 0x3D: { break; } // SRL (HL): Shift value pointed by HL right // NOTE: two-stage opcode case 0x3E: { var shiftCarry = UtilFuncs.ShiftRightLogic(cpu.Registers.TEMP); cpu._memory.Write(cpu.Registers.HL, shiftCarry.Item1); cpu.Registers.FC = shiftCarry.Item2; cpu.Registers.FZ = (byte)((shiftCarry.Item1 == 0) ? 1 : 0); cpu.Registers.FN = 0; cpu.Registers.FH = 0; break; } // SRL A: Shift A right case 0x3F: { break; } // BIT 0,B: Test bit 0 of B case 0x40: { break; } // BIT 0,C: Test bit 0 of C case 0x41: { break; } // BIT 0,D: Test bit 0 of D case 0x42: { break; } // BIT 0,E: Test bit 0 of E case 0x43: { break; } // BIT 0,H: Test bit 0 of H case 0x44: { break; } // BIT 0,L: Test bit 0 of L case 0x45: { break; } // BIT 0,(HL): Test bit 0 of value pointed by HL case 0x46: { break; } // BIT 0,A: Test bit 0 of A case 0x47: { break; } // BIT 1,B: Test bit 1 of B case 0x48: { break; } // BIT 1,C: Test bit 1 of C case 0x49: { break; } // BIT 1,D: Test bit 1 of D case 0x4A: { break; } // BIT 1,E: Test bit 1 of E case 0x4B: { break; } // BIT 1,H: Test bit 1 of H case 0x4C: { break; } // BIT 1,L: Test bit 1 of L case 0x4D: { break; } // BIT 1,(HL): Test bit 1 of value pointed by HL case 0x4E: { break; } // BIT 1,A: Test bit 1 of A case 0x4F: { break; } // BIT 2,B: Test bit 2 of B case 0x50: { break; } // BIT 2,C: Test bit 2 of C case 0x51: { break; } // BIT 2,D: Test bit 2 of D case 0x52: { break; } // BIT 2,E: Test bit 2 of E case 0x53: { break; } // BIT 2,H: Test bit 2 of H case 0x54: { break; } // BIT 2,L: Test bit 2 of L case 0x55: { break; } // BIT 2,(HL): Test bit 2 of value pointed by HL case 0x56: { break; } // BIT 2,A: Test bit 2 of A case 0x57: { break; } // BIT 3,B: Test bit 3 of B case 0x58: { break; } // BIT 3,C: Test bit 3 of C case 0x59: { break; } // BIT 3,D: Test bit 3 of D case 0x5A: { break; } // BIT 3,E: Test bit 3 of E case 0x5B: { break; } // BIT 3,H: Test bit 3 of H case 0x5C: { break; } // BIT 3,L: Test bit 3 of L case 0x5D: { break; } // BIT 3,(HL): Test bit 3 of value pointed by HL case 0x5E: { break; } // BIT 3,A: Test bit 3 of A case 0x5F: { break; } // BIT 4,B: Test bit 4 of B case 0x60: { break; } // BIT 4,C: Test bit 4 of C case 0x61: { break; } // BIT 4,D: Test bit 4 of D case 0x62: { break; } // BIT 4,E: Test bit 4 of E case 0x63: { break; } // BIT 4,H: Test bit 4 of H case 0x64: { break; } // BIT 4,L: Test bit 4 of L case 0x65: { break; } // BIT 4,(HL): Test bit 4 of value pointed by HL case 0x66: { break; } // BIT 4,A: Test bit 4 of A case 0x67: { break; } // BIT 5,B: Test bit 5 of B case 0x68: { break; } // BIT 5,C: Test bit 5 of C case 0x69: { break; } // BIT 5,D: Test bit 5 of D case 0x6A: { break; } // BIT 5,E: Test bit 5 of E case 0x6B: { break; } // BIT 5,H: Test bit 5 of H case 0x6C: { break; } // BIT 5,L: Test bit 5 of L case 0x6D: { break; } // BIT 5,(HL): Test bit 5 of value pointed by HL case 0x6E: { break; } // BIT 5,A: Test bit 5 of A case 0x6F: { break; } // BIT 6,B: Test bit 6 of B case 0x70: { break; } // BIT 6,C: Test bit 6 of C case 0x71: { break; } // BIT 6,D: Test bit 6 of D case 0x72: { break; } // BIT 6,E: Test bit 6 of E case 0x73: { break; } // BIT 6,H: Test bit 6 of H case 0x74: { break; } // BIT 6,L: Test bit 6 of L case 0x75: { break; } // BIT 6,(HL): Test bit 6 of value pointed by HL case 0x76: { break; } // BIT 6,A: Test bit 6 of A case 0x77: { break; } // BIT 7,B: Test bit 7 of B case 0x78: { break; } // BIT 7,C: Test bit 7 of C case 0x79: { break; } // BIT 7,D: Test bit 7 of D case 0x7A: { break; } // BIT 7,E: Test bit 7 of E case 0x7B: { break; } // BIT 7,H: Test bit 7 of H case 0x7C: { break; } // BIT 7,L: Test bit 7 of L case 0x7D: { break; } // BIT 7,(HL): Test bit 7 of value pointed by HL case 0x7E: { break; } // BIT 7,A: Test bit 7 of A case 0x7F: { break; } // RES 0,B: Clear (reset) bit 0 of B case 0x80: { break; } // RES 0,C: Clear (reset) bit 0 of C case 0x81: { break; } // RES 0,D: Clear (reset) bit 0 of D case 0x82: { break; } // RES 0,E: Clear (reset) bit 0 of E case 0x83: { break; } // RES 0,H: Clear (reset) bit 0 of H case 0x84: { break; } // RES 0,L: Clear (reset) bit 0 of L case 0x85: { break; } // RES 0,(HL): Clear (reset) bit 0 of value pointed by HL // NOTE: two-stage opcode case 0x86: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.ClearBit(cpu.Registers.TEMP, 0)); break; } // RES 0,A: Clear (reset) bit 0 of A case 0x87: { break; } // RES 1,B: Clear (reset) bit 1 of B case 0x88: { break; } // RES 1,C: Clear (reset) bit 1 of C case 0x89: { break; } // RES 1,D: Clear (reset) bit 1 of D case 0x8A: { break; } // RES 1,E: Clear (reset) bit 1 of E case 0x8B: { break; } // RES 1,H: Clear (reset) bit 1 of H case 0x8C: { break; } // RES 1,L: Clear (reset) bit 1 of L case 0x8D: { break; } // RES 1,(HL): Clear (reset) bit 1 of value pointed by HL // NOTE: two-stage opcode case 0x8E: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.ClearBit(cpu.Registers.TEMP, 1)); break; } // RES 1,A: Clear (reset) bit 1 of A case 0x8F: { break; } // RES 2,B: Clear (reset) bit 2 of B case 0x90: { break; } // RES 2,C: Clear (reset) bit 2 of C case 0x91: { break; } // RES 2,D: Clear (reset) bit 2 of D case 0x92: { break; } // RES 2,E: Clear (reset) bit 2 of E case 0x93: { break; } // RES 2,H: Clear (reset) bit 2 of H case 0x94: { break; } // RES 2,L: Clear (reset) bit 2 of L case 0x95: { break; } // RES 2,(HL): Clear (reset) bit 2 of value pointed by HL // NOTE: two-stage opcode case 0x96: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.ClearBit(cpu.Registers.TEMP, 2)); break; } // RES 2,A: Clear (reset) bit 2 of A case 0x97: { break; } // RES 3,B: Clear (reset) bit 3 of B case 0x98: { break; } // RES 3,C: Clear (reset) bit 3 of C case 0x99: { break; } // RES 3,D: Clear (reset) bit 3 of D case 0x9A: { break; } // RES 3,E: Clear (reset) bit 3 of E case 0x9B: { break; } // RES 3,H: Clear (reset) bit 3 of H case 0x9C: { break; } // RES 3,L: Clear (reset) bit 3 of L case 0x9D: { break; } // RES 3,(HL): Clear (reset) bit 3 of value pointed by HL // NOTE: two-stage opcode case 0x9E: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.ClearBit(cpu.Registers.TEMP, 3)); break; } // RES 3,A: Clear (reset) bit 3 of A case 0x9F: { break; } // RES 4,B: Clear (reset) bit 4 of B case 0xA0: { break; } // RES 4,C: Clear (reset) bit 4 of C case 0xA1: { break; } // RES 4,D: Clear (reset) bit 4 of D case 0xA2: { break; } // RES 4,E: Clear (reset) bit 4 of E case 0xA3: { break; } // RES 4,H: Clear (reset) bit 4 of H case 0xA4: { break; } // RES 4,L: Clear (reset) bit 4 of L case 0xA5: { break; } // RES 4,(HL): Clear (reset) bit 4 of value pointed by HL // NOTE: two-stage opcode case 0xA6: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.ClearBit(cpu.Registers.TEMP, 4)); break; } // RES 4,A: Clear (reset) bit 4 of A case 0xA7: { break; } // RES 5,B: Clear (reset) bit 5 of B case 0xA8: { break; } // RES 5,C: Clear (reset) bit 5 of C case 0xA9: { break; } // RES 5,D: Clear (reset) bit 5 of D case 0xAA: { break; } // RES 5,E: Clear (reset) bit 5 of E case 0xAB: { break; } // RES 5,H: Clear (reset) bit 5 of H case 0xAC: { break; } // RES 5,L: Clear (reset) bit 5 of L case 0xAD: { break; } // RES 5,(HL): Clear (reset) bit 5 of value pointed by HL // NOTE: two-stage opcode case 0xAE: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.ClearBit(cpu.Registers.TEMP, 5)); break; } // RES 5,A: Clear (reset) bit 5 of A case 0xAF: { break; } // RES 6,B: Clear (reset) bit 6 of B case 0xB0: { break; } // RES 6,C: Clear (reset) bit 6 of C case 0xB1: { break; } // RES 6,D: Clear (reset) bit 6 of D case 0xB2: { break; } // RES 6,E: Clear (reset) bit 6 of E case 0xB3: { break; } // RES 6,H: Clear (reset) bit 6 of H case 0xB4: { break; } // RES 6,L: Clear (reset) bit 6 of L case 0xB5: { break; } // RES 6,(HL): Clear (reset) bit 6 of value pointed by HL // NOTE: two-stage opcode case 0xB6: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.ClearBit(cpu.Registers.TEMP, 6)); break; } // RES 6,A: Clear (reset) bit 6 of A case 0xB7: { break; } // RES 7,B: Clear (reset) bit 7 of B case 0xB8: { break; } // RES 7,C: Clear (reset) bit 7 of C case 0xB9: { break; } // RES 7,D: Clear (reset) bit 7 of D case 0xBA: { break; } // RES 7,E: Clear (reset) bit 7 of E case 0xBB: { break; } // RES 7,H: Clear (reset) bit 7 of H case 0xBC: { break; } // RES 7,L: Clear (reset) bit 7 of L case 0xBD: { break; } // RES 7,(HL): Clear (reset) bit 7 of value pointed by HL // NOTE: two-stage opcode case 0xBE: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.ClearBit(cpu.Registers.TEMP, 7)); break; } // RES 7,A: Clear (reset) bit 7 of A case 0xBF: { break; } // SET 0,B: Set bit 0 of B case 0xC0: { break; } // SET 0,C: Set bit 0 of C case 0xC1: { break; } // SET 0,D: Set bit 0 of D case 0xC2: { break; } // SET 0,E: Set bit 0 of E case 0xC3: { break; } // SET 0,H: Set bit 0 of H case 0xC4: { break; } // SET 0,L: Set bit 0 of L case 0xC5: { break; } // SET 0,(HL): Set bit 0 of value pointed by HL // NOTE: two-stage opcode case 0xC6: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.SetBit(cpu.Registers.TEMP, 0)); break; } // SET 0,A: Set bit 0 of A case 0xC7: { break; } // SET 1,B: Set bit 1 of B case 0xC8: { break; } // SET 1,C: Set bit 1 of C case 0xC9: { break; } // SET 1,D: Set bit 1 of D case 0xCA: { break; } // SET 1,E: Set bit 1 of E case 0xCB: { break; } // SET 1,H: Set bit 1 of H case 0xCC: { break; } // SET 1,L: Set bit 1 of L case 0xCD: { break; } // SET 1,(HL): Set bit 1 of value pointed by HL // NOTE: two-stage opcode case 0xCE: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.SetBit(cpu.Registers.TEMP, 1)); break; } // SET 1,A: Set bit 1 of A case 0xCF: { break; } // SET 2,B: Set bit 2 of B case 0xD0: { break; } // SET 2,C: Set bit 2 of C case 0xD1: { break; } // SET 2,D: Set bit 2 of D case 0xD2: { break; } // SET 2,E: Set bit 2 of E case 0xD3: { break; } // SET 2,H: Set bit 2 of H case 0xD4: { break; } // SET 2,L: Set bit 2 of L case 0xD5: { break; } // SET 2,(HL): Set bit 2 of value pointed by HL // NOTE: two-stage opcode case 0xD6: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.SetBit(cpu.Registers.TEMP, 2)); break; } // SET 2,A: Set bit 2 of A case 0xD7: { break; } // SET 3,B: Set bit 3 of B case 0xD8: { break; } // SET 3,C: Set bit 3 of C case 0xD9: { break; } // SET 3,D: Set bit 3 of D case 0xDA: { break; } // SET 3,E: Set bit 3 of E case 0xDB: { break; } // SET 3,H: Set bit 3 of H case 0xDC: { break; } // SET 3,L: Set bit 3 of L case 0xDD: { break; } // SET 3,(HL): Set bit 3 of value pointed by HL // NOTE: two-stage opcode case 0xDE: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.SetBit(cpu.Registers.TEMP, 3)); break; } // SET 3,A: Set bit 3 of A case 0xDF: { break; } // SET 4,B: Set bit 4 of B case 0xE0: { break; } // SET 4,C: Set bit 4 of C case 0xE1: { break; } // SET 4,D: Set bit 4 of D case 0xE2: { break; } // SET 4,E: Set bit 4 of E case 0xE3: { break; } // SET 4,H: Set bit 4 of H case 0xE4: { break; } // SET 4,L: Set bit 4 of L case 0xE5: { break; } // SET 4,(HL): Set bit 4 of value pointed by HL // NOTE: two-stage opcode case 0xE6: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.SetBit(cpu.Registers.TEMP, 4)); break; } // SET 4,A: Set bit 4 of A case 0xE7: { break; } // SET 5,B: Set bit 5 of B case 0xE8: { break; } // SET 5,C: Set bit 5 of C case 0xE9: { break; } // SET 5,D: Set bit 5 of D case 0xEA: { break; } // SET 5,E: Set bit 5 of E case 0xEB: { break; } // SET 5,H: Set bit 5 of H case 0xEC: { break; } // SET 5,L: Set bit 5 of L case 0xED: { break; } // SET 5,(HL): Set bit 5 of value pointed by HL // NOTE: two-stage opcode case 0xEE: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.SetBit(cpu.Registers.TEMP, 5)); break; } // SET 5,A: Set bit 5 of A case 0xEF: { break; } // SET 6,B: Set bit 6 of B case 0xF0: { break; } // SET 6,C: Set bit 6 of C case 0xF1: { break; } // SET 6,D: Set bit 6 of D case 0xF2: { break; } // SET 6,E: Set bit 6 of E case 0xF3: { break; } // SET 6,H: Set bit 6 of H case 0xF4: { break; } // SET 6,L: Set bit 6 of L case 0xF5: { break; } // SET 6,(HL): Set bit 6 of value pointed by HL // NOTE: two-stage opcode case 0xF6: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.SetBit(cpu.Registers.TEMP, 6)); break; } // SET 6,A: Set bit 6 of A case 0xF7: { break; } // SET 7,B: Set bit 7 of B case 0xF8: { break; } // SET 7,C: Set bit 7 of C case 0xF9: { break; } // SET 7,D: Set bit 7 of D case 0xFA: { break; } // SET 7,E: Set bit 7 of E case 0xFB: { break; } // SET 7,H: Set bit 7 of H case 0xFC: { break; } // SET 7,L: Set bit 7 of L case 0xFD: { break; } // SET 7,(HL): Set bit 7 of value pointed by HL // NOTE: two-stage opcode case 0xFE: { cpu._memory.Write(cpu.Registers.HL, UtilFuncs.SetBit(cpu.Registers.TEMP, 7)); break; } // SET 7,A: Set bit 7 of A case 0xFF: { break; } } }