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 );
