/// <summary> /// Initializes and divides tree /// </summary> /// <param name="depthDivision">Depth of division</param> /// <param name="transformParent">Parent for tree trunk GameObject</param> public void InitializeTree(int depthDivision, Transform transformParent = null) { trunk = new OctreeNode(); trunk.gameObject = new GameObject(); trunk.gameObject.transform.parent = transformParent; trunk.AABB = new Bounds(Vector3.zero, new Vector3(4, 4, 4)); DivideTree(2); InitializeDeepestNodesValue(); }
public void Build(MeshDesc desc, OctreeNode root) { desc.Clear(); meshDesc = desc; if (root != null) { GenerateVertices(root); ContourCellProc(root); } }
/// <summary> /// Recursively divides tree /// </summary> /// <param name="n">Current node</param> /// <param name="depth">Depth of division</param> /// <param name="_deepestNodes">List to add deepest nodes to</param> private void DivideTreeNode(OctreeNode n, int depth, List<OctreeNode> _deepestNodes) { var parentBB = n.AABB; OctreeNode t; Vector3 e = parentBB.extents /= 2; n.children.Add(t = new OctreeNode()); t.AABB = parentBB; t.AABB.center += new Vector3(e.x, e.y, e.z); n.children.Add(t = new OctreeNode()); t.AABB = parentBB; t.AABB.center += new Vector3(-e.x, e.y, e.z); n.children.Add(t = new OctreeNode()); t.AABB = parentBB; t.AABB.center += new Vector3(e.x, -e.y, e.z); n.children.Add(t = new OctreeNode()); t.AABB = parentBB; t.AABB.center += new Vector3(-e.x, -e.y, e.z); n.children.Add(t = new OctreeNode()); t.AABB = parentBB; t.AABB.center += new Vector3(e.x, e.y, -e.z); n.children.Add(t = new OctreeNode()); t.AABB = parentBB; t.AABB.center += new Vector3(-e.x, e.y, -e.z); n.children.Add(t = new OctreeNode()); t.AABB = parentBB; t.AABB.center += new Vector3(e.x, -e.y, -e.z); n.children.Add(t = new OctreeNode()); t.AABB = parentBB; t.AABB.center += new Vector3(-e.x, -e.y, -e.z); for (int i = 0; i < n.children.Count; i++) { t = n.children[i]; t.parent = n; t.gameObject = new GameObject(); t.gameObject.transform.position = t.AABB.center; t.gameObject.transform.localScale = t.AABB.size; t.gameObject.transform.parent = n.gameObject.transform; } if (depth-- > 0) for (int i = 0; i < n.children.Count; i++) DivideTreeNode(n.children[i], depth, _deepestNodes); else _deepestNodes.AddRange(n.children); }
void DrawNode(OctreeNode node) { switch (mode) { case Mode.Hierarchy: DrawNode_HierarchyMode(node); break; case Mode.Edges: DrawNode_EdgesMode(node); break; } }
void DrawNode_EdgesMode(OctreeNode node) { const float dotSize = 0.01f; if (node.type == OctreeNode.Type.Leaf) { Vector3 nodeSize = new Vector3(size, size, size) * node.size; Vector3 center = node.min + nodeSize * 0.5f; Gizmos.DrawWireCube(center, nodeSize); Gizmos.DrawCube(node.info.position, new Vector3(dotSize, dotSize, dotSize)); } }
public Octree(BoundingBox bounds, int maxDepth, int maxObjectsPerNode, int minObjectsPerNode) { Bounds = bounds; MaxDepth = maxDepth; MaxObjectsPerNode = maxObjectsPerNode; MinObjectsPerNode = minObjectsPerNode; Root = new OctreeNode(Bounds, this, 0, null); DebugDraw = false; Lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion); ObjectsToNodes = new Dictionary<IBoundedObject, OctreeNode>(); ObjectsToUpdate = new Dictionary<IBoundedObject, bool>(); UpdateTimer = new Timer(1.0f, false); }
void DrawNode_HierarchyMode(OctreeNode node) { Vector3 nodeSize = new Vector3(size, size, size) * node.size; Vector3 center = node.min + nodeSize * 0.5f; switch (node.type) { case OctreeNode.Type.Leaf: Gizmos.DrawCube(center, nodeSize); break; case OctreeNode.Type.Internal: Gizmos.DrawWireCube(center, nodeSize); break; } }
public static void Build(OctreeNode node, int minSize) { if (node == null) return; if (node.size < minSize) return; int childSize = node.size / 2; for (int i = 0; i < 8; ++i) { OctreeNode child = new OctreeNode(); child.type = OctreeNode.Type.Internal; child.size = childSize; child.min = node.min + (CHILD_MIN_OFFSETS[i] * childSize); Build(child, minSize); node.children[i] = child; } }
void ContourCellProc(OctreeNode node) { if (node.type == OctreeNode.Type.Internal) { for (int i = 0; i < node.children.Length; ++i) { OctreeNode child = node.children[i]; if (child != null) ContourCellProc(child); } for (int i = 0; i < 12; ++i) { OctreeNode[] faceNodes = new OctreeNode[2]; int[] c = new int[2]{ cellProcFaceMask[i, 0], cellProcFaceMask[i, 1] }; faceNodes[0] = node.children[c[0]]; faceNodes[1] = node.children[c[1]]; ContourFaceProc(faceNodes, cellProcFaceMask[i, 2]); } for (int i = 0; i < 6; ++i) { OctreeNode[] edgeNodes = new OctreeNode[4]; int[] c = new int[4] { cellProcEdgeMask[i, 0], cellProcEdgeMask[i, 1], cellProcEdgeMask[i, 2], cellProcEdgeMask[i, 3], }; for (int j = 0; j < 4; ++j) { edgeNodes[j] = node.children[c[j]]; } ContourEdgeProc(edgeNodes, cellProcEdgeMask[i, 4]); } } }
public Window() : base(1280, 720, new GraphicsMode(32, 0, 0, 4), "OpenCAD") { stl = new STL("Models/elephant.stl", Color.Green, STLType.Binary); var s1 = new Sphere {Center = Vect3.Zero, Radius = 4}; var s2 = new Sphere {Center = new Vect3(0,5,0), Radius = 4}; var t1 = new Octree<Voxel>(Vect3.Zero, 32.0); var t2 = new Octree<Voxel>(Vect3.Zero, 32.0); Test2(t1, node => s1.Intersects(node.AABB)); Test(t2, stl.Elements); _tree = t1.Union(t2); //_tree.Test(node => sphere.Intersects(node.AABB),maxLevel); //Test2(t, node => sphere.Intersects(node.AABB)); //t[0].Clear(); //t[0].Clear(); //Test(_tree,stl.Elements); //create from stl //foreach (var tri in stl.Elements) //{ // Intersect(_tree, tri); //} VSync = VSyncMode.On; _camera = new Camera(); Mouse.WheelChanged += (sender, args) => { _camera.View = _camera.View * Mat4.Translate(0, 0, args.DeltaPrecise * -10.0); //_camera.Eye += new Vect3(0, 0, args.DeltaPrecise * -10.0); // Console.WriteLine(_camera.Eye); }; }
public static OctreeChildCoords FromIndex(OctreeNode.ChildIndex index) { switch (index) { case OctreeNode.ChildIndex.LeftBelowBack: return new OctreeChildCoords(0, 0, 0); case OctreeNode.ChildIndex.LeftBelowForward: return new OctreeChildCoords(0, 0, 1); case OctreeNode.ChildIndex.LeftAboveBack: return new OctreeChildCoords(0, 1, 0); case OctreeNode.ChildIndex.LeftAboveForward: return new OctreeChildCoords(0, 1, 1); case OctreeNode.ChildIndex.RightBelowBack: return new OctreeChildCoords(1, 0, 0); case OctreeNode.ChildIndex.RightBelowForward: return new OctreeChildCoords(1, 0, 1); case OctreeNode.ChildIndex.RightAboveBack: return new OctreeChildCoords(1, 1, 0); case OctreeNode.ChildIndex.RightAboveForward: return new OctreeChildCoords(1, 1, 1); default: throw new ArgumentOutOfRangeException("index", index, null); } }
/// <summary> /// Reduce the depth of the tree /// </summary> public void reduce() { int index; for (index = _maxColorBits - 1; (index > 0) && (null == _reducibleNodes[index]); ++index) ; OctreeNode node = _reducibleNodes[index]; _reducibleNodes[index] = node.nextReducible; _leafCount -= node.reduce(); _previousNode = null; }
/// <summary> /// Keep track of the previous node that was quantized /// </summary> /// <param name="node">The node last quantized</param> protected void TrackPrevious(OctreeNode node) { _previousNode = node; }
protected void TrackPrevious(OctreeNode node) => this.previousNode = node;
/// /// <summary> /// Add items to the Octree /// </summary> /// /// <param name="itemPositions"> /// The positions (centroid) of the items being added /// </param> /// /// <param name="itemBoundingBoxes"> /// The bounding boxes for each item being added /// </param> /// /// <param name="searchRoot"> /// The node to attempt to add the items within /// </param> /// private void AddItems(Vector3[] itemPositions, BoundingBox[] itemBoundingBoxes, OctreeNode searchRoot) { if (itemPositions.Length != itemBoundingBoxes.Length) { throw new ArgumentException("there must be as many item positions as there are item bounding boxes"); } for (int i = 0; i < itemPositions.Length; ++i) { List <OctreeNode> nodes = FindContainingNodes(searchRoot, itemBoundingBoxes[i]); foreach (OctreeNode node in nodes) { if (node.InternalObjectPositions.Count + 1 >= _maximumObjectsInNode) { BreakDownNode(node); List <OctreeNode> newNodes = FindContainingNodes(node, itemBoundingBoxes[i]); foreach (OctreeNode newNode in newNodes) { // These nodes will be brand new, so we can always add 1 item to them without checks newNode.AddObject(itemPositions[i], itemBoundingBoxes[i]); } } else { node.AddObject(itemPositions[i], itemBoundingBoxes[i]); } } } }
private List <OctreeNode> ComputeVoxels(ComputeShader shader, Vector3 min, int octreeSize) { float gpuStart = Time.realtimeSinceStartup; float[] chunkPos = new float[3] { min.x, min.y, min.z }; shader.SetFloats("chunkPosition", chunkPos); shader.SetInt("resolution", octreeSize); shader.SetInt("octreeSize", octreeSize); float sqRTRC = Mathf.Sqrt(octreeSize * octreeSize * octreeSize); int sqRTRes = (int)sqRTRC; if (sqRTRC > sqRTRes) { sqRTRes++; } ComputeBuffer Perm = new ComputeBuffer(512, sizeof(int)); Perm.SetData(permutations); ComputeBuffer cornCount = new ComputeBuffer(sqRTRes, sizeof(int)); ComputeBuffer finalCount = new ComputeBuffer(1, sizeof(float)); ComputeBuffer voxMatBuffer = new ComputeBuffer(octreeSize * octreeSize * octreeSize, sizeof(uint)); float rD8 = octreeSize / 8.0f; int rD8I = (int)rD8; if (rD8 > rD8I) { rD8I++; } int kernel = shader.FindKernel("ComputeCorners"); shader.SetBuffer(kernel, "Perm", Perm); shader.SetBuffer(kernel, "voxelMaterials", voxMatBuffer); shader.Dispatch(kernel, rD8I, rD8I, rD8I); /*kernel = shader.FindKernel("ComputeLength"); * shader.SetBuffer(kernel, "voxelMaterials", voxMatBuffer); * shader.SetBuffer(kernel, "cornerCount", cornCount); * shader.Dispatch(kernel, 1, 1, 1);*/ kernel = shader.FindKernel("AddLength"); shader.SetBuffer(kernel, "cornerCount", cornCount); shader.SetBuffer(kernel, "finalCount", finalCount); shader.Dispatch(kernel, 1, 1, 1); float[] voxelCount = new float[1]; finalCount.GetData(voxelCount); finalCount.SetData(voxelCount); int count = (int)voxelCount[0]; //Debug.Log (count); if (count <= 0) { voxMatBuffer.Dispose(); cornCount.Dispose(); finalCount.Dispose(); Perm.Dispose(); return(null); } ComputeBuffer cornerIndexes = new ComputeBuffer(count, sizeof(uint)); kernel = shader.FindKernel("ComputePositions"); shader.SetBuffer(kernel, "voxelMaterials", voxMatBuffer); shader.SetBuffer(kernel, "cornerCount", cornCount); shader.SetBuffer(kernel, "cornerIndexes", cornerIndexes); shader.Dispatch(kernel, 1, 1, 1); ComputeBuffer voxBuffer = new ComputeBuffer(count, (sizeof(float) * 6) + sizeof(int)); ComputeBuffer positionBuffer = new ComputeBuffer(count, sizeof(float) * 3); kernel = shader.FindKernel("ComputeVoxels"); shader.SetBuffer(kernel, "Perm", Perm); shader.SetBuffer(kernel, "voxMins", positionBuffer); shader.SetBuffer(kernel, "voxelMaterials", voxMatBuffer); shader.SetBuffer(kernel, "finalCount", finalCount); shader.SetBuffer(kernel, "cornerIndexes", cornerIndexes); shader.SetBuffer(kernel, "voxels", voxBuffer); //int dispatchCount = count / 10; shader.Dispatch(kernel, (count / 128) + 1, 1, 1); List <OctreeNode> computedVoxels = new List <OctreeNode>(); Vector3[] voxelMins = new Vector3[count]; positionBuffer.GetData(voxelMins); positionBuffer.Dispose(); uint[] voxelMaterials = new uint[count]; cornerIndexes.GetData(voxelMaterials); cornerIndexes.Dispose(); GPUVOX[] voxs = new GPUVOX[count]; voxBuffer.GetData(voxs); voxBuffer.Dispose(); voxMatBuffer.Dispose(); cornCount.Dispose(); finalCount.Dispose(); Perm.Dispose(); float gpuEnd = Time.realtimeSinceStartup; //Debug.Log ("GPU time on chunk: " + (gpuEnd - gpuStart)); int HIGHEST_VOXEL_RES = 64; int voxelSize = HIGHEST_VOXEL_RES / octreeSize; for (int i = 0; i < count; i++) { if (voxs[i].numPoints != 0) { OctreeNode leaf = new OctreeNode(); leaf.type = OctreeNodeType.Node_Leaf; leaf.size = voxelSize; OctreeDrawInfo drawInfo = new OctreeDrawInfo(); drawInfo.position = voxs[i].vertPoint; drawInfo.averageNormal = voxs[i].avgNormal; drawInfo.corners = (int)voxelMaterials[i]; leaf.drawInfo = drawInfo; leaf.min = voxelMins[i]; computedVoxels.Add(leaf); } } //Debug.Log ("CPU Leaf generation time on chunk: " + (Time.realtimeSinceStartup - gpuEnd)); //Debug.Log (computedVoxels.Count); return(computedVoxels); }
public virtual void Awake() { rootNode = new OctreeNode(new Vector3Int(-2, -2, -2), 8); }
//costruisce il nodo terminale (foglia) calcolando le NodeInfo per la generazione della mesh public OctreeNode BuildLeaf(OctreeNode leaf, int size) { if (leaf == null || leaf.size != size) { return(null); } int corners = 0; for (int i = 0; i < 8; i++) { Vector3 cornerPos = leaf.min + (CHILD_MIN_OFFSETS[i] * size); float density = Density.DensityFunc(cornerPos); int material = density < 0.0f ? SOLID : AIR; corners |= (material << i); } if (corners == 0 || corners == 255) { leaf = null; return(null); } int edgeCount = 0; Vector3 averageNormal = new Vector3(); QefSolver qef = new QefSolver(); for (int i = 0; i < 12 && edgeCount < MAX_CROSSINGS; i++) { int c1 = edgevmap[i][0]; int c2 = edgevmap[i][1]; int m1 = (corners >> c1) & 1; int m2 = (corners >> c2) & 1; if ((m1 == AIR && m2 == AIR) || (m1 == SOLID && m2 == SOLID)) { continue; } Vector3 p1 = leaf.min + (CHILD_MIN_OFFSETS[c1] * size); Vector3 p2 = leaf.min + (CHILD_MIN_OFFSETS[c2] * size); Vector3 p = ApproximateZeroCrossingPosition(p1, p2, 8); Vector3 n = CalculateSurfaceNormal(p); qef.Add(p.x, p.y, p.z, n.x, n.y, n.z); averageNormal += n; edgeCount++; } Vector3 qefPosition = new Vector3(); qef.Solve(qefPosition, QEF_ERROR, QEF_SWEEPS, QEF_ERROR); NodeInfo info = new NodeInfo(); info.index = -1; info.corners = 0; info.position = qefPosition; info.qef = qef.GetData(); Vector3 min = leaf.min; Vector3 max = new Vector3(leaf.min.x + leaf.size, leaf.min.y + leaf.size, leaf.min.z + leaf.size); if (info.position.x < min.x || info.position.x > max.x || info.position.y < min.y || info.position.y > max.y || info.position.z < min.z || info.position.z > max.z) { info.position = qef.GetMassPoint(); } info.avgNormal = (averageNormal / (float)edgeCount).normalized; info.corners = corners; leaf.type = NodeType.LEAF; leaf.nodeInfo = info; return(leaf); }
/// <summary> /// Return a color palette for the computed octree. /// </summary> /// <returns>A color palette for the computed octree</returns> internal Color[] GetPaletteColors() { // If we haven't already computed it, compute it now if (this.octreePalette == null) { // Start at the second-to-last reducible level int reductionLevel = this.octreeReducibleNodes.Length - 1; // We want to subtract one from the target if we have a transparent // bit because we want to save room for that special color int targetCount = this.octreeMaxColors - (this.octreeHasTransparent ? 1 : 0); // While we still have more colors than the target... while (this.octreeColorCount > targetCount) { // Find the first reducible node, starting with the last level // that can have reducible nodes while (reductionLevel > 0 && this.octreeReducibleNodes[reductionLevel] == null) { --reductionLevel; } if (this.octreeReducibleNodes[reductionLevel] == null) { // Shouldn't get here break; } // We should have a node now OctreeNode newLeaf = this.octreeReducibleNodes[reductionLevel]; this.octreeReducibleNodes[reductionLevel] = newLeaf.NextReducibleNode; this.octreeColorCount -= newLeaf.Reduce() - 1; } if (reductionLevel == 0 && !this.octreeHasTransparent) { // If this was the top-most level, we now only have a single color // representing the average. That's not what we want. // use just black and white this.octreePalette = new Color[2]; this.octreePalette[0] = Color.Black; this.octreePalette[1] = Color.White; // And empty the octree so it always picks the closer of the black and white entries this.octreeRoot = new OctreeNode(0, this); } else { // Now walk the tree, adding all the remaining colors to the list int paletteIndex = 0; this.octreePalette = new Color[this.octreeColorCount + (this.octreeHasTransparent ? 1 : 0)]; // Add the transparent color if we need it if (this.octreeHasTransparent) { this.octreePalette[paletteIndex++] = Color.Transparent; } // Have the nodes insert their leaf colors this.octreeRoot.AddColorsToPalette(this.octreePalette, ref paletteIndex); } } return(this.octreePalette); }
/// \cond protected override bool SynchronizeOctree(uint availableSyncOperations) { VolumeRenderer volumeRenderer = gameObject.GetComponent <VolumeRenderer>(); VolumeCollider volumeCollider = gameObject.GetComponent <VolumeCollider>(); Vector3 camPos = CameraUtils.getCurrentCameraPosition(); // This is messy - perhaps the LOD thresold shold not be a parameter to update. Instead it could be passed // as a parameter during traversal, so different traversal could retrieve differnt LODs. We then wouldn't // want a single 'renderThisNode' member of Cubiquity nodes, but instead some threshold we could compare to. float lodThreshold = GetComponent <VolumeRenderer>() ? GetComponent <VolumeRenderer>().lodThreshold : 1.0f; int minimumLOD = GetComponent <VolumeRenderer>() ? GetComponent <VolumeRenderer>().minimumLOD : 0; // Although the LOD system is partially functional I don't feel it's ready for release yet. // The following line disables it by forcing the highest level of detail to always be used. minimumLOD = 0; // Next line commented out so the system starts up with LOD disabled. //if (volumeRenderer.hasChanged) { CubiquityDLL.SetLodRange(data.volumeHandle.Value, minimumLOD, 0); } bool cubiquityUpToDate = CubiquityDLL.UpdateVolume(data.volumeHandle.Value, camPos.x, camPos.y, camPos.z, lodThreshold); if (CubiquityDLL.HasRootOctreeNode(data.volumeHandle.Value) == 1) { uint rootNodeHandle = CubiquityDLL.GetRootOctreeNode(data.volumeHandle.Value); if (rootOctreeNodeGameObject == null) { rootOctreeNodeGameObject = OctreeNode.CreateOctreeNode(rootNodeHandle, gameObject); } OctreeNode.syncNode(ref availableSyncOperations, rootOctreeNodeGameObject, rootNodeHandle, gameObject); if (volumeRenderer != null && volumeRenderer.hasChanged) { OctreeNode.syncNodeWithVolumeRenderer(rootOctreeNodeGameObject, volumeRenderer, true); } if (volumeCollider != null && volumeCollider.hasChanged) { OctreeNode.syncNodeWithVolumeCollider(rootOctreeNodeGameObject, volumeCollider, true); } } // These properties might have to be synced with the volume (e.g. LOD settings) or with components // (e.g. shadow/material settings). Therefore we don't clear the flags until all syncing is completed. if (volumeRenderer != null) { volumeRenderer.hasChanged = false; } if (volumeCollider != null) { volumeCollider.hasChanged = false; } // If there were still sync operations available then there was no more syncing to be done with the // Cubiquity octree. So if the Cubiquity octree was also up to date then we have synced everything. return(cubiquityUpToDate && availableSyncOperations > 0); }
public static void syncNode(ref uint availableSyncOperations, GameObject nodeGameObject, uint nodeHandle, GameObject voxelTerrainGameObject) { OctreeNode octreeNode = nodeGameObject.GetComponent <OctreeNode>(); CuOctreeNode cuOctreeNode = CubiquityDLL.GetOctreeNode(nodeHandle); //////////////////////////////////////////////////////////////////////////////// // Has anything in this node or its children changed? If so, we may need to syncronise the node's properties, mesh and // structure. Each of these can be tested against a timestamp. We may also need to do this recursively on child nodes. //////////////////////////////////////////////////////////////////////////////// if (cuOctreeNode.nodeOrChildrenLastChanged > octreeNode.nodeAndChildrenLastSynced) { bool resyncedProperties = false; // See comments where this is tested - it's a bit of a hack //////////////////////////////////////////////////////////////////////////////// // 1st test - Have the properties of the node changed? //////////////////////////////////////////////////////////////////////////////// if (cuOctreeNode.propertiesLastChanged > octreeNode.propertiesLastSynced) { octreeNode.renderThisNode = cuOctreeNode.renderThisNode != 0; octreeNode.height = cuOctreeNode.height; octreeNode.propertiesLastSynced = CubiquityDLL.GetCurrentTime(); resyncedProperties = true; } //////////////////////////////////////////////////////////////////////////////// // 2nd test - Has the mesh changed and do we have time to syncronise it? //////////////////////////////////////////////////////////////////////////////// if ((cuOctreeNode.meshLastChanged > octreeNode.meshLastSynced) && (availableSyncOperations > 0)) { if (cuOctreeNode.hasMesh == 1) { // Set up the rendering mesh VolumeRenderer volumeRenderer = voxelTerrainGameObject.GetComponent <VolumeRenderer>(); if (volumeRenderer != null) { MeshFilter meshFilter = nodeGameObject.GetOrAddComponent <MeshFilter>() as MeshFilter; if (meshFilter.sharedMesh == null) { meshFilter.sharedMesh = new Mesh(); } MeshRenderer meshRenderer = nodeGameObject.GetOrAddComponent <MeshRenderer>() as MeshRenderer; if (voxelTerrainGameObject.GetComponent <Volume>().GetType() == typeof(TerrainVolume)) { MeshConversion.BuildMeshFromNodeHandleForTerrainVolume(meshFilter.sharedMesh, nodeHandle, false); } else if (voxelTerrainGameObject.GetComponent <Volume>().GetType() == typeof(ColoredCubesVolume)) { MeshConversion.BuildMeshFromNodeHandleForColoredCubesVolume(meshFilter.sharedMesh, nodeHandle, false); } meshRenderer.enabled = volumeRenderer.enabled && octreeNode.renderThisNode; // For syncing materials, shadow properties, etc. syncNodeWithVolumeRenderer(nodeGameObject, volumeRenderer, false); } // Set up the collision mesh VolumeCollider volumeCollider = voxelTerrainGameObject.GetComponent <VolumeCollider>(); if (volumeCollider != null) { bool useCollider = volumeCollider.useInEditMode || Application.isPlaying; if (useCollider) { // I'm not quite comfortable with this. For some reason we have to create this new mesh, fill it, // and set it as the collider's shared mesh, whereas I would rather just pass the collider's sharedMesh // straight to the functon that fills it. For some reason that doesn't work properly, and we see // issues with objects falling through terrain or not updating when part of the terrain is deleted. // It's to be investigated further... perhaps we could try deleting and recreating the MeshCollider? // Still, the approach below seems to work properly. Mesh collisionMesh = new Mesh(); if (voxelTerrainGameObject.GetComponent <Volume>().GetType() == typeof(TerrainVolume)) { MeshConversion.BuildMeshFromNodeHandleForTerrainVolume(collisionMesh, nodeHandle, true); } else if (voxelTerrainGameObject.GetComponent <Volume>().GetType() == typeof(ColoredCubesVolume)) { MeshConversion.BuildMeshFromNodeHandleForColoredCubesVolume(collisionMesh, nodeHandle, true); } MeshCollider meshCollider = nodeGameObject.GetOrAddComponent <MeshCollider>() as MeshCollider; meshCollider.sharedMesh = collisionMesh; } } } // If there is no mesh in Cubiquity then we make sure there isn't one in Unity. else { MeshCollider meshCollider = nodeGameObject.GetComponent <MeshCollider>() as MeshCollider; if (meshCollider) { Utility.DestroyOrDestroyImmediate(meshCollider); } MeshRenderer meshRenderer = nodeGameObject.GetComponent <MeshRenderer>() as MeshRenderer; if (meshRenderer) { Utility.DestroyOrDestroyImmediate(meshRenderer); } MeshFilter meshFilter = nodeGameObject.GetComponent <MeshFilter>() as MeshFilter; if (meshFilter) { Utility.DestroyOrDestroyImmediate(meshFilter); } } octreeNode.meshLastSynced = CubiquityDLL.GetCurrentTime(); availableSyncOperations--; } // We want to syncronize the properties before the mesh, so that the enabled flag can be set correctly when the mesh // is created. But we also want to syncronize properties after the mesh, so we can apply the correct enabled flag to // existing meshes when the node's 'renderThisNode' flag has changed. Therefore we set the 'resyncedProperties' flag // previously to let ourseves know that we should come back an finish the propertiy syncing here. It's a bit of a hack. if (resyncedProperties) { VolumeRenderer volumeRenderer = voxelTerrainGameObject.GetComponent <VolumeRenderer>(); if (volumeRenderer != null) { syncNodeWithVolumeRenderer(nodeGameObject, volumeRenderer, false); } VolumeCollider volumeCollider = voxelTerrainGameObject.GetComponent <VolumeCollider>(); if (volumeCollider != null) { syncNodeWithVolumeCollider(nodeGameObject, volumeCollider, false); } } uint[,,] childHandleArray = new uint[2, 2, 2]; childHandleArray[0, 0, 0] = cuOctreeNode.childHandle000; childHandleArray[0, 0, 1] = cuOctreeNode.childHandle001; childHandleArray[0, 1, 0] = cuOctreeNode.childHandle010; childHandleArray[0, 1, 1] = cuOctreeNode.childHandle011; childHandleArray[1, 0, 0] = cuOctreeNode.childHandle100; childHandleArray[1, 0, 1] = cuOctreeNode.childHandle101; childHandleArray[1, 1, 0] = cuOctreeNode.childHandle110; childHandleArray[1, 1, 1] = cuOctreeNode.childHandle111; //////////////////////////////////////////////////////////////////////////////// // 3rd test - Has the structure of the octree node changed (gained or lost children)? //////////////////////////////////////////////////////////////////////////////// if (cuOctreeNode.structureLastChanged > octreeNode.structureLastSynced) { //Now syncronise any children for (uint z = 0; z < 2; z++) { for (uint y = 0; y < 2; y++) { for (uint x = 0; x < 2; x++) { if (childHandleArray[x, y, z] != 0xFFFFFFFF) { uint childNodeHandle = childHandleArray[x, y, z]; if (octreeNode.GetChild(x, y, z) == null) { octreeNode.SetChild(x, y, z, OctreeNode.CreateOctreeNode(childNodeHandle, nodeGameObject)); } } else { if (octreeNode.GetChild(x, y, z)) { Utility.DestroyOrDestroyImmediate(octreeNode.GetChild(x, y, z)); octreeNode.SetChild(x, y, z, null); } } } } } octreeNode.structureLastSynced = CubiquityDLL.GetCurrentTime(); } //////////////////////////////////////////////////////////////////////////////// // The last step of syncronization is to apply it recursively to our children. //////////////////////////////////////////////////////////////////////////////// for (uint z = 0; z < 2; z++) { for (uint y = 0; y < 2; y++) { for (uint x = 0; x < 2; x++) { if (octreeNode.GetChild(x, y, z) != null && availableSyncOperations > 0) { OctreeNode.syncNode(ref availableSyncOperations, octreeNode.GetChild(x, y, z), childHandleArray[x, y, z], voxelTerrainGameObject); } } } } // We've reached the end of our syncronization process. If there are still sync operations available then // we did less work then we could have, which implies we finished. Therefore mark the whole tree as synced. if (availableSyncOperations > 0) { octreeNode.nodeAndChildrenLastSynced = CubiquityDLL.GetCurrentTime(); } } }
void FinishUpChunkLoading() { if (finishedChunk) { finishedChunk = false; busy = false; if (changingChunk == null) { if (thread.m_Root != null && loadingChunk != null) { //if (loadingChunk.LOD == 6) //Debug.Log ("Chunk time on CPU: " + (Time.realtimeSinceStartup - cpuStartTime)); loadingChunk.CreateSeamChunk(thread.m_Root, thread.m_Root.min); if (loadingChunk.GenerateMesh(thread.m_Vertices, thread.m_Normals, thread.m_Indices) > 0) { loadingChunk.containsNothing = false; } List <Chunk> seamChunks = new List <Chunk>(); bool foundAllEight = FindSeamChunks(loadingChunk, seamChunks); if (foundAllEight) { List <OctreeNode> seams = FindSeamNodes(loadingChunk, seamChunks); OctreeNode seamRoot = loadingChunk.BuildSeamTree(seams, loadingChunk.min, octreeSize * 2); if (seamRoot != null) { Chunk seamChunk = new Chunk(); seamChunk.LOD = 6; seamChunk.CreateSeamChunk(seamRoot, seamRoot.min); seamChunk.GenerateMesh(); //Debug.Log (seamChunk.GenerateMesh()); seamChunk.DestroyOctree(); loadingChunk.seamChunk = seamChunk; } } //loadingChunk.DestroyOctree(); } if (loadingChunk != null && thread.m_Root == null) { loadingChunk.DestroyMesh(); } if (loadingChunk != null) { chunks.Add(loadingChunk.min, loadingChunk); } } else { if (thread.m_Root != null && changingChunk != null) { changingChunk.clearMesh(); changingChunk.DestroyOctree(); changingChunk.CreateSeamChunk(thread.m_Root, thread.m_Root.min); //float meshReloadStart = Time.realtimeSinceStartup; changingChunk.GenerateMesh(thread.m_Vertices, thread.m_Normals, thread.m_Indices); //Debug.Log (Time.realtimeSinceStartup - meshReloadStart); List <Chunk> seamChunks = new List <Chunk>(); bool foundAllEight = FindSeamChunks(changingChunk, seamChunks); if (foundAllEight) { List <OctreeNode> seams = FindSeamNodes(changingChunk, seamChunks); OctreeNode seamRoot = changingChunk.BuildSeamTree(seams, changingChunk.min, octreeSize * 2); if (seamRoot != null) { Chunk seamChunk = changingChunk.seamChunk; if (seamChunk == null) { seamChunk = new Chunk(); changingChunk.seamChunk = seamChunk; } if (seamChunk != null) { seamChunk.LOD = 6; seamChunk.CreateSeamChunk(seamRoot, seamRoot.min); seamChunk.GenerateMesh(); //Debug.Log (seamChunk.GenerateMesh()); seamChunk.DestroyOctree(); } } } //changingChunk.DestroyOctree(); changingChunk = null; } } thread.m_Vertices.Clear(); thread.m_Normals.Clear(); thread.m_Indices.Clear(); loadingChunk = null; thread.m_Root = null; } }
private OctreeNode <T> CreateNewNode(ref BoundingBox bounds) { OctreeNode <T> node = new OctreeNode <T>(ref bounds, MaxChildren, this, null); return(node); }
public void ContourFaceProc(OctreeNode[] node, int dir, MeshData data) { if (node[0] == null || node[1] == null) { return; } if (node[0].type == NodeType.INTERNAL || node[1].type == NodeType.INTERNAL) { for (int i = 0; i < 4; i++) { OctreeNode[] faceNodes = new OctreeNode[2]; int[] c = { faceProcFaceMask[dir][i][0], faceProcFaceMask[dir][i][1], }; for (int j = 0; j < 2; j++) { if (node[j].type != NodeType.INTERNAL) { faceNodes[j] = node[j]; } else { faceNodes[j] = node[j].children[c[j]]; } } ContourFaceProc(faceNodes, faceProcFaceMask[dir][i][2], data); } int[][] orders = { new int[] { 0, 0, 1, 1 }, new int[] { 0, 1, 0, 1 }, }; for (int i = 0; i < 4; i++) { OctreeNode[] edgeNodes = new OctreeNode[4]; int[] c = { faceProcEdgeMask[dir][i][1], faceProcEdgeMask[dir][i][2], faceProcEdgeMask[dir][i][3], faceProcEdgeMask[dir][i][4], }; int[] order = orders[faceProcEdgeMask[dir][i][0]]; for (int j = 0; j < 4; j++) { if (node[order[j]].type == NodeType.LEAF || node[order[j]].type == NodeType.PSEUDO) { edgeNodes[j] = node[order[j]]; } else { edgeNodes[j] = node[order[j]].children[c[j]]; } } ContourEdgeProc(edgeNodes, faceProcEdgeMask[dir][i][5], data); } } }
//semplifica l'octree public OctreeNode SimplifyOctree(OctreeNode node, float threshold) { if (node == null) { return(null); } if (node.type != NodeType.INTERNAL) { // can't simplify! return(node); } QefSolver qef = new QefSolver(); int[] signs = new int[8] { -1, -1, -1, -1, -1, -1, -1, -1, }; int midsign = -1; int edgeCount = 0; bool isCollapsible = true; for (int i = 0; i < 8; i++) { node.children[i] = SimplifyOctree(node.children[i], threshold); if (node.children[i] != null) { OctreeNode child = node.children[i]; if (child.type == NodeType.INTERNAL) { isCollapsible = false; } else { qef.Add(child.nodeInfo.qef); midsign = (child.nodeInfo.corners >> (7 - i)) & 1; signs[i] = (child.nodeInfo.corners >> i) & 1; edgeCount++; } } } if (!isCollapsible) { // at least one child is an internal node, can't collapse return(node); } Vector3 qefPosition = new Vector3(); float error = qef.Solve(qefPosition, QEF_ERROR, QEF_SWEEPS, QEF_ERROR); Vector3 position = new Vector3(qefPosition.x, qefPosition.y, qefPosition.z); // at this point the masspoint will actually be a sum, so divide to make it the average if (error > threshold) { // this collapse breaches the threshold return(node); } if (position.x < node.min.x || position.x > (node.min.x + node.size) || position.y < node.min.y || position.y > (node.min.y + node.size) || position.z < node.min.z || position.z > (node.min.z + node.size)) { position = qef.GetMassPoint(); } // change the node from an internal node to a 'pseudo leaf' node NodeInfo info = new NodeInfo(); for (int i = 0; i < 8; i++) { if (signs[i] == -1) { // Undetermined, use centre sign instead info.corners |= (midsign << i); } else { info.corners |= (signs[i] << i); } } info.avgNormal = new Vector3(0, 0, 0); for (int i = 0; i < 8; i++) { if (node.children[i] != null) { if (node.children[i].type == NodeType.PSEUDO || node.children[i].type == NodeType.LEAF) { info.avgNormal += node.children[i].nodeInfo.avgNormal; } } } info.avgNormal = info.avgNormal.normalized; info.position = position; info.qef = qef.GetData(); for (int i = 0; i < 8; i++) { DestroyOctree(node.children[i]); node.children[i] = null; } node.type = NodeType.PSEUDO; node.nodeInfo.Set(info); return(node); }
/// <summary> /// Add a color into the tree /// </summary> /// <param name="pixel">The color</param> /// <param name="colorBits">The number of significant color bits</param> /// <param name="level">The level in the tree</param> /// <param name="octree">The tree to which this node belongs</param> public void addColor(Color32* pixel, int colorBits, int level, Octree octree) { // Update the color information if this is a leaf if (_leaf) { inc(pixel); // Setup the previous node octree.trackPrevious(this); } else { // Go to the next level down in the tree int shift = 7 - level; int index = ((pixel->Red & mask[level]) >> (shift - 2)) | ((pixel->Green & mask[level]) >> (shift - 1)) | ((pixel->Blue & mask[level]) >> (shift)); OctreeNode child = _children[index]; if (child == null) { // Create a new child node & store in the array child = new OctreeNode(level + 1, colorBits, octree); _children[index] = child; } // Add the color to the child node child.addColor(pixel, colorBits, level + 1, octree); } }
/// <summary> /// Create an octree around the given root node. /// </summary> /// <param name="root"></param> private Octree(OctreeNode <StoredType> root) { depth = root.depth; this.root = root; }
private OctreeNode_GPU OctreeNode2OctreeNode_GPU(OctreeNode node) { return(new OctreeNode_GPU(node)); }
/// <summary>When a reducible node is added, this method is called to add it to the appropriate /// reducible node list (given its level)</summary> /// <param name="reducibleNode">node to add to a reducible list</param> private void AddReducibleNode(OctreeNode reducibleNode) { // hook this node into the front of the list. // this means the last one added will be the first in the list. reducibleNode.NextReducibleNode = this.octreeReducibleNodes[reducibleNode.Level]; this.octreeReducibleNodes[reducibleNode.Level] = reducibleNode; }
public OctreeNode(T obj, OctreeNode <T> parent) { mObject = obj; mParentNode = parent; mChilden = new OctreeNode <T> [(int)OctreeNodePos.max]; }
private void ContourFaceProc(OctreeNode[] node, int dir, List <int> indices) { if (node[0] == null || node[1] == null) { return; } if (node[0].type == OctreeNodeType.Node_Internal || node[1].type == OctreeNodeType.Node_Internal) { for (int i = 0; i < 4; i++) { OctreeNode[] faceNodes = new OctreeNode[2]; int[] c = new int[2] { faceProcFaceMask[dir, i, 0], faceProcFaceMask[dir, i, 1] }; for (int j = 0; j < 2; j++) { if (node[j].type != OctreeNodeType.Node_Internal) { faceNodes[j] = node[j]; } else { faceNodes[j] = node[j].children[c[j]]; } } ContourFaceProc(faceNodes, faceProcFaceMask[dir, i, 2], indices); } int[,] orders = new int[, ] { { 0, 0, 1, 1 }, { 0, 1, 0, 1 } }; for (int i = 0; i < 4; i++) { OctreeNode[] edgeNodes = new OctreeNode[4]; int[] c = new int[4] { faceProcEdgeMask[dir, i, 1], faceProcEdgeMask[dir, i, 2], faceProcEdgeMask[dir, i, 3], faceProcEdgeMask[dir, i, 4] }; int[] order = new int[4] { orders[faceProcEdgeMask[dir, i, 0], 0], orders[faceProcEdgeMask[dir, i, 0], 1], orders[faceProcEdgeMask[dir, i, 0], 2], orders[faceProcEdgeMask[dir, i, 0], 3] }; for (int j = 0; j < 4; j++) { if (node[order[j]].type == OctreeNodeType.Node_Leaf || node[order[j]].type == OctreeNodeType.Node_Psuedo) { edgeNodes[j] = node[order[j]]; } else { edgeNodes[j] = node[order[j]].children[c[j]]; } } ContourEdgeProc(edgeNodes, faceProcEdgeMask[dir, i, 5], indices); } } }
private int childHasObjects = 0; //Bitmask for child nodes public void Initialize(int index, LooseOctree <T> tree, OctreeNode parent) { Initialize(index, tree); this.parent = parent; treeDepth = parent.treeDepth + 1; }
/// /// <summary> /// Recursively traverse the octree looking for the closest object intersected by the rage /// </summary> /// /// <param name="node"> /// The node to traverse from /// </param> /// /// <param name="ray"> /// The ray to check for intersections against /// </param> /// /// <param name="intersectedPosition"> /// [output] the postion of the closest object intersected /// </param> /// /// <returns> /// The distance to the nearest object intersected by the input ray (null if there are no intersections) /// </returns> /// private float?RayIntersection(OctreeNode node, Ray ray, out Vector3 intersectedPosition) { intersectedPosition = new Vector3(); BoundingBox translatedBoundingBox = _masterBoundingBoxList[node.BoundingBoxIndex]; translatedBoundingBox.Max += node.BoundingBoxPosition; translatedBoundingBox.Min += node.BoundingBoxPosition; if (ray.Intersects(translatedBoundingBox) != null) { if (node.Children == null) { float shortestDistance = float.MaxValue; int shortestDistanceIndex = -1; for (int i = 0; i < node.InternalObjectPositions.Count; ++i) { float?distance = ray.Intersects(node.InternalObjectBoundingBoxes[i]); if (distance.HasValue && distance.Value < shortestDistance) { shortestDistance = distance.Value; shortestDistanceIndex = i; } } if (shortestDistance == float.MaxValue) { return(null); } else { intersectedPosition = node.InternalObjectPositions[shortestDistanceIndex]; return(shortestDistance); } } else { float shortestDistance = float.MaxValue; foreach (OctreeNode childNode in node.Children) { Vector3 position; float? distance = RayIntersection(childNode, ray, out position); if (distance.HasValue && distance.Value < shortestDistance) { shortestDistance = distance.Value; intersectedPosition = position; } } if (shortestDistance == float.MaxValue) { return(null); } else { return(shortestDistance); } } } return(null); }
public Octree(float xMax, float xMin, float yMax, float yMin, float zMax, float zMin, int maxItems, float minSize) { Top = new OctreeNode(xMax, xMin, yMax, yMin, zMax, zMin, maxItems, minSize); }
/// /// <summary> /// C'tor /// </summary> /// /// <param name="topLevelBoundingBox"> /// A top level bounding showing the size of the region that this octree will represent /// </param> /// /// <param name="topLevelBoundingBoxPosition"> /// The world coordinates of the minimum corner of the top level bounding box /// </param> /// public Octree(BoundingBox topLevelBoundingBox, Vector3 topLevelBoundingBoxPosition) { _masterBoundingBoxList.Add(topLevelBoundingBox); _root = new OctreeNode(_masterBoundingBoxList.Count - 1, topLevelBoundingBoxPosition); }
/// <summary> /// Construct the octree /// </summary> /// <param name="maxColorBits">The maximum number of significant bits in the image</param> public Octree(int maxColorBits) { _maxColorBits = maxColorBits; _leafCount = 0; _reducibleNodes = new OctreeNode[9]; _root = new OctreeNode(0, _maxColorBits, this); _previousColor = 0; _previousNode = null; }
public OctreeRenderer(OctreeNode <T> octree, AssetDatabase ad, RenderContext rc) : base(ad, rc, RgbaFloat.Red) { _octree = octree; }
/// <summary> /// Construct the node /// </summary> /// <param name="level">The level in the tree = 0 - 7</param> /// <param name="colorBits">The number of significant color bits in the image</param> /// <param name="octree">The tree to which this node belongs</param> public OctreeNode(int level, int colorBits, Octree octree) { // Construct the new node _leaf = (level == colorBits); _red = _green = _blue = 0; _pixelCount = 0; // If a leaf, increment the leaf count if (_leaf) { octree.Leaves++; _nextReducible = null; _children = null; } else { // Otherwise add this to the reducible nodes _nextReducible = octree.ReducibleNodes[level]; octree.ReducibleNodes[level] = this; _children = new OctreeNode[8]; } }
/// <summary> /// Recursively updates tree visibility /// </summary> /// <param name="n">Current node</param> /// <param name="p">Camera frustum planes</param> private void __updateOctreeNodeVisibility(OctreeNode n, Plane[] p) { if (GeometryUtility.TestPlanesAABB(p, n.AABB) && CanCameraSeeAABB(n.AABB, Camera.main.transform.position)) { n.gameObject.SetActive(true); for (int i = 0; i < n.children.Count; i++) __updateOctreeNodeVisibility(n.children[i], p); } else n.gameObject.SetActive(false); }
/// <summary> /// Keep track of the previous node that was quantized /// </summary> /// <param name="node"> /// The node last quantized /// </param> protected void TrackPrevious(OctreeNode node) { this.previousNode = node; }
/// <summary> /// Keep track of the previous node that was quantized /// </summary> /// <param name="node">The node last quantized</param> protected void trackPrevious(OctreeNode node) { _previousNode = node; }
/// <summary> /// Initializes a new instance of the <see cref="OctreeNode"/> class. /// </summary> /// <param name="level"> /// The level in the tree = 0 - 7 /// </param> /// <param name="colorBits"> /// The number of significant color bits in the image /// </param> /// <param name="octree"> /// The tree to which this node belongs /// </param> public OctreeNode(int level, int colorBits, Octree octree) { // Construct the new node this.leaf = level == colorBits; this.red = this.green = this.blue = 0; this.pixelCount = 0; // If a leaf, increment the leaf count if (this.leaf) { octree.Leaves++; this.nextReducible = null; this.children = null; } else { // Otherwise add this to the reducible nodes this.nextReducible = octree.ReducibleNodes[level]; octree.ReducibleNodes[level] = this; this.children = new OctreeNode[8]; } }
/// <summary> /// Recursively removes empty nodes /// </summary> /// <param name="n">Current node</param> /// <param name="_deepestNodes">List of deepest nodes to remove values from</param> private void __removeEmptyTreeNodes(OctreeNode n, List<OctreeNode> _deepestNodes) { for (int i = n.children.Count - 1; i >= 0; i--) __removeEmptyTreeNodes(n.children[i], _deepestNodes); if (n.children.Count == 0 && (n.value == null || n.value.mapObjects.Count == 0)) { _deepestNodes.Remove(n); GameObject.Destroy(n.gameObject); n.parent.children.Remove(n); } }
/// <summary>Initializes a new instance of the <see cref="Octree"/> class. Constructor</summary> /// <param name="pixelFormat">desired pixel format</param> internal Octree(PixelFormat pixelFormat) { // figure out the maximum colors from the pixel format passed in switch (pixelFormat) { case PixelFormat.Format1bppIndexed: this.octreeMaxColors = 2; break; case PixelFormat.Format4bppIndexed: this.octreeMaxColors = 16; break; case PixelFormat.Format8bppIndexed: this.octreeMaxColors = 256; break; default: throw new ArgumentException("Invalid Pixel Format", "pixelFormat"); } // we need a list for each level that may have reducible nodes. // since the last level (level 7) is only made up of leaf nodes, // we don't need an array entry for it. this.octreeReducibleNodes = new OctreeNode[7]; // add the initial level-0 root node this.octreeRoot = new OctreeNode(0, this); }
/// <summary> /// Find a node that fully contains the given bounds /// </summary> public bool ContainingNode(ref Vector3 center, ref Vector3 minBounds, ref Vector3 maxBounds, out OctreeNode node) { node = null; OctreeNode childNode = this;//Start here int index; while (true) { if (!childNode.ContainsBounds(ref minBounds, ref maxBounds)) { //Doesn't fit in this node. Put it in the parent node. if (childNode.childIndex == -1) { return(false); } node = childNode.parent; return(true); } index = childNode.BestFitChild(ref center); if (!childNode.isLeaf) { //Drop down another level if we have children childNode = childNode.children[index]; } else { //Place it here. No children node = childNode; return(true); } } }
/// <summary>set up the values we need to reuse the given pointer if the next color is argb</summary> /// <param name="node">last node to which we added a color</param> /// <param name="argb">last color we added</param> private void SetLastNode(OctreeNode node, int argb) { this.octreeLastNode = node; this.octreeLastArgb = argb; }
/// <summary> Keep track of the previous node that was quantized. </summary> /// <param name="node"> The node last quantized. </param> void TrackPrevious( OctreeNode node ) { previousNode = node; }
/// <summary> /// 分八个区 /// </summary> /// <param name="childNodes">八个子节点</param> /// <param name="oneBounds">当前节点的信息</param> private void SplitBounds(ref OctreeNode <T> currentNode, List <GameObject> objectList, int deep) { if (deep < m_MaxDepth) { currentNode.m_ObjectList = new List <GameObject>(); // 1、判断是否相交 相交就添加到当前节点的列表里 foreach (var gameObject in objectList) { if (gameObject.GetComponent <SphereCollider>() != null) { var gameObjectBounds = gameObject.GetComponent <Collider>().bounds; // 如果gameobject与分区相交 就添加到当前分区的列表里 if (currentNode.m_Bounds.Intersects(gameObjectBounds)) { currentNode.m_ObjectList.Add(gameObject); } } } // 2、分八个区域 currentNode.m_ChildNodes = new OctreeNode <T> [8]; currentNode.m_CurrentDepth = deep; var oneBounds = currentNode.m_Bounds; Vector3 half2Vector = oneBounds.size / 4; // 八块空间的位置 currentNode.m_ChildNodes[0].m_Bounds.center = oneBounds.center - half2Vector; currentNode.m_ChildNodes[0].m_Bounds.size = oneBounds.size / 2; currentNode.m_ChildNodes[1].m_Bounds.center = currentNode.m_ChildNodes[0].m_Bounds.center + new Vector3(oneBounds.size.x / 2, 0, 0); currentNode.m_ChildNodes[1].m_Bounds.size = oneBounds.size / 2; currentNode.m_ChildNodes[2].m_Bounds.center = currentNode.m_ChildNodes[1].m_Bounds.center + new Vector3(0, 0, oneBounds.size.z / 2); currentNode.m_ChildNodes[2].m_Bounds.size = oneBounds.size / 2; currentNode.m_ChildNodes[3].m_Bounds.center = currentNode.m_ChildNodes[0].m_Bounds.center + new Vector3(0, 0, oneBounds.size.z / 2); currentNode.m_ChildNodes[3].m_Bounds.size = oneBounds.size / 2; currentNode.m_ChildNodes[4].m_Bounds.center = currentNode.m_ChildNodes[0].m_Bounds.center + new Vector3(0, oneBounds.size.y / 2, 0); currentNode.m_ChildNodes[4].m_Bounds.size = oneBounds.size / 2; currentNode.m_ChildNodes[5].m_Bounds.center = currentNode.m_ChildNodes[1].m_Bounds.center + new Vector3(0, oneBounds.size.y / 2, 0); currentNode.m_ChildNodes[5].m_Bounds.size = oneBounds.size / 2; currentNode.m_ChildNodes[6].m_Bounds.center = currentNode.m_ChildNodes[2].m_Bounds.center + new Vector3(0, oneBounds.size.y / 2, 0); currentNode.m_ChildNodes[6].m_Bounds.size = oneBounds.size / 2; currentNode.m_ChildNodes[7].m_Bounds.center = currentNode.m_ChildNodes[3].m_Bounds.center + new Vector3(0, oneBounds.size.y / 2, 0); currentNode.m_ChildNodes[7].m_Bounds.size = oneBounds.size / 2; // 3、遍历8个区域 递归调用 for (int i = 0; i < currentNode.m_ChildNodes.Length; i++) { // 递归调用 if (currentNode.m_ObjectList.Count != 0) { // check if child node intersect bool isIntersects = false; currentNode.m_ChildNodes[i].m_ObjectList = new List <GameObject>(); foreach (var gameObject in currentNode.m_ObjectList) { if (gameObject.GetComponent <SphereCollider>() != null) { var gameObjectBounds = gameObject.GetComponent <Collider>().bounds; if (currentNode.m_ChildNodes[i].m_Bounds.Intersects(gameObjectBounds)) { currentNode.m_ChildNodes[i].m_ObjectList.Add(gameObject); isIntersects = true; } } } if (isIntersects) { if (currentNode.m_CurrentDepth != 0 && currentNode.m_ObjectList.Count == currentNode.m_ChildNodes[i].m_ObjectList.Count) { continue; } currentNode.m_CurrentDepth++; SplitBounds(ref currentNode.m_ChildNodes[i], currentNode.m_ObjectList, currentNode.m_CurrentDepth); } } } } }
/// <summary> /// Reduce the depth of the tree /// </summary> public void Reduce() { int index; // Find the deepest level containing at least one reducible node for (index = _maxColorBits - 1; (index > 0) && (null == _reducibleNodes[index]); index--) ; // Reduce the node most recently added to the list at level 'index' OctreeNode node = _reducibleNodes[index]; _reducibleNodes[index] = node.NextReducible; // Decrement the leaf count after reducing the node _leafCount -= node.Reduce(); // And just in case I've reduced the last color to be added, and the next color to // be added is the same, invalidate the previousNode... _previousNode = null; }
public void Add(T content) { if (!this.Bounds.Contains(content.Position)) { throw new UnityException("Cannot add an object outside of octree"); } // just add if empty if ((IsLeaf() && _Contents.Count == 0) || Level == MaxLevel) { _Contents.Add(content); } else { if (content.Position.Equals(this.Bounds.center) || (_Contents.Count > 0 && _Contents.TrueForAll(i => content.Position.Equals(i.Position)))) { _Contents.Add(content); } else { if (IsLeaf()) { // build children _IsLeaf = false; var ex = this.Bounds.extents * 0.5f; Children[0] = new OctreeNode <T>(new Bounds(this.Bounds.center + new Vector3(-ex.x, -ex.y, -ex.z), this.Bounds.extents), Level + 1, MaxLevel); Children[1] = new OctreeNode <T>(new Bounds(this.Bounds.center + new Vector3(-ex.x, -ex.y, ex.z), this.Bounds.extents), Level + 1, MaxLevel); Children[2] = new OctreeNode <T>(new Bounds(this.Bounds.center + new Vector3(ex.x, -ex.y, -ex.z), this.Bounds.extents), Level + 1, MaxLevel); Children[3] = new OctreeNode <T>(new Bounds(this.Bounds.center + new Vector3(ex.x, -ex.y, ex.z), this.Bounds.extents), Level + 1, MaxLevel); Children[4] = new OctreeNode <T>(new Bounds(this.Bounds.center + new Vector3(-ex.x, ex.y, -ex.z), this.Bounds.extents), Level + 1, MaxLevel); Children[5] = new OctreeNode <T>(new Bounds(this.Bounds.center + new Vector3(-ex.x, ex.y, ex.z), this.Bounds.extents), Level + 1, MaxLevel); Children[6] = new OctreeNode <T>(new Bounds(this.Bounds.center + new Vector3(ex.x, ex.y, -ex.z), this.Bounds.extents), Level + 1, MaxLevel); Children[7] = new OctreeNode <T>(new Bounds(this.Bounds.center + new Vector3(ex.x, ex.y, ex.z), this.Bounds.extents), Level + 1, MaxLevel); // move any existing items for (var i = 0; i < Contents.Count; i++) { if (!content.Position.Equals(this.Bounds.center)) { for (var j = 0; j < 8; j++) { T c = Contents[i]; if (Children[j].Contains(c.Position)) { Children[j].Add(c); } } _Contents.Clear(); } } } // add new item into child for (var i = 0; i < 8; i++) { if (Children[i].Contains(content.Position)) { Children[i].Add(content); } } } } }
/// <summary> /// Initializes a new instance of the <see cref="Octree"/> class. /// </summary> /// <param name="maxColorBits"> /// The maximum number of significant bits in the image /// </param> public Octree(int maxColorBits) { this.maxColorBits = maxColorBits; this.leafCount = 0; this.reducibleNodes = new OctreeNode[9]; this.root = new OctreeNode(0, this.maxColorBits, this); this.previousColor = 0; this.previousNode = null; }
private void AddVerticesAndIndices(OctreeNode <T> octree, List <VertexPositionNormalTexture> vertices, List <int> indices) { int baseIndex = vertices.Count; var bounds = octree.Bounds; vertices.Add(new VertexPositionNormalTexture(new Vector3(bounds.Min.X, bounds.Min.Y, bounds.Min.Z), Vector3.Zero, Vector2.Zero)); vertices.Add(new VertexPositionNormalTexture(new Vector3(bounds.Min.X, bounds.Max.Y, bounds.Min.Z), Vector3.Zero, Vector2.Zero)); vertices.Add(new VertexPositionNormalTexture(new Vector3(bounds.Max.X, bounds.Max.Y, bounds.Min.Z), Vector3.Zero, Vector2.Zero)); vertices.Add(new VertexPositionNormalTexture(new Vector3(bounds.Max.X, bounds.Min.Y, bounds.Min.Z), Vector3.Zero, Vector2.Zero)); vertices.Add(new VertexPositionNormalTexture(new Vector3(bounds.Min.X, bounds.Min.Y, bounds.Max.Z), Vector3.Zero, Vector2.Zero)); vertices.Add(new VertexPositionNormalTexture(new Vector3(bounds.Min.X, bounds.Max.Y, bounds.Max.Z), Vector3.Zero, Vector2.Zero)); vertices.Add(new VertexPositionNormalTexture(new Vector3(bounds.Max.X, bounds.Max.Y, bounds.Max.Z), Vector3.Zero, Vector2.Zero)); vertices.Add(new VertexPositionNormalTexture(new Vector3(bounds.Max.X, bounds.Min.Y, bounds.Max.Z), Vector3.Zero, Vector2.Zero)); indices.Add(baseIndex + 0); indices.Add(baseIndex + 1); indices.Add(baseIndex + 0); indices.Add(baseIndex + 1); indices.Add(baseIndex + 2); indices.Add(baseIndex + 1); indices.Add(baseIndex + 2); indices.Add(baseIndex + 3); indices.Add(baseIndex + 2); indices.Add(baseIndex + 0); indices.Add(baseIndex + 3); indices.Add(baseIndex + 0); indices.Add(baseIndex + 4); indices.Add(baseIndex + 5); indices.Add(baseIndex + 4); indices.Add(baseIndex + 5); indices.Add(baseIndex + 1); indices.Add(baseIndex + 5); indices.Add(baseIndex + 1); indices.Add(baseIndex + 0); indices.Add(baseIndex + 1); indices.Add(baseIndex + 4); indices.Add(baseIndex + 0); indices.Add(baseIndex + 4); indices.Add(baseIndex + 7); indices.Add(baseIndex + 6); indices.Add(baseIndex + 7); indices.Add(baseIndex + 6); indices.Add(baseIndex + 5); indices.Add(baseIndex + 6); indices.Add(baseIndex + 5); indices.Add(baseIndex + 4); indices.Add(baseIndex + 5); indices.Add(baseIndex + 7); indices.Add(baseIndex + 4); indices.Add(baseIndex + 7); indices.Add(baseIndex + 3); indices.Add(baseIndex + 2); indices.Add(baseIndex + 3); indices.Add(baseIndex + 2); indices.Add(baseIndex + 6); indices.Add(baseIndex + 2); indices.Add(baseIndex + 6); indices.Add(baseIndex + 7); indices.Add(baseIndex + 6); indices.Add(baseIndex + 3); indices.Add(baseIndex + 7); indices.Add(baseIndex + 3); foreach (var child in octree.Children) { AddVerticesAndIndices(child, vertices, indices); } }
/// <summary> /// Reduce the depth of the tree /// </summary> private void Reduce() { // Find the deepest level containing at least one reducible node int index = this.maxColorBits - 1; while ((index > 0) && (null == this.reducibleNodes[index])) { index--; } // Reduce the node most recently added to the list at level 'index' OctreeNode node = this.reducibleNodes[index]; this.reducibleNodes[index] = node.NextReducible; // Decrement the leaf count after reducing the node this.leafCount -= node.Reduce(); // And just in case I've reduced the last color to be added, and the next color to // be added is the same, invalidate the previousNode... this.previousNode = null; }
public Octree(Vector3 position, float size, int depth) { node = new OctreeNode <T>(position, size); node.Subdivide(depth); }
/// <summary> /// Add a color into the tree /// </summary> /// <param name="pixel"> /// The color /// </param> /// <param name="colorBits"> /// The number of significant color bits /// </param> /// <param name="level"> /// The level in the tree /// </param> /// <param name="octree"> /// The tree to which this node belongs /// </param> public void AddColor(Color32* pixel, int colorBits, int level, Octree octree) { // Update the color information if this is a leaf if (this.leaf) { this.Increment(pixel); // Setup the previous node octree.TrackPrevious(this); } else { // Go to the next level down in the tree int shift = 7 - level; int index = ((pixel->R & Mask[level]) >> (shift - 2)) | ((pixel->G & Mask[level]) >> (shift - 1)) | ((pixel->B & Mask[level]) >> shift); OctreeNode child = this.children[index]; if (null == child) { // Create a new child node & store in the array child = new OctreeNode(level + 1, colorBits, octree); this.children[index] = child; } // Add the color to the child node child.AddColor(pixel, colorBits, level + 1, octree); } }
//------------------------------------------------------------------------------------------- void UpdateOctree() { playerNode = OctreeNode.getRoot.CreateSubdivisionsWithItem(maxOctreeGenerations, Player.position); //Invoke("UpdateGrpahics", 0.4f); //UpdateGrpahics(); }
/// <summary> /// Return a color palette for the computed octree. /// </summary> /// <returns>A color palette for the computed octree</returns> internal Color[] GetPaletteColors() { // If we haven't already computed it, compute it now if (this.octreePalette == null) { // Start at the second-to-last reducible level int reductionLevel = this.octreeReducibleNodes.Length - 1; // We want to subtract one from the target if we have a transparent // bit because we want to save room for that special color int targetCount = this.octreeMaxColors - (this.octreeHasTransparent ? 1 : 0); // While we still have more colors than the target... while (this.octreeColorCount > targetCount) { // Find the first reducible node, starting with the last level // that can have reducible nodes while (reductionLevel > 0 && this.octreeReducibleNodes[reductionLevel] == null) { --reductionLevel; } if (this.octreeReducibleNodes[reductionLevel] == null) { // Shouldn't get here break; } // We should have a node now OctreeNode newLeaf = this.octreeReducibleNodes[reductionLevel]; this.octreeReducibleNodes[reductionLevel] = newLeaf.NextReducibleNode; this.octreeColorCount -= newLeaf.Reduce() - 1; } if (reductionLevel == 0 && !this.octreeHasTransparent) { // If this was the top-most level, we now only have a single color // representing the average. That's not what we want. // use just black and white this.octreePalette = new Color[2]; this.octreePalette[0] = Color.Black; this.octreePalette[1] = Color.White; // And empty the octree so it always picks the closer of the black and white entries this.octreeRoot = new OctreeNode(0, this); } else { // Now walk the tree, adding all the remaining colors to the list int paletteIndex = 0; this.octreePalette = new Color[this.octreeColorCount + (this.octreeHasTransparent ? 1 : 0)]; // Add the transparent color if we need it if (this.octreeHasTransparent) { this.octreePalette[paletteIndex++] = Color.Transparent; } // Have the nodes insert their leaf colors this.octreeRoot.AddColorsToPalette(this.octreePalette, ref paletteIndex); } } return this.octreePalette; }
private void Awake() { _vm = this; vdm = new DataGenerator(worldSize.y); OctreeNode.Init(); }
/// <summary>set up the values we need to reuse the given pointer if the next color is argb</summary> /// <param name="node">last node to which we added a color</param> /// <param name="argb">last color we added</param> private void SetLastNode(OctreeNode node, int argb) { this.octreeLastNode = node; this.octreeLastArgb = argb; }
public OctreeNode ConstructUpwards(List <OctreeNode> inputNodes, Vector3 rootMin, int rootNodeSize) { if (inputNodes.Count == 0) { return(null); } int baseNodeSize = inputNodes[0].size; List <OctreeNode> nodes = new List <OctreeNode>(); for (int i = 0; i < inputNodes.Count; i++) { nodes.Add(inputNodes[i]); } nodes.Sort(delegate(OctreeNode lhs, OctreeNode rhs) { return(lhs.size - rhs.size); }); // the input nodes may be different sizes if a seam octree is being constructed // in that case we need to process the input nodes in stages along with the newly // constructed parent nodes until all the nodes have the same size while (nodes[0].size != nodes[nodes.Count - 1].size) { // find the end of this run int iter = 0; int size = nodes[iter].size; do { ++iter; } while (nodes[iter].size == size); // construct the new parent nodes for this run List <OctreeNode> newNodes = new List <OctreeNode>(); for (int i = 0; i < iter; i++) { newNodes.Add(nodes[i]); } newNodes = ConstructParents(newNodes, rootMin, size * 2); // set up for the next iteration: the parents produced plus any remaining input nodes for (int i = iter; i < nodes.Count; i++) { newNodes.Add(nodes[i]); } nodes.Clear(); for (int i = 0; i < newNodes.Count; i++) { nodes.Add(newNodes[i]); } newNodes.Clear(); newNodes = null; } int parentSize = nodes[0].size * 2; while (parentSize <= rootNodeSize) { nodes = ConstructParents(nodes, rootMin, parentSize); parentSize *= 2; } if (nodes.Count != 1) { Debug.Log(baseNodeSize); Debug.Log(rootMin); Debug.Log(rootNodeSize); Debug.LogError("There can only be one root node!"); Application.Quit(); } OctreeNode root = nodes[0]; nodes.Clear(); nodes = null; return(root); }