public int syncNode(int availableNodeSyncs, GameObject voxelTerrainGameObject) { int nodeSyncsPerformed = 0; if (availableNodeSyncs <= 0) { return(nodeSyncsPerformed); } uint meshLastUpdated = CubiquityDLL.GetMeshLastUpdated(nodeHandle); if (meshLastSyncronised < meshLastUpdated) { if (CubiquityDLL.NodeHasMesh(nodeHandle) == 1) { // Set up the rendering mesh VolumeRenderer volumeRenderer = voxelTerrainGameObject.GetComponent <VolumeRenderer>(); if (volumeRenderer != null) { //Mesh renderingMesh = volumeRenderer.BuildMeshFromNodeHandle(nodeHandle); Mesh renderingMesh = null; if (voxelTerrainGameObject.GetComponent <Volume>().GetType() == typeof(TerrainVolume)) { renderingMesh = BuildMeshFromNodeHandleForTerrainVolume(nodeHandle); } else if (voxelTerrainGameObject.GetComponent <Volume>().GetType() == typeof(ColoredCubesVolume)) { renderingMesh = BuildMeshFromNodeHandleForColoredCubesVolume(nodeHandle); } MeshFilter meshFilter = gameObject.GetOrAddComponent <MeshFilter>() as MeshFilter; MeshRenderer meshRenderer = gameObject.GetOrAddComponent <MeshRenderer>() as MeshRenderer; if (meshFilter.sharedMesh != null) { DestroyImmediate(meshFilter.sharedMesh); } meshFilter.sharedMesh = renderingMesh; meshRenderer.sharedMaterial = volumeRenderer.material; #if UNITY_EDITOR EditorUtility.SetSelectedWireframeHidden(meshRenderer, true); #endif } // Set up the collision mesh VolumeCollider volumeCollider = voxelTerrainGameObject.GetComponent <VolumeCollider>(); if ((volumeCollider != null) && (Application.isPlaying)) { Mesh collisionMesh = volumeCollider.BuildMeshFromNodeHandle(nodeHandle); MeshCollider meshCollider = gameObject.GetOrAddComponent <MeshCollider>() as MeshCollider; meshCollider.sharedMesh = collisionMesh; } } // If there is no mesh in Cubiquity then we make sure there isn't on in Unity. else { MeshCollider meshCollider = gameObject.GetComponent <MeshCollider>() as MeshCollider; if (meshCollider) { DestroyImmediate(meshCollider); } MeshRenderer meshRenderer = gameObject.GetComponent <MeshRenderer>() as MeshRenderer; if (meshRenderer) { DestroyImmediate(meshRenderer); } MeshFilter meshFilter = gameObject.GetComponent <MeshFilter>() as MeshFilter; if (meshFilter) { DestroyImmediate(meshFilter); } } meshLastSyncronised = CubiquityDLL.GetCurrentTime(); availableNodeSyncs--; nodeSyncsPerformed++; } VolumeRenderer vr = voxelTerrainGameObject.GetComponent <VolumeRenderer>(); MeshRenderer mr = gameObject.GetComponent <MeshRenderer>(); if (vr != null && mr != null) { if (mr.enabled != vr.enabled) // Not sure we really need this check? { mr.enabled = vr.enabled; } if (lastSyncronisedWithVolumeRenderer < vr.lastModified) { mr.receiveShadows = vr.receiveShadows; mr.castShadows = vr.castShadows; lastSyncronisedWithVolumeRenderer = Clock.timestamp; } } VolumeCollider vc = voxelTerrainGameObject.GetComponent <VolumeCollider>(); MeshCollider mc = gameObject.GetComponent <MeshCollider>(); if (vc != null && mc != null) { if (mc.enabled != vc.enabled) // Not sure we really need this check? { mc.enabled = vc.enabled; } if (lastSyncronisedWithVolumeCollider < vc.lastModified) { // Actual syncronization to be filled in in the future when we have something to syncronize. lastSyncronisedWithVolumeCollider = Clock.timestamp; } } //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 (CubiquityDLL.HasChildNode(nodeHandle, x, y, z) == 1) { uint childNodeHandle = CubiquityDLL.GetChildNode(nodeHandle, x, y, z); GameObject childGameObject = GetChild(x, y, z); if (childGameObject == null) { childGameObject = OctreeNode.CreateOctreeNode(childNodeHandle, gameObject); SetChild(x, y, z, childGameObject); } //syncNode(childNodeHandle, childGameObject); OctreeNode childOctreeNode = childGameObject.GetComponent <OctreeNode>(); int syncs = childOctreeNode.syncNode(availableNodeSyncs, voxelTerrainGameObject); availableNodeSyncs -= syncs; nodeSyncsPerformed += syncs; } } } } return(nodeSyncsPerformed); }
//The purpose of availableNodeSyncs is because: This function is recursive. availableNodeSyncs tells it how deep to plumb /// <summary> /// A recursive function responsible for synchronizing Unity data with the CubiquityDLL data. /// </summary> /// <returns>The amount of synchronization steps left unexpended.</returns> /// <param name="availableNodeSyncs">a parameter to track how much synchronization can and will be done from recrusive layer to recursive layer.</param> public int SyncNode(int availableNodeSyncs) { //terminator of the all-powerful recursion if (availableNodeSyncs <= 0) { return(0); } //------------------------------------------- // PHASE ONE: Building Meshes! //------------------------------------------- //is a synchronization even called for? uint meshLastUpdated = CubiquityDLL.GetMeshLastUpdated(nodeHandle); //we don't have to synchronize this node if it wasn't updated. if (meshLastSyncronised < meshLastUpdated) { //I like major control branches that are concise to read! if (CubiquityDLL.NodeHasMesh(nodeHandle) == 1) { NodeMeshUp(); } else { NodeMeshDown(); } //absolutely do not decrement availableNodesyncs if no meshSyncing occured, or we'll never //explore the whole tree @.@ meshLastSyncronised = CubiquityDLL.GetCurrentTime(); availableNodeSyncs--; } //------------------------------------------- // PHASE TWO: RECURSE! //------------------------------------------- //we needs to know if any children were ever used in the making of this node. (that way we can children == null) at the end if necessary. bool usedChildren = false; //normally we would have to iterate across the two x children, the two y children, and the two z children using 3 nested //for-loops. Typically speaking, nesting for loops in a recursive function causes nausea, dry mouth, dizzinss and vomiting. //Let's flatten the array! for (uint x = 0, y = 0, z = 0, i = 0;; x++, i++) { //iteration code! if (x > 1) { y++; x = 0; } if (y > 1) { z++; y = 0; } if (z > 1) { break; } //At this point we know i is an element of [0,8) //And we know children exists. So we can directly getChild by using children[i]; //Steps: // 1) Ascertain whether we SHOULD have a unity node // 2) Ascertain whether we have a children array to store the unity node in. // 3) Ascertain whether we DO have a unity node // 4) See if the unity node is right, and then Synchronize it. //Test whether we have a child node and, if not, clean up leaves and bare branches if (CubiquityDLL.HasChildNode(nodeHandle, x, y, z) != 1) { //check to make sure we aren't about to dispose and a nonexistant child/array. //Use continue to check the next child if (children == null) { continue; } if (children[i] == null) { continue; } //Testing will need to be done, but TECHNICALLY this should destroy not only the octree node, but all octree nodes that come afterward (because it is //done on the game object, and the game object is the parent of the other octreenodes game objects) Destroy(children[i].gameObject); children[i] = null; continue; } //if we need a child Node and haven't even a child array, we need to init the array. else if (children == null) { children = new OctreeNodeAlt[8] { null, null, null, null, null, null, null, null }; } //nab the child Node Handle uint childNodeHandle = CubiquityDLL.GetChildNode(nodeHandle, x, y, z); //and create the Unity-side child, if necessary SetChild(i, childNodeHandle); //and synchronize the child if syncs are available. availableNodeSyncs = children[i].SyncNode(availableNodeSyncs); //if even one spot in the childArray is used, we set this to true usedChildren = true; } //delete children array to save space. if (usedChildren == false) { children = null; } //return any Syncs we have left! return(availableNodeSyncs); }
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(); } } }