private void Awake() { _voxelRenderer = GetComponent<VoxelModelRenderer>(); _voxelAnimation = GetComponent<VoxelAnimation>(); _voxelData = new VoxelData(); transform.position = new Vector3(-.5f, .5f, -.5f); }
public void initialize(VoxelData voxelData, BlobManager blobOwner, IntVector3 startPosition) { this.blobOwner = blobOwner; this.startPosition = startPosition; textureIndex = 0; status = new VoxelStatus (); setVoxelData (voxelData); setName (); }
public void UpgradeFromData(VoxelData data, int sz, int offsetX, int offsetZ) { size = sz; nodes = new VoxelOctNode[data.sizeY/size+1]; for (int i=0; i<nodes.Length; i++) nodes[i] = new VoxelOctNode(); for (int y=0; y<data.sizeY; y++) for (int x=0; x<size; x++) for (int z=0; z<size; z++) { VoxelOctNode node = data.GetClosestNode(x+offsetX, y, z+offsetZ); SetBlock(x,y,z, node.type, node.exists); } }
public void Apply(VoxelData voxelData) { switch (_type) { case Type.Add: voxelData.AddVoxel(_voxel); break; case Type.Remove: voxelData.RemoveVoxel(_pos); break; default: throw new UnityException(); } }
public static SerializedVoxelData SerializeVoxelData(VoxelData voxelData) { if (voxelData == null) { Debug.LogWarning("Attempted to serialize null VoxelData"); return null; } BinaryFormatter formatter = new BinaryFormatter(); using (MemoryStream stream = new MemoryStream()) { formatter.Serialize(stream, voxelData.Voxels); return new SerializedVoxelData(stream.ToArray()); } }
// TODO: Clean all of this code up... /// <summary> /// Update the model to represent the given voxel data /// </summary> public void RenderMesh(VoxelData voxelData) { List<Vector3> verts = new List<Vector3>(); List<int> trigs = new List<int>(); List<Color> colors = new List<Color>(); Mesh mesh = _meshFilter.mesh; foreach (Voxel voxel in voxelData.Voxels) { if (!voxelData.HasVoxelAtPos(voxel.Pos + Vector3Int.Up)) { GenTopFace(voxel, verts, trigs, colors); } if (!voxelData.HasVoxelAtPos(voxel.Pos - Vector3Int.Up)) { GenBottomFace(voxel, verts, trigs, colors); } if (!voxelData.HasVoxelAtPos(voxel.Pos + Vector3Int.Forward)) { GenNorthFace(voxel, verts, trigs, colors); } if (!voxelData.HasVoxelAtPos(voxel.Pos - Vector3Int.Forward)) { GenSouthFace(voxel, verts, trigs, colors); } if (!voxelData.HasVoxelAtPos(voxel.Pos + Vector3Int.Right)) { GenEastFace(voxel, verts, trigs, colors); } if (!voxelData.HasVoxelAtPos(voxel.Pos - Vector3Int.Right)) { GenWestFace(voxel, verts, trigs, colors); } } // Update the mesh filter to the new model mesh.Clear(); mesh.vertices = verts.ToArray(); mesh.triangles = trigs.ToArray(); mesh.colors = colors.ToArray(); mesh.uv = new List<Vector2>(verts.Count).ToArray(); mesh.Optimize(); mesh.RecalculateNormals(); // Update the mesh collider to the new model _meshCollider.sharedMesh = null; _meshCollider.sharedMesh = mesh; }
private void Awake() { ServerButton.onClick.AddListener(() => { // try to start the server VoxelData voxelData = null; try { voxelData = VoxelSerializer.VoxelDataFromFile(LoadPath); } catch (Exception) { voxelData = null; } if (voxelData == null) { voxelData = new VoxelData(); } try { Server.Start(Port, Port, Config.SERVER_LOG_FILE, voxelData); } catch (Exception e) { WriteToErrorBox(e.ToString()); } // this thread does nothing now... }); ClientButton.onClick.AddListener(() => { // try to start the client try { Client.Start(IpAddress, Port, Port, Config.CLIENT_LOG_FILE); } catch (Exception e) { WriteToErrorBox(e.ToString()); return; } // load editor if client successfully starts Application.LoadLevel(1); }); ExitButton.onClick.AddListener(Application.Quit); }
// Throws an exception on error. public static void Start(int tcpPort, int udpPort, string logfilePath, VoxelData voxelData) { _logger = new Logger (logfilePath); _voxelData = voxelData; // open TCP listener Socket serverSocket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); serverSocket.Bind (new IPEndPoint (IPAddress.Any, tcpPort)); serverSocket.Listen (0); _logger.Log (string.Format ("TCP listening on {0}", Utils.IPAddressToString(serverSocket.LocalEndPoint))); // open UDP listener UdpClient serverUdpClient = new UdpClient (udpPort); _logger.Log (string.Format ("UDP listening on {0}", Utils.IPAddressToString(serverUdpClient.Client.LocalEndPoint))); // start accepting clients Concurrency.StartThread (() => AcceptTcpClients (serverSocket), "server accept TCP clients loop", _logger); // start broadcasting incoming UDP packets Concurrency.StartThread (() => HandleUdp (serverUdpClient), "server broadcast UDP packets", _logger); }
public void Copy( VoxelData data ) { sizeX = data.sizeX; sizeY = data.sizeY; sizeZ = data.sizeZ; biggestNode = data.biggestNode; nodesX = data.nodesX; nodesY = data.nodesY; nodesZ = data.nodesZ; blocks = new int[0]; octree = new VoxelOctNode[ nodesX * nodesY * nodesZ ]; for (int x=0; x<nodesX; x++) for (int y=0; y<nodesY; y++) for (int z=0; z<nodesZ; z++) { int i = z*nodesY*nodesX + y*nodesX + x; octree[i] = data.octree[i].Copy(); } }
void Compress_OtherInfos_RLE( VoxelData* Data, ushort* VoxelData, void* Stream );
/// <summary> /// Only load from file before the scene is live (before the user can edit the model) /// </summary> public void LoadFromFile(string filepath) { _voxelData = VoxelSerializer.VoxelDataFromFile(filepath); _voxelRenderer.RenderMesh(_voxelData); }
public void ChangeData(VoxelData voxelData) { _voxelData = voxelData; _voxelRenderer.RenderMesh(_voxelData); }
/// <summary> /// Updates the ore locations then fires OnUpdateComplete /// </summary> public void UpdateOreLocations() { if (!Block.IsWorking) { m_logger.debugLog("not working: " + Block.DisplayNameText, "Update()"); return; } m_logger.debugLog("running update", "Update()"); BoundingSphereD detection = new BoundingSphereD(m_oreDetector.GetPosition(), m_maxRange); m_nearbyVoxel.Clear(); MainLock.UsingShared(() => MyGamePruningStructure.GetAllVoxelMapsInSphere(ref detection, m_nearbyVoxel)); foreach (IMyVoxelBase nearbyMap in m_nearbyVoxel) if (nearbyMap is IMyVoxelMap || nearbyMap is MyPlanet) { VoxelData data; using (l_voxelDate.AcquireExclusiveUsing()) if (!m_voxelData.TryGetValue(nearbyMap, out data)) { data = new VoxelData(m_oreDetector, nearbyMap, m_maxRange); m_voxelData.Add(nearbyMap, data); } using (l_waitingOn.AcquireExclusiveUsing()) if (data.StartRead(OnVoxelFinish)) m_waitingOn++; } if (m_waitingOn == 0) { using (l_waitingOn.AcquireExclusiveUsing()) m_waitingOn++; OnVoxelFinish(); return; } }
void ChangeSize( uint Size_x, uint Size_y, uint Size_z ) { int i; Data = new VoxelData( Size_x * Size_y * Size_z ); //Data.TempInfos = null; //if (OtherInfos) {delete [] OtherInfos; OtherInfos = 0; } //if (TempInfos) {delete [] TempInfos; TempInfos = 0; } this.Size_x = Size_x; this.Size_y = Size_y; this.Size_z = Size_z; Handle_x = Handle_y = Handle_z = 0; DataSize = Size_x * Size_y * Size_z; solid_geometry.Clear(); transparent_geometry.Clear(); custom_geometry.Clear(); if( Culler != null ) Culler.InitFaceCullData( this ); //for( i = 0; i < DataSize; i++ ) Data.TempInfos[i] = 273 + 20; }
public void LoadFromData(int x, int z, VoxelData data) { //generating byte column for (int y=0; y<data.sizeY; y++) byteColumn[y] = (byte)(data.GetNode(x,y,z).type); //baking it BakeByteColumn(); }
bool Decompress_Short_RLE( VoxelData* Data, void* Stream );
/// <summary> /// Searches nearby voxels for ores. /// </summary> /// <param name="position">Position of autopilot block</param> /// <param name="oreType">Ore types to search for</param> /// <param name="onComplete">Invoked iff an ore is found</param> /// <returns>true iff an ore is found</returns> private bool GetOreLocations(Vector3D position, byte[] oreType, OreSearchComplete onComplete) { m_logger.debugLog("entered GetOreLocations()"); BoundingSphereD detection = new BoundingSphereD(m_oreDetector.GetPosition(), m_maxRange); m_nearbyVoxel.Clear(); MyGamePruningStructure.GetAllVoxelMapsInSphere(ref detection, m_nearbyVoxel); IOrderedEnumerable<MyVoxelBase> sorted = m_nearbyVoxel.OrderBy(voxel => Vector3D.DistanceSquared(voxel.GetCentre(), position)); foreach (IMyVoxelBase nearbyMap in sorted) { if (nearbyMap is IMyVoxelMap || nearbyMap is MyPlanet) { VoxelData data; using (l_voxelData.AcquireExclusiveUsing()) if (!m_voxelData.TryGetValue(nearbyMap, out data)) { data = new VoxelData(m_oreDetector, nearbyMap, m_maxRange); m_voxelData.Add(nearbyMap, data); } if (data.NeedsUpdate) { m_logger.debugLog("Data needs to be updated for " + nearbyMap.getBestName()); data.Read(); } else m_logger.debugLog("Old data OK for " + nearbyMap.getBestName()); Vector3D closest; byte foundOre; if (data.GetClosest(oreType, ref position, out closest, out foundOre)) { m_logger.debugLog("PositionLeftBottomCorner: " + nearbyMap.PositionLeftBottomCorner + ", worldPosition: " + closest + ", distance: " + Vector3D.Distance(position, closest)); string oreName = MyDefinitionManager.Static.GetVoxelMaterialDefinition(foundOre).MinedOre; onComplete(true, closest, nearbyMap, oreName); m_nearbyVoxel.Clear(); return true; } } } m_nearbyVoxel.Clear(); return false; }
public VoxelData get_meta(GameObject model) { VoxelData item; if(!voxels.TryGetValue(model.name, out item)) { item = new VoxelData(model.name, model.renderer.sharedMaterials); voxels[model.name] = item; } return item; }
//bool Decompress_FaceCulling_RLE(byte * Data, void * Stream); bool Decompress_OtherInfos_RLE( VoxelData* Data, void* Stream );
void InitSector() { int i; solid_geometry = new VoxelGeometry(); transparent_geometry = new VoxelGeometry(); custom_geometry = new VoxelGeometry(); //Pos_x = 0; Pos_y = 0; Pos_z = 0; Handle_x = Handle_y = Handle_z = 0; ZoneType = 0; ZoneVersion = 0; GeneratorVersion = 0; RingNum = 65535; #if VOXEL_CULLER Culling = 0; #endif Data = new VoxelData( Size_x * Size_y * Size_z ); for( int r = 0; r < 6; r++ ) { near_sectors[r] = null; } Flag_Render_Dirty = true; Flag_HighPriorityRefresh = false; Flag_Void_Regular = true; Flag_Void_Transparent = true; Flag_IsVisibleAtLastRendering = false; Flag_DeletePending = false; Flag_NeedFullCulling = false; Flag_KeepInMemory = false; Flag_IsModified = ModifiedFieldFlags.NONE; Flag_IsSlowGeneration = false; Flag_IsActiveVoxels = false; Flag_IsActiveLowRefresh = false; Flag_NeedSortedRendering = false; PartialCulling = 0; RefreshWaitCount = 0; LowRefresh_Mask = 0x0F; }
public VoxelSector( VoxelSector Sector ) { uint DataSize; DataSize = Sector.DataSize; Data = new VoxelData( ZVOXELBLOCKCOUNT ); for( int i = 0; i < DataSize; i++ ) { Data.Data[i] = Sector.Data.Data[i]; } VoxelTypeManager = null; Next = Pred = GlobalList_Next = GlobalList_Pred = null; Handle_x = Sector.Handle_x; Handle_y = Sector.Handle_y; Handle_z = Sector.Handle_z; Pos_x = Sector.Pos_x; Pos_y = Sector.Pos_y; Pos_z = Sector.Pos_z; Size_x = Sector.Size_x; Size_y = Sector.Size_y; Size_z = Sector.Size_z; Flag_Void_Regular = Sector.Flag_Void_Regular; Flag_Void_Transparent = Sector.Flag_Void_Transparent; Flag_Render_Dirty = Sector.Flag_Render_Dirty; Flag_HighPriorityRefresh = Sector.Flag_HighPriorityRefresh; Flag_IsVisibleAtLastRendering = Sector.Flag_IsVisibleAtLastRendering; Flag_DeletePending = Sector.Flag_DeletePending; Flag_NeedFullCulling = Sector.Flag_NeedFullCulling; Flag_KeepInMemory = Sector.Flag_KeepInMemory; Flag_IsModified = Sector.Flag_IsModified; Flag_IsSlowGeneration = Sector.Flag_IsSlowGeneration; Flag_IsActiveVoxels = Sector.Flag_IsActiveVoxels; Flag_IsActiveLowRefresh = Sector.Flag_IsActiveLowRefresh; Flag_NotStandardSize = Sector.Flag_NotStandardSize; Flag_NeedSortedRendering = Sector.Flag_NeedSortedRendering; PartialCulling = Sector.PartialCulling; RefreshWaitCount = Sector.RefreshWaitCount; LowRefresh_Mask = Sector.LowRefresh_Mask; }
private void setVoxelData(VoxelData voxelData) { this.voxelData = voxelData; textureIndex = getNewTextureIndex (); renderer.material.mainTexture = voxelData.textures [textureIndex]; }
public void Insert( VoxelData data , int stepX , int stepY , int stepZ ) { VoxelOctNode[] newOctree= new VoxelOctNode[ nodesX * nodesY * nodesZ ]; for (int x=0; x<nodesX; x++) for (int y=0; y<nodesY; y++) for (int z=0; z<nodesZ; z++) { int i = z*nodesY*nodesX + y*nodesX + x; newOctree[i] = new VoxelOctNode(); //newOctree[i].GenerateFromTwoOctrees(data, this, x*biggestNode, y*biggestNode, z*biggestNode, biggestNode/2, -stepX, -stepY, -stepZ); } octree = newOctree; #if UNITY_EDITOR UnityEditor.EditorUtility.SetDirty(this); #endif }
public static void VoxelDataToFile(string filepath, VoxelData data) { File.WriteAllBytes(filepath, SerializeVoxelData(data).bytes); }
public static VoxelData AllocateData(int sx, int sy, int sz) { int numVoxels = sx*sy*sz; VoxelData toReturn = new VoxelData() { Health = new byte[numVoxels], IsExplored = new bool[numVoxels], SunColors = new byte[numVoxels], Types = new byte[numVoxels], Water = new WaterCell[numVoxels], RampTypes = new RampType[numVoxels], VertexColors = new Color[(sx + 1) * (sy + 1) * (sz + 1)], SizeX = sx, SizeY = sy, SizeZ = sz }; for (int i = 0; i < numVoxels; i++) { toReturn.Water[i] = new WaterCell(); } return toReturn; }
bool Decompress_Temperatures_RLE( VoxelData* Data, void* Stream );