// Update is called once per frame public void VoxelPhysicUpdate() { this.container = this.gameObject.GetComponent <VoxelContainer>(); if (this.container == null) { return; } switch (this.currentState) { case PhysicsState.WaitingForTask: this.DoWaitForTask(); return; case PhysicsState.Fragmanatation: //Fragmantation started by the waiting for Aggregation return; case PhysicsState.ObjectCreation: this.DoObjectCreation(); return; case PhysicsState.MovingDataToObjects: return; case PhysicsState.Finalisation: this.DoFinalization(); return; } }
private void ShootArray(Vector3 aPosition, Vector3 adirection, VoxelContainer aContainer, MeshCollider aCollider, Texture2D aObjectTexture) { //Physics.SphereCastAll(aPosition, 0.05f, adirection, Mathf.Infinity); RaycastHit[] hits = Physics.RaycastAll(aPosition, adirection, Mathf.Infinity); foreach (RaycastHit hit in hits) { if (hit.collider == aCollider) { Vector3 newPosition = hit.point - aCollider.gameObject.transform.position; newPosition.x = (int)Mathf.RoundToInt(newPosition.x); newPosition.y = (int)Mathf.RoundToInt(newPosition.y); newPosition.z = (int)Mathf.RoundToInt(newPosition.z); Voxel newVoxel; if (!aContainer.voxels.ContainsKey(newPosition)) { newVoxel = this.AddVoxelAtPosition(newPosition, aContainer, aCollider); if (aObjectTexture != null) { Color palettedColor = this.GetColorByTolerance(aObjectTexture.GetPixel((int)(hit.textureCoord.x * aObjectTexture.width), (int)(hit.textureCoord.y * aObjectTexture.height))); newVoxel.color = palettedColor; } } } } }
public void PlaceDamage(int x, int y, int z, float amount) { int cx, cy, cz; Utils.CoordVoxelToChunk(x, y, z, out cx, out cy, out cz, ChunkSize); int vx, vy, vz; Utils.CoordChunkToVoxel(cx, cy, cz, out vx, out vy, out vz); VoxelContainer vc = null; if (VoxelContainer.Containers.TryGetValue(Utils.VoxelCoordToLong(cx, cy, cz), out vc)) { var key = Utils.VoxelCoordToLong(x - vx, y - vy, z - vz); if (vc.Damages.ContainsKey(key)) { vc.Damages[key] += amount; } else { vc.Damages.Add(key, amount); } vc.BreaksProcessingNeeded = true; if (vc.Damages[key] > 1) { PlaceVoxel(x, y, z, 0, true); } } }
List<TexturedVertex> GenerateVertsFor(VoxelContainer data, IntVector3 start, IntVector3 end) { var verts = new List<TexturedVertex>(); var here = new IntVector3(data.Start); //Voxel currentVoxel; Vector3[] currentVerts; Vector2[] currentUVs; for (here.X = start.X; here.X <= end.X; here.X++) for (here.Z = start.Z; here.Z <= end.Z; here.Z++) for (here.Y = start.Y; here.Y <= end.Y; here.Y++) { //currentVoxel = data.GetVoxel(here); foreach (var face in VoxelHelper.VisibleFacesFor(data, here)) { currentVerts = VoxelHelper.FaceVerts(here, face).ToArray(); currentUVs = VoxelHelper.UVCoords(data.GetVoxel(here).Type, face, Atlas).ToArray(); verts.AddRange(new []{ new TexturedVertex(currentVerts[0], currentUVs[0]), new TexturedVertex(currentVerts[1], currentUVs[1]), new TexturedVertex(currentVerts[2], currentUVs[2]), new TexturedVertex(currentVerts[3], currentUVs[3]) }); } } return verts; }
private GameObject ConvertSprite(Sprite aSprite) { Texture2D editableTexture = this.GetReadableTexture(aSprite.texture); //Create simple container object GameObject rootObject = new GameObject(); rootObject.transform.position = new Vector3(0f, 0f, 0f); rootObject.name = StaticValues.baseObjectNamePrefix + aSprite.name; //Create Voxel container component for the root object VoxelContainer voxelContainer = rootObject.AddComponent <VoxelContainer>(); voxelContainer.ConvertTexture(editableTexture, aSprite.textureRect.min, aSprite.textureRect.max, this.alphaColor, this.alphaTolerance); voxelContainer.BuildOptimizedMesh(false); string assetPath = "Assets/" + StaticValues.voxelizerRootFolder + "/" + StaticValues.animationPrefabsFolder + "/" + rootObject.name + ".prefab"; PrefabUtility.CreatePrefab(assetPath, rootObject); DestroyImmediate(rootObject); #if UNITY_5_0 return((GameObject)AssetDatabase.LoadAssetAtPath(assetPath, typeof(GameObject))); #else return(AssetDatabase.LoadAssetAtPath <GameObject>(assetPath)); #endif }
public static void Explode(VoxelContainer voxelContainer) { var vc = voxelContainer; var cd = vc.ContainerData; for (var x = 1; x < cd.Size - 1; x += 2) { for (var y = 1; y < cd.Size - 1; y += 2) { for (var z = 1; z < cd.Size - 1; z += 2) { if (cd.Voxels[x, y, z] == null) { continue; } if (cd.Voxels[x, y, z].IsActive) { var pos = new Vector3(cd.Position.x + x, cd.Position.y + y, cd.Position.z + z); var go = ObjectPool.Instance.GetObjectForType <Fraction>(parent: voxelContainer.transform.parent); go.Init(pos, 2.0f, MaterialRegistry.Instance.MaterialFromId(cd.Voxels[x, y, z].BlockType).Color, voxelContainer.GetCenter()); } } } } DestroyImmediate(voxelContainer.gameObject); }
public void NewVoxelStructure() { GameObject newGameObject = new GameObject(); VoxelContainer newVoxelContainer = newGameObject.AddComponent<VoxelContainer>(); for (int i = 0; i < this.sizeVector.x; i++) { for (int j = 0; j < this.sizeVector.y; j++) { for (int z = 0; z < this.sizeVector.z; z++) { Voxel newVoxel = new Voxel(); newVoxel.position.x = i; newVoxel.position.y = j; newVoxel.position.z = z; newVoxelContainer.AddVoxel(newVoxel); } } } newVoxelContainer.BuildMesh(false, true, true, true); if (SceneView.lastActiveSceneView != null) { UnityEditor.Selection.activeGameObject = newGameObject; SceneView.lastActiveSceneView.pivot = newGameObject.transform.position; SceneView.lastActiveSceneView.Repaint(); } }
public void SetContainer(VoxelContainer acontainer) { this.container = acontainer; if (this.voxelList == null) { this.voxelList = new List <Voxel>(); } }
public void PlaceVoxel(int x, int y, int z, int type, bool overwrite = true) { //GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube); //cube.transform.position = new Vector3(x, y, z) + Vector3.one * 0.5f; //cube.renderer.material.color = Color.red; int cx, cy, cz; Utils.CoordVoxelToChunk(x, y, z, out cx, out cy, out cz, ChunkSize); int vx, vy, vz; Utils.CoordChunkToVoxel(cx, cy, cz, out vx, out vy, out vz); VoxelContainer vc = null; if (!VoxelContainer.Containers.TryGetValue(Utils.VoxelCoordToLong(cx, cy, cz), out vc)) { GameObject go = new GameObject("Voxel Container"); go.transform.parent = WorldManager.Active.transform; vc = go.AddComponent <VoxelContainer>(); vc.SideTexture = WorldManager.Active.SideTexture; vc.TopTexture = WorldManager.Active.TopTexture; vc.BottomTexture = WorldManager.Active.BottomTexture; vc.Shader = WorldManager.Active.VoxelShader; vc.LiquidShader = WorldManager.Active.LiquidShader; vc.BreakTexture = WorldManager.Active.BreakTexture; vc.X = cx; vc.Y = cy; vc.Z = cz; vc.Register(); go.isStatic = true; go.transform.position = new Vector3(vx, vy, vz); } lock (vc.Voxels) { var key = Utils.VoxelCoordToLong(x - vx, y - vy, z - vz); if (type == 0) { vc.Voxels.Remove(key); if (sygnalize) { vc.ProcessingNeeded = true; } } else if (overwrite || !vc.Voxels.ContainsKey(key)) { bool changed = vc.Voxels.AddOrReplace(key, type); if (changed && sygnalize) { vc.ProcessingNeeded = true; } } } }
private void ExtrudePart(Texture2D curTexture, Vector2 startPos, Vector2 endPos) { //Create simple container object GameObject rootObject = new GameObject(); rootObject.transform.position = new Vector3(0f, 0f, 0f); rootObject.name = StaticValues.baseObjectNamePrefix + curTexture.name; //Create Voxel container component for the root object VoxelContainer voxelContainer = rootObject.AddComponent <VoxelContainer>(); voxelContainer.ConvertTexture(curTexture, startPos, endPos, this.alphaColor, this.alphaTolerance); }
/* * Instantiate and fix the frame list if neccesary */ private void InstantiatePrefabs() { bool matchingAlreadyInstaniated = true; if (this.voxelContainerPrefabs.Count != this.frames.Count) { matchingAlreadyInstaniated = false; } else { for (int i = 0; i < this.voxelContainerPrefabs.Count; i++) { GameObject curPrefab = this.voxelContainerPrefabs[i]; GameObject curFrame = this.frames[i]; if (curFrame == null) { matchingAlreadyInstaniated = false; break; } VoxelContainer prefabContainer = curPrefab.GetComponent <VoxelContainer>(); VoxelContainer frameVoxelContainer = curFrame.GetComponent <VoxelContainer>(); if (prefabContainer == null) { Debug.LogError("One of the prefab in the animation '" + this.animationName + "' is does not have VoxelContainer!"); return; } if (prefabContainer.modelFilename != frameVoxelContainer.modelFilename) { matchingAlreadyInstaniated = false; break; } } } if (!matchingAlreadyInstaniated) { foreach (GameObject curFrame in this.frames) { DestroyImmediate(curFrame); } this.frames.Clear(); foreach (GameObject curPrefab in this.voxelContainerPrefabs) { GameObject newObject = Instantiate(curPrefab); newObject.transform.parent = this.transform; newObject.SetActive(false); this.frames.Add(newObject); } } }
private Voxel AddVoxelAtPosition(Vector3 aPosition, VoxelContainer aVoxelContainer, MeshCollider aMeshCollider) { if (aVoxelContainer.voxels.ContainsKey(aPosition)) { return(aVoxelContainer.voxels[aPosition]); } Voxel newVoxel = new Voxel(); newVoxel.position = aPosition; newVoxel.SetContainer(aVoxelContainer); aVoxelContainer.AddVoxel(newVoxel); return(newVoxel); }
// Use this for initialization void Start() { this.container = this.gameObject.GetComponent <VoxelContainer>(); if (this.container == null) { Debug.LogError("VoxelPhysics need a voxelcontainer on the same gameobject to work."); } else { lock (this.container.voxels) { this.lastVoxelCount = container.voxels.Count; } } }
public override Mesh GenerateMesh(VoxelContainer data, IntVector3 start, IntVector3 end) { var verts = GenerateVertsFor(data, start, end); if (!verts.Any()) return null; var result = new Mesh() { vertices = verts.Select(v => v.Position).ToArray(), uv = verts.Select(v => v.Uv).ToArray() }; result.SetTriangles(GenerateIndicesFor(verts).ToArray(), 0); return result; }
public Voxel getSubVoxelAt(int layer, int columnID, string subID) { // v should be a voxel container for this to be a valid call to destroy subvoxel Voxel v = MapManager.manager.voxels[layer][columnID]; if (subID.ToCharArray()[0] == ',') { subID = subID.Substring(1); } int shatterLevel = subID.Split(',').Length - 1; for (int i = 0; i <= shatterLevel; i++) { if (v == null) { Debug.LogError("found null voxel looking for subvoxel: " + layer + "," + columnID + "," + subID + " ; failed at level: " + i); break; } VoxelContainer vc = v.gameObject.GetComponent <VoxelContainer>(); if (vc.subVoxels == null) { Debug.LogError("vox cont " + vc + " has a null subvoxels array"); return(null); } int id = -1; try { id = int.Parse(subID.Split(',')[i]); } catch (Exception e) { Debug.LogError("trying to parse " + subID + " index " + i + "into an int, which failed\t" + e.Message); return(null); } try { v = (Voxel)vc.subVoxels[id]; // TODO try catch, this isn't working every time } catch (Exception e) { Debug.LogError("trying to get subvoxel at " + subID + " from " + vc + " failed at shatterlevel " + i + " id = " + id + " num subvoxels = " + vc.subVoxels.Count + "\t" + e.Message); return(null); } } return(v); }
private void CheckVoxel(Vector3 aPosition, VoxelContainer aContainer, MeshCollider aCollider, Texture2D aObjectTexture) { //Physics.SphereCastAll(aPosition, 0.05f, adirection, Mathf.Infinity); for (int i = 0; i < 6; i++) { if (!this.CheckIfInnerPoint(aPosition, aCollider, StaticValues.sixDirectionArray[i])) { return; } } //Coord is inside Vector3 voxelPosition = this.RoundVector(aPosition); Color curColor = Color.white; float curDistance = -1; for (int i = 0; i < 6; i++) { Vector3 curDirection = StaticValues.sixDirectionArray[i]; RaycastHit[] hits = Physics.RaycastAll(aPosition + (curDirection * 10000f), -curDirection, Mathf.Infinity); foreach (RaycastHit hit in hits) { if (hit.collider == aCollider) { if ((curDistance == -1) || (curDistance > Vector3.Distance(voxelPosition, hit.point))) { curDistance = Vector3.Distance(voxelPosition, hit.point); if (aObjectTexture != null) { curColor = this.GetColorByTolerance(aObjectTexture.GetPixel((int)(hit.textureCoord.x * aObjectTexture.width), (int)(hit.textureCoord.y * aObjectTexture.height))); } } } } } if (!aContainer.voxels.ContainsKey(voxelPosition)) { voxelPosition = voxelPosition - aCollider.transform.position; voxelPosition = this.RoundVector(voxelPosition); Voxel newVoxel = this.AddVoxelAtPosition(voxelPosition, aContainer, aCollider); if (aObjectTexture != null) { newVoxel.color = curColor; } } }
public void Init(VoxelLayer aLayer, ParamForOptimizerThread aTextureParam, Vector3 aVectorX, Vector3 aVectorY, Vector3 aOffset, int aOptmalisationMinMergableVoxels, VoxelContainer aContainer) { vertices = new List <Vector3>(); uvs = new List <Vector2>(); triangles = new List <int>(); this.layer = aLayer; this.texture = aTextureParam.voxelTexture; this.vectorX = aVectorX; this.vectorY = aVectorY; this.offset = aOffset; this.optmalisationMinMergableVoxels = aOptmalisationMinMergableVoxels; this.ownerContainer = aContainer; this.textureWidth = aTextureParam.textureWidth; this.textureHeight = aTextureParam.textureHeight; // this.ownerContainer.PrepareTextureAndUVDictionary(true); }
internal void replaceSubVoxel(Voxel spawnedVox) { Voxel v = MapManager.manager.voxels[spawnedVox.layer][spawnedVox.columnID]; //v should be a voxel container for this to be a valid call to destroy subvoxel //Debug.Log("found top level container: " + v + " of type: " + v.GetType()); int shatterLevel = spawnedVox.subVoxelID.Split(',').Length - 1; VoxelContainer vc = null; for (int i = 1; i <= shatterLevel; i++) { vc = v.gameObject.GetComponent <VoxelContainer>(); //Debug.Log("opening container " + vc + " - " + vc.subVoxelID); v = (Voxel)vc.subVoxels[int.Parse(spawnedVox.subVoxelID.Split(',')[i])]; //Debug.Log("opening contained subVoxel " + v + " - " + v.subVoxelID); } vc.subVoxels[int.Parse(spawnedVox.subVoxelID.Split(',')[shatterLevel])] = spawnedVox; }
public Voxel getSubVoxelAt(int layer, int columnID, String subID) { // v should be a voxel container for this to be a valid call to destroy subvoxel Voxel v = voxels[layer][columnID]; if (!v.isContainer) { Debug.LogError("base voxel of given layer, col: " + layer + "," + columnID + " is not a container. cannot find id: " + subID); return(null); } int shatterLevel = subID.Split(',').Length - 1; if (subID.ToCharArray()[0] == ',') { subID = subID.Substring(1); } string[] ids = subID.Split(','); for (int i = 0; i <= ids.Length; i++) { if (v == null) { Debug.LogError("found null voxel looking for subvoxel: " + layer + "," + columnID + "," + subID + " ; failed at level: " + i); return(null); } VoxelContainer vc = v.gameObject.GetComponent <VoxelContainer>(); if (vc == null) { Debug.LogError("no voxel container comp attached to contained voxel: " + v.gameObject + " trying to get sub id: " + subID); } int id = -1; id = int.Parse(subID.Split(',')[i]); v = (Voxel)vc.subVoxels[id]; } return(v); }
public int?GetVoxel(int x, int y, int z) { int cx, cy, cz; Utils.CoordVoxelToChunk(x, y, z, out cx, out cy, out cz, ChunkSize); VoxelContainer vc = null; if (!VoxelContainer.Containers.TryGetValue(Utils.VoxelCoordToLong(cx, cy, cz), out vc)) { return(null); } int val; int vx, vy, vz; Utils.CoordChunkToVoxel(cx, cy, cz, out vx, out vy, out vz); if (vc.Voxels.TryGetValue(Utils.VoxelCoordToLong(x - vx, y - vy, z - vz), out val)) { return(val); } return(null); }
private void addVoxelContainer(Voxel v) { VoxelContainer vc = v.GetComponent <VoxelContainer>(); if (vc != null) { foreach (Voxel subVox in vc.subVoxels) { if (subVox.isContainer) { addVoxelContainer(subVox); } else { addVoxel(subVox); } } } else { Debug.LogError("no voxel container attached to voxel (" + v.gameObject + ") with isContainer = " + v.isContainer); } }
private Texture2D GetTexture() { //handling input errors if (sourceTexture == null) { EditorUtility.DisplayDialog("Error", "Please set the source texture before convert.", "Ok"); return(null); } //Reimport the texture if it is not readable Texture2D curTexture = this.sourceTexture; try { curTexture.GetPixel(0, 0); } catch { Debug.Log("Reimporting texture, because it is not readable."); curTexture = VoxelContainer.ReImportTexture(this.sourceTexture); } return(curTexture); }
private void ExportObjectToVoxFile(string aFilename) { GameObject tempGameObject = new GameObject(); VoxelContainer voxelContainer = tempGameObject.AddComponent <VoxelContainer>(); try { List <VoxelContainer> containers = new List <VoxelContainer>(); VoxelContainer rootContainer = this.voxelObject.GetComponent <VoxelContainer>(); if (this.exportChildObjects) { containers.AddRange(this.voxelObject.transform.GetComponentsInChildren <VoxelContainer>()); } else { if (rootContainer != null) { containers.Add(rootContainer); } } foreach (VoxelContainer curContainer in containers) { foreach (Voxel curVoxel in curContainer.voxels.Values) { Voxel newVoxel = new Voxel(); newVoxel.color = curVoxel.color; //Transform the positions into the same matrix newVoxel.position = this.voxelObject.transform.InverseTransformPoint(curContainer.gameObject.transform.TransformPoint(curVoxel.position)); voxelContainer.AddVoxel(newVoxel, false); } } if (voxelContainer.voxels.Count == 0) { Debug.LogError("Vox Export: Did not found voxels or voxelContainer in the structure! Please make sure you selected an object with voxelcontainer"); return; } if (Path.GetExtension(aFilename).ToUpper() != ".vox".ToUpper()) { Debug.LogError("Extension must be .vox"); return; } BinaryWriter bw = new BinaryWriter(File.OpenWrite(aFilename)); try { char[] magicalString = "VOX ".ToCharArray(); bw.Write(magicalString); int fileVersion = 150; bw.Write(fileVersion); //Main chunk //Chunk header char[] mainChunk = "MAIN".ToCharArray(); bw.Write(mainChunk); int chunkSize = 0; //3*4bytes bw.Write(chunkSize); int childChunks = (3 * 12) + 12 + (voxelContainer.voxels.Count * 4) + 4 + (256 * 4); //3 chunk header + size values + voxels values + voxelnumbers + color palette bw.Write(childChunks); //Size chunk //Chunk header char[] sizeChunk = "SIZE".ToCharArray(); bw.Write(sizeChunk); chunkSize = 3 * 4;//3*4bytes bw.Write(chunkSize); childChunks = 0; bw.Write(childChunks); //Chunk data Vector3 sizeVector = voxelContainer.GetMaxContainerVector() - voxelContainer.GetMinContainerVector(); int size = (int)sizeVector.x; bw.Write(size); //x size = (int)sizeVector.z; bw.Write(size); //y size = (int)sizeVector.y; bw.Write(size); //z //XYZI chunk //Chunk header char[] XYZIChunk = "XYZI".ToCharArray(); bw.Write(XYZIChunk); chunkSize = 4 * voxelContainer.voxels.Count + 4;//the Voxel's preferences are stored on 4 bytes bw.Write(chunkSize); childChunks = 0; bw.Write(childChunks); List <Color> colorPalette = voxelContainer.GetColorPalette(); if (colorPalette.Count > 255) { Debug.LogError("Export Failed: MagicaVoxel does not support more then 255 colors."); return; } //Prepare Transform Vector //We need it because, it looks like MagicaVoxel drops everything under 0 Vector3 transFormVector = Vector3.zero; Vector3 minVector = voxelContainer.GetMinContainerVector(); if (minVector.x < 0) { transFormVector.x = minVector.x * -1f; } if (minVector.y < 0) { transFormVector.y = minVector.y * -1f; } if (minVector.z < 0) { transFormVector.z = minVector.z * -1f; } //Chunk Data int voxelNumber = voxelContainer.voxels.Count; bw.Write(voxelNumber); foreach (Voxel curVoxel in voxelContainer.voxels.Values) { Vector3 voxelPos = curVoxel.position + transFormVector; byte coord = (byte)voxelPos.x; bw.Write(coord); coord = (byte)voxelPos.z; bw.Write(coord); coord = (byte)voxelPos.y; bw.Write(coord); byte colorIndex = (byte)(colorPalette.IndexOf(curVoxel.color) + 1); bw.Write(colorIndex); } //RGBA chunk //Chunk header char[] RGBAChunk = "RGBA".ToCharArray(); bw.Write(RGBAChunk); chunkSize = 4 * 256;//Colors are stored in bytes bw.Write(chunkSize); childChunks = 0; bw.Write(childChunks); //Color data for (int j = 0; j < colorPalette.Count; j++) { byte colorR = (byte)(colorPalette[j].r * 255); bw.Write(colorR); byte colorG = (byte)(colorPalette[j].g * 255); bw.Write(colorG); byte colorB = (byte)(colorPalette[j].b * 255); bw.Write(colorB); byte colorA = (byte)(colorPalette[j].a * 255); bw.Write(colorA); } if (colorPalette.Count < 256) { //Fill update the color palette to 255 for (int j = colorPalette.Count; j < 256; j++) { for (int k = 0; k < 4; k++) { byte color = 255; bw.Write(color); } } } } finally { bw.Flush(); bw.Close(); } } finally { DestroyImmediate(tempGameObject); } }
private void ImportAssetOptionsQEObject(string aFilename) { if (Path.GetExtension(aFilename).ToUpper() != ".qb".ToUpper()) { Debug.LogError("Extension must be .qb"); return; } //Consts uint CODEFLAG = 2; uint NEXTSLICEFLAG = 6; //Parent Gameobject GameObject parentGameObject = new GameObject(); parentGameObject.name = Path.GetFileNameWithoutExtension(aFilename); BinaryReader br = new BinaryReader(File.Open(aFilename, FileMode.Open)); try { if (br == null) { Debug.Log("VoxelMax: Could not open file. Filename: " + aFilename); return; } uint fileVersion = br.ReadUInt32(); uint colorFormat = br.ReadUInt32(); uint zAxisOrientation = br.ReadUInt32(); uint compressed = br.ReadUInt32(); uint visibilityMaskEncoded = br.ReadUInt32(); uint numMatrices = br.ReadUInt32(); Debug.Log("Qubicle File Import Info\r\n" + "File Version: " + fileVersion + "\r\n" + "Color Format: " + colorFormat + "\r\n" + "zAxisOrientation: " + zAxisOrientation + "\r\n" + "visibilityMaskEncoded: " + visibilityMaskEncoded + "\r\n" + "Object Count: " + numMatrices); for (uint i = 0; i < numMatrices; i++) { // read matrix name byte nameLength = br.ReadByte(); string matrixName = new string(br.ReadChars(nameLength)); GameObject newGameObject = new GameObject(); newGameObject.transform.parent = parentGameObject.transform; newGameObject.name = matrixName; VoxelContainer newVoxelContainer = newGameObject.AddComponent <VoxelContainer>(); // read matrix size uint sizeX = br.ReadUInt32(); uint sizeY = br.ReadUInt32(); uint sizeZ = br.ReadUInt32(); // read matrix position (in this example the position is irrelevant) int posX = br.ReadInt32(); int posY = br.ReadInt32(); int posZ = br.ReadInt32(); newGameObject.transform.position = new Vector3(posX, posY, posZ); if (compressed == 0) // if uncompressd { for (uint z = 0; z < sizeZ; z++) { for (uint y = 0; y < sizeY; y++) { for (uint x = 0; x < sizeX; x++) { uint curColor = br.ReadUInt32(); if (curColor != 0) { Voxel newVoxel = new Voxel(); newVoxel.position = new Vector3(x, y, z); newVoxel.color = this.UIntToColor(curColor); newVoxelContainer.AddVoxel(newVoxel, false); } } } } } else // if compressed { uint z = 0; while (z < sizeZ) { z++; uint index = 0; while (true) { uint data = br.ReadUInt32(); if (data == NEXTSLICEFLAG) { break; } else if (data == CODEFLAG) { uint count = br.ReadUInt32(); data = br.ReadUInt32(); for (uint j = 0; j < count; j++) { uint x = index % sizeX + 1; // mod = modulo e.g. 12 mod 8 = 4 uint y = index / sizeX + 1; // div = integer division e.g. 12 div 8 = 1 index++; if (data != 0) { Voxel newVoxel = new Voxel(); newVoxel.position = new Vector3(x, y, z); newVoxel.color = this.UIntToColor(data); newVoxelContainer.AddVoxel(newVoxel, false); } } } else { uint x = index % sizeX + 1; uint y = index / sizeX + 1; index++; if (data != 0) { Voxel newVoxel = new Voxel(); newVoxel.position = new Vector3(x, y, z); newVoxel.color = this.UIntToColor(data); newVoxelContainer.AddVoxel(newVoxel, false); } } } } } newVoxelContainer.UpdateStructure(); newVoxelContainer.BuildMesh(true, true, true, true); } } finally { br.Close(); } }
private GameObject ConvertObject(GameObject aObject) { if (aObject == null) { return(null); } GameObject newVoxelObject = new GameObject(); newVoxelObject.name = aObject.name + "_Converted"; if (this.isRecursive) { //I do this because the child list always change because //I have to removed the child while I convert it since //the mesh collider does not look to be workin as a child for me. //Reach out for me if you have better idea :) List <Transform> childList = new List <Transform>(); for (int i = 0; i < aObject.transform.childCount; i++) { childList.Add(aObject.transform.GetChild(i)); } for (int i = 0; i < childList.Count; i++) { GameObject newChild = this.ConvertObject(childList[i].gameObject); if (newChild != null) { newChild.transform.parent = newVoxelObject.transform; newChild.transform.localPosition = childList[i].localPosition; } } } MeshCollider meshcollider = aObject.GetComponent <MeshCollider>(); if (meshcollider == null) { UnityEngine.Debug.LogError("VoxelMax: Source Object need meshcollider to be converted!"); return(newVoxelObject); } EditorUtility.ClearProgressBar(); EditorUtility.DisplayCancelableProgressBar("Building Voxel Matrix", "Building", 0f); //Clear colorpalette this.colorPalette = null; this.colorPalette = new List <Color>(); VoxelContainer voxelContainer = newVoxelObject.AddComponent <VoxelContainer>(); try { //Get Texture Texture2D objectTexture = null; Renderer objRenderer = aObject.GetComponent <Renderer>(); if (objRenderer != null) { if (objRenderer.sharedMaterial != null) { objectTexture = (Texture2D)objRenderer.sharedMaterial.mainTexture; if (objectTexture != null) { try { objectTexture.GetPixel(0, 0); } catch { UnityEngine.Debug.Log("Reimporting texture, because it is not readable."); objectTexture = VoxelContainer.ReImportTexture(objectTexture); } } } } Transform originalParent = aObject.transform.parent; aObject.transform.parent = null; float maxStepCount = (meshcollider.bounds.max.x - meshcollider.bounds.min.x + 2) * (meshcollider.bounds.max.y - meshcollider.bounds.min.y + 2) * (meshcollider.bounds.max.z - meshcollider.bounds.min.z + 2); float eachStep = (meshcollider.bounds.max.y - meshcollider.bounds.min.y + 2) * (meshcollider.bounds.max.z - meshcollider.bounds.min.z + 2); for (float x = (int)(meshcollider.bounds.min.x - 1f); x <= meshcollider.bounds.max.x + 1f; x += 1f) { for (float y = (int)(meshcollider.bounds.min.y - 1f); y <= meshcollider.bounds.max.y + 1f; y += 1f) { for (float z = (int)(meshcollider.bounds.min.z - 1f); z <= meshcollider.bounds.max.z + 1f; z += 1f) { Vector3 shootOrigin = new Vector3(x, y, z); if (this.selectedAlgorithm == ConvertAlgorithm.RayBased) { for (int k = 0; k < 6; k++) { this.ShootArray(shootOrigin, StaticValues.sixDirectionArray[k], voxelContainer, meshcollider, objectTexture); } } else { this.CheckVoxel(shootOrigin, voxelContainer, meshcollider, objectTexture); } } } if (EditorUtility.DisplayCancelableProgressBar("Building Voxel Matrix", "Building", (eachStep * x) / maxStepCount)) { EditorUtility.ClearProgressBar(); return(null); } } aObject.transform.parent = originalParent; } finally { EditorUtility.ClearProgressBar(); } // if (this.selectedAlgorithm == ConvertAlgorithm.RayBased) // voxelContainer.FillUpObject(); voxelContainer.BuildMesh(true, true, true, true); if (SceneView.lastActiveSceneView != null) { UnityEditor.Selection.activeGameObject = newVoxelObject; SceneView.lastActiveSceneView.pivot = newVoxelObject.transform.position; SceneView.lastActiveSceneView.Repaint(); } return(newVoxelObject); }
// Update is called once per frame void Update() { if ((triggered) && (!this.exploded)) { this.exploded = true; //Get the root object rootObjectForParticles = GameObject.Find("VoxelMaxExplosionRoot"); if (rootObjectForParticles == null) { rootObjectForParticles = new GameObject(); rootObjectForParticles.name = "VoxelMaxExplosionRoot"; } Collider[] colliderList = Physics.OverlapSphere(this.gameObject.transform.position, this.explosionRadius); foreach (Collider curCollider in colliderList) { if (curCollider.gameObject.tag == "Indestructible") { continue; } VoxelContainer voxelContainer = curCollider.gameObject.GetComponent <VoxelContainer>(); if (voxelContainer != null) { Vector3 torqueVector = new Vector3(Random.Range(0f, 1f), Random.Range(0f, 1f), Random.Range(0f, 1f)) * this.explosionForce; Vector3 voxelPoint = voxelContainer.gameObject.transform.InverseTransformPoint(this.gameObject.transform.position); List <Voxel> voxelsToRemove = new List <Voxel>(); Vector3 transformedDistance = voxelContainer.gameObject.transform.InverseTransformVector(explosionRadius, 0f, 0f); List <Voxel> voxelList; lock (voxelContainer.voxels) { voxelList = new List <Voxel>(voxelContainer.voxels.Values); } foreach (Voxel curVoxel in voxelList) { float voxDistance = Vector3.Distance(curVoxel.position, voxelPoint); if (voxDistance <= transformedDistance.magnitude) { voxelsToRemove.Add(curVoxel); } } //Do not instantiate every voxel on large explosions to prevent frame drop int particleStepper = 0; if (maxParticleCount != 0) { particleStepper = Mathf.Max((int)(voxelsToRemove.Count / this.maxParticleCount), 1); } for (int i = 0; i < voxelsToRemove.Count; i++) { Voxel curVoxel = voxelsToRemove[i]; if ((particleStepper != 0) && ((i % particleStepper) == 0)) { if (this.explosionParticle != null) { GameObject newObject = Instantiate(this.explosionParticle); newObject.transform.parent = rootObjectForParticles.transform; newObject.transform.localScale = voxelContainer.gameObject.transform.localScale; newObject.transform.position = voxelContainer.gameObject.transform.TransformPoint(curVoxel.position); Renderer curRenderer = newObject.GetComponent <Renderer>(); if (curRenderer != null) { if (curRenderer.material != null) { curRenderer.material.color = curVoxel.color; } } Rigidbody curRigidBody = newObject.GetComponent <Rigidbody>(); if (curRigidBody != null) { curRigidBody.AddForce(voxelContainer.gameObject.transform.TransformDirection(curVoxel.position - voxelPoint).normalized *explosionForce); curRigidBody.AddRelativeTorque(torqueVector); } } } } voxelContainer.AddBuildTaskRemovedVoxels(voxelsToRemove); VoxelPhysics vPhysics = this.GetComponent <VoxelPhysics>(); if ((vPhysics != null) && (vPhysics.enabled)) { voxelContainer.rebuildCollider = false; } //Modification for Will if (objectToInstantiate != null) { GameObject newGameObject = Instantiate <GameObject>(this.objectToInstantiate); newGameObject.transform.position = this.gameObject.transform.position; newGameObject.transform.parent = rootObjectForParticles.transform; } } else { Rigidbody curRigidBody = curCollider.gameObject.GetComponent <Rigidbody>(); if (curRigidBody != null) { Vector3 torqueVector = new Vector3(Random.Range(0f, 1f), Random.Range(0f, 1f), Random.Range(0f, 1f)) * this.explosionForce; Vector3 voxelPoint = curCollider.gameObject.transform.InverseTransformPoint(this.gameObject.transform.position); curRigidBody.AddForce(curCollider.gameObject.transform.TransformDirection(voxelPoint - this.gameObject.transform.position).normalized *explosionForce); curRigidBody.AddRelativeTorque(torqueVector); } } } Destroy(this.gameObject); } }
public VoxelArea(Vector3 aPosition, VoxelContainer aContainer) { this.position = aPosition; this.container = aContainer; }
private void LoadVoxFile(string aFileName) { //I dissabled compiler warning, because we want to load some values from the file even if we would not use it later. //I think it is cleaner this way #pragma warning disable //Prepare Object GameObject newGameObject = new GameObject(); newGameObject.name = "ImportedFromMagicaVoxel"; VoxelContainer newVoxelContainer = newGameObject.AddComponent <VoxelContainer>(); //Open File BinaryReader br = new BinaryReader(File.OpenRead(aFileName)); string magic = new string(br.ReadChars(4)); int version = br.ReadInt32(); if (magic == "VOX ") { int sizex = 0, sizey = 0, sizez = 0; Color[] colors = null; MagicaVoxelData[] voxelData = null; while (br.BaseStream.Position < br.BaseStream.Length) { char[] chunkId = br.ReadChars(4); int chunkSize = br.ReadInt32(); int childChunks = br.ReadInt32(); string chunkName = new string(chunkId); if (chunkName == "SIZE") { sizex = br.ReadInt32(); sizey = br.ReadInt32(); sizez = br.ReadInt32(); br.ReadBytes(chunkSize - 4 * 3); } else if (chunkName == "XYZI") { int numVoxels = br.ReadInt32(); voxelData = new MagicaVoxelData[numVoxels]; for (int i = 0; i < voxelData.Length; i++) { voxelData[i] = new MagicaVoxelData(br); } } else if (chunkName == "RGBA") { colors = new Color[256]; for (int i = 0; i < 256; i++) { byte r = br.ReadByte(); byte g = br.ReadByte(); byte b = br.ReadByte(); byte a = br.ReadByte(); colors[i].r = r / 255f; colors[i].g = g / 255f; colors[i].b = b / 255f; colors[i].a = a / 255f; } } else { br.ReadBytes(chunkSize); } } if ((voxelData == null) || (voxelData.Length == 0)) { return; } for (int i = 0; i < voxelData.Length; i++) { Vector3 position = new Vector3(voxelData[i].x, voxelData[i].z, voxelData[i].y); if (!newVoxelContainer.voxels.ContainsKey(position)) { Voxel newVoxel = new Voxel(); newVoxel.position = position; newVoxel.color = (colors == null ? UShortToColor(voxColors[voxelData[i].color - 1]) : colors[voxelData[i].color - 1]); newVoxelContainer.AddVoxel(newVoxel, false); } } newVoxelContainer.UpdateStructure(); newVoxelContainer.BuildMesh(true, true, true, true); } else { Debug.LogError("Error durring vox import. Probably this is not a .vox file."); return; } #pragma warning restore }
public void DoObjectCreation() { this.currentState = PhysicsState.ObjectCreation; if (showDebugMessages) { Debug.Log("VoxelMax Physics: Object creation update"); } if (this.physicsAggregatedList == null) { if (showDebugMessages) { Debug.Log("VoxelMax Physics: No fragmented object to create"); } this.currentState = PhysicsState.WaitingForTask; return; } if (this.physicsAggregatedList.Count > 1) { //Prepare GameObjectList because it can be only done in the main thread List <GameObject> newGameObjectList = new List <GameObject>(); List <VoxelContainer> newContainerList = new List <VoxelContainer>(); for (int i = 0; i < this.physicsAggregatedList.Count - 1; i++) { GameObject newGameObject = new GameObject(); newGameObject.transform.parent = this.transform; VoxelContainer newContainer = newGameObject.AddComponent <VoxelContainer>(); newContainer.enabled = false; newContainer.modelFilename = this.container.modelFilename; newContainer.modelName = this.container.modelName; newContainer.textureFilename = this.container.textureFilename; //newContainer.AssignUVDictionary(this.container); newContainerList.Add(newContainer); this.fragmentContainers.Add(newContainer); MeshRenderer meshRenderer = newGameObject.AddComponent <MeshRenderer>(); Rigidbody rigidBody = newGameObject.AddComponent <Rigidbody>(); newContainer.enabled = false; meshRenderer.enabled = false; rigidBody.useGravity = false; newGameObject.transform.localScale = new Vector3(1f, 1f, 1f); newGameObject.transform.rotation = this.gameObject.transform.rotation; newGameObject.transform.position = this.gameObject.transform.position; //Add physics to fragments VoxelPhysics newVoxelPhysics = newGameObject.AddComponent <VoxelPhysics>(); newVoxelPhysics.tensionCalculation = this.tensionCalculation; newVoxelPhysics.layerWidthBreakPoint = this.layerWidthBreakPoint; newVoxelPhysics.enabled = false; newGameObject.GetComponent <Renderer>().sharedMaterial = this.gameObject.GetComponent <MeshRenderer>().sharedMaterial; newGameObjectList.Add(newGameObject); } // this.gameObject.GetComponent<MeshCollider>().enabled = false; if (this.gameObject.GetComponent <Rigidbody>() != null) { this.gameObject.GetComponent <Rigidbody>().useGravity = false; } this.physicsBuildTask = new PhysicsBuildTask(newGameObjectList, this.physicsAggregatedList, newContainerList); this.DoMoveDataToObjects(); } else { if (this.physicsAggregatedList.Count == 1) { if (this.gameObject.GetComponent <Rigidbody>() == null) { // Rigidbody curRigidBody = this.gameObject.AddComponent<Rigidbody>(); // curRigidBody.mass = this.container.voxels.Count; } MeshCollider meshCollider = this.gameObject.GetComponent <MeshCollider>(); if (meshCollider != null) { Destroy(meshCollider); } this.physicsBuildTask = new PhysicsBuildTask(null, this.physicsAggregatedList, null); this.DoMoveDataToObjects(); } } }
private void MoveAggregatedVoxelsIntoNewContainers(object aBuildTask) { PhysicsBuildTask buildTask = (PhysicsBuildTask)aBuildTask; int gameObjectIndex = 0; try { if (buildTask.physicsAggregatedList != null) { while (buildTask.physicsAggregatedList.Count > 1) { int smallestIndex = 0; VoxelContainer newContainer = buildTask.voxelContainerList[gameObjectIndex]; newContainer.AssignUVDictionary(this.container); foreach (Voxel curVoxel in buildTask.physicsAggregatedList[smallestIndex]) { newContainer.AddVoxel(curVoxel, true); lock (this.container.voxels) { this.container.RemoveVoxel(curVoxel, true); } } Texture2D curTexture = null; int curTextureWidth = 0; int curTextureHeight = 0; foreach (VoxelArea curArea in this.container.voxelAreas.Values) { curTexture = curArea.GetTexture(); curTextureWidth = curArea.GetTextureWidth(); curTextureHeight = curArea.GetTextureHeight(); if (curTexture != null) { break; } } foreach (VoxelArea curArea in newContainer.voxelAreas.Values) { curArea.SetTexture(curTexture, curTextureWidth, curTextureHeight); } foreach (VoxelArea curArea in newContainer.voxelAreas.Values) { curArea.SetTexture(curTexture, curTextureWidth, curTextureHeight); } newContainer.GenerateAreaBuffers(); newContainer.rebuildCollider = false; List <VoxelContainer.ColliderDescriptor> colliders = newContainer.PrepareColliderDescriptors(); buildTask.colliders.Add(colliders); gameObjectIndex++; buildTask.physicsAggregatedList.RemoveAt(smallestIndex); } buildTask.mainBodyCollider = this.container.PrepareColliderDescriptors(); lock (this.container.voxels) { this.container.rebuildCollider = false; this.container.GenerateAreaBuffers(); this.container.mustRebuildBeforeUpdate = false; this.container.ingameBuildTask = null; } this.currentState = PhysicsState.Finalisation; buildTask.isReady = true; } } catch (Exception e) { Debug.LogError("VoxelPhysics error: " + e.Message); } }
private void ExportObjectToQBFile(string aFilename) { List <VoxelContainer> containers = new List <VoxelContainer>(); VoxelContainer rootContainer = this.voxelObject.GetComponent <VoxelContainer>(); if (this.exportChildObjects) { containers.AddRange(this.voxelObject.transform.GetComponentsInChildren <VoxelContainer>()); } else { if (rootContainer != null) { containers.Add(rootContainer); } } if (containers.Count == 0) { Debug.LogError("QB Export: Did not found voxelContainer in the structure! Please make sure you selected an object with voxelcontainer"); return; } if (Path.GetExtension(aFilename).ToUpper() != ".qb".ToUpper()) { Debug.LogError("Extension must be .qb"); return; } BinaryWriter bw = new BinaryWriter(File.OpenWrite(aFilename)); try { //Header uint version = 257; bw.Write(version); uint colorFormat = 0;//RGBA bw.Write(colorFormat); uint zAxisOrientation = 0; bw.Write(zAxisOrientation); uint compression = 0; //Not compressed bw.Write(compression); uint visibilityMask = 0; //Not encoded bw.Write(visibilityMask); uint matrixNumber = (uint)containers.Count; bw.Write(matrixNumber); for (int i = 0; i < matrixNumber; i++) { VoxelContainer curContainer = containers[i]; //Data string matrixName = curContainer.name; byte nameLength = (byte)matrixName.Length; bw.Write(nameLength); char[] charArrayOfName = matrixName.ToCharArray(); bw.Write(charArrayOfName); Vector3 minVector = curContainer.GetMinContainerVector(); Vector3 maxVector = curContainer.GetMaxContainerVector(); uint sizeX = (uint)(maxVector.x - minVector.x + 1); uint sizeY = (uint)(maxVector.y - minVector.y + 1); uint sizeZ = (uint)(maxVector.z - minVector.z + 1); bw.Write(sizeX); bw.Write(sizeY); bw.Write(sizeZ); // int posx = (int)(curContainer.transform.position.x + minVector.x); int posy = (int)(curContainer.transform.position.y + minVector.y); int posz = (int)(curContainer.transform.position.z + minVector.z); bw.Write(posx); bw.Write(posy); bw.Write(posz); for (int z = (int)minVector.z; z <= maxVector.z; z++) { for (int y = (int)minVector.y; y <= maxVector.y; y++) { for (int x = (int)minVector.x; x <= maxVector.x; x++) { Vector3 curPosition = new Vector3(x, y, z); if (curContainer.voxels.ContainsKey(curPosition)) { uint voxelColor = this.ColorToUInt(curContainer.voxels[curPosition].color); bw.Write(voxelColor); } else { uint noVoxel = 0; bw.Write(noVoxel); } } } } } Debug.Log("Export Finished"); }finally { bw.Flush(); bw.Close(); } }
public void SetContainer(VoxelContainer aVoxelContainer) { this.voxelContainer = aVoxelContainer; this.selectionList = null; }