public override void OnInspectorGUI() { CogBlockVolumeRenderer renderer = target as CogBlockVolumeRenderer; float labelWidth = 120.0f; EditorGUILayout.BeginHorizontal(); EditorGUILayout.LabelField("Receive Shadows:", GUILayout.Width(labelWidth)); renderer.receiveShadows = EditorGUILayout.Toggle(renderer.receiveShadows); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); EditorGUILayout.LabelField("Cast Shadows:", GUILayout.Width(labelWidth)); renderer.castShadows = EditorGUILayout.Toggle(renderer.castShadows); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); renderer.material = EditorGUILayout.ObjectField("Material: ", renderer.material, typeof(Material), true) as Material; EditorGUILayout.EndHorizontal(); if (!GUI.changed) { return; } CogBlockVolume vol = renderer.gameObject.GetComponentInChildren <CogBlockVolume>() as CogBlockVolume; if (vol != null) { //Debug.Log("GuiChange detected"); //for some reason, trying to get the octreenode from here resulted in CATASTROPHIC MELTDOWN where OctreeNodeAlt reported no children. //Do I understand? Nupe. This works better anyway by talking only to volume vol.RelayComponentChanges = true; } }
/// <summary> /// Synchronize this instance. /// </summary> protected override void Synchronize() { //super! base.Synchronize(); //Not sure if this needs to be done every synchronization but okay CogBlockVolumeRenderer volRend = gameObject.GetComponent <CogBlockVolumeRenderer>(); //initialize the volume renderer so that it's normals face in the correct direction if (volRend != null) //I miss actionscript with lazy evaluation so I could string these all together in one big if.. { if (volRend.material != null) { // We compute surface normals using derivative operations in the fragment shader, but for some reason // these are backwards on Linux. We can correct for this in the shader by setting the multiplier below. #if UNITY_STANDALONE_LINUX && !UNITY_EDITOR float normalMultiplier = -1.0f; #else float normalMultiplier = 1.0f; #endif volRend.material.SetFloat("normalMultiplier", normalMultiplier); } } // Check to make sure we have anything to Synchronize if (data == null) { return; } //still checking if (!data.volumeHandle.HasValue) { return; } //update the volume CubiquityDLL.UpdateVolume(data.volumeHandle.Value); //try to synchronize the octrees if (CubiquityDLL.HasRootOctreeNode(data.volumeHandle.Value) == 1) { if (rootOctreeNode == null || rootOctreeNodeGameObject == null) { //Debug.Log("Creating RootOctreeNode from null"); uint rootNodeHandle = CubiquityDLL.GetRootOctreeNode(data.volumeHandle.Value); rootOctreeNode = OctreeNodeAlt.CreateOctreeNode(typeof(CogBlockOctreeNode), rootNodeHandle, gameObject) as CogBlockOctreeNode; rootOctreeNodeGameObject = rootOctreeNode.gameObject; } //Sync the Node and remember SyncNode will return syncs remaining. If some are remaining, the mesh is syncronized. isMeshSyncronized = (rootOctreeNode.SyncNode(maxNodesPerSync) != 0); //Where Sync nodes handles re-informed a bunch of nodes based on mesh changes, RelayComponentChanges assumes that something happened //which every node of the octree needs to know about. By setting this flag = true, we can relay those changes quickly down through the whole tree. //of course since RelayComponentChanges doesn't really 'yield' after a certain number of units are updated, it is important to realize this function is //called sparingly, usually only in edit mode, and should not perform incredibly complex per-update operations. if (RelayComponentChanges) { rootOctreeNode.RelayComponentChanges(); } } }