public NPVoxFaces Clone() { NPVoxFaces clone = new NPVoxFaces( ); clone.Left = Left; clone.Right = Right; clone.Up = Up; clone.Down = Down; clone.Forward = Forward; clone.Back = Back; return(clone); }
public NPVoxFaces GetIncludedFaces() { NPVoxFaces sides = new NPVoxFaces(); NPVoxMeshOutput meshOutput = InputMeshFactory; if (meshOutput != null) { // sides.Back = (sbyte)((meshOutput.Loop.Back == 0 && meshOutput.Include.Back != 0) ? 1 : 0); // sides.Forward = (sbyte)((meshOutput.Loop.Forward == 0 && meshOutput.Include.Forward != 0) ? 1 : 0); // sides.Left = (sbyte)((meshOutput.Loop.Left == 0 && meshOutput.Include.Left != 0) ? 1 : 0); // sides.Right = (sbyte)((meshOutput.Loop.Right == 0 && meshOutput.Include.Right != 0) ? 1 : 0); // sides.Up = (sbyte)((meshOutput.Loop.Up == 0 && meshOutput.Include.Up != 0) ? 1 : 0); // sides.Down = (sbyte)((meshOutput.Loop.Down == 0 && meshOutput.Include.Down != 0) ? 1 : 0); sides.Back = (sbyte)((meshOutput.Cutout.Back <= 0 && meshOutput.Loop.Back == 0 && meshOutput.Include.Back != 0) ? 1 : 0); sides.Forward = (sbyte)((!Baked45Angle && meshOutput.Cutout.Forward <= 0 && meshOutput.Loop.Forward == 0 && meshOutput.Include.Forward != 0) ? 1 : 0); sides.Left = (sbyte)((!Baked45Angle && meshOutput.Cutout.Left <= 0 && meshOutput.Loop.Left == 0 && meshOutput.Include.Left != 0) ? 1 : 0); sides.Right = (sbyte)((!Baked45Angle && meshOutput.Cutout.Right <= 0 && meshOutput.Loop.Right == 0 && meshOutput.Include.Right != 0) ? 1 : 0); sides.Up = (sbyte)((!Baked45Angle && meshOutput.Cutout.Up <= 0 && meshOutput.Loop.Up == 0 && meshOutput.Include.Up != 0) ? 1 : 0); sides.Down = (sbyte)((meshOutput.Cutout.Down <= 0 && meshOutput.Loop.Down == 0 && meshOutput.Include.Down != 0) ? 1 : 0); } return(sides); }
public NPVoxCoord LoopCoord(NPVoxCoord coord, NPVoxFaces loop) { if (loop.Right != 0) { if (loop.Right < 0 && coord.X >= SizeX) { coord.X = (sbyte)(coord.X + loop.Right); } coord.X = (sbyte)(coord.X % SizeX); } if (loop.Left != 0) { if (loop.Left < 0 && coord.X < 0) { coord.X = (sbyte)(coord.X - loop.Left); } while (coord.X < 0) { coord.X += SizeX; } } if (loop.Up != 0) { if (loop.Up < 0 && coord.Y >= SizeY) { coord.Y = (sbyte)(coord.Y + loop.Up); } coord.Y = (sbyte)(coord.Y % SizeY); } if (loop.Down != 0) { if (loop.Down < 0 && coord.Y < 0) { coord.Y = (sbyte)(coord.Y - loop.Down); } while (coord.Y < 0) { coord.Y += SizeY; } } if (loop.Forward != 0) { if (loop.Forward < 0 && coord.Z >= SizeZ) { coord.Z = (sbyte)(coord.Z + loop.Forward); } coord.Z = (sbyte)(coord.Z % SizeZ); } if (loop.Back != 0) { if (loop.Back < 0 && coord.Z < 0) { coord.Z = (sbyte)(coord.Z - loop.Back); } while (coord.Z < 0) { coord.Z += SizeZ; } } return(coord); }
public static NPVoxModel CreateFlippedModel(NPVoxModel source, NPVoxCoord xFlip, NPVoxCoord yFlip, NPVoxCoord zFlip, NPVoxModel reuse = null) { sbyte sizeX = (sbyte)(xFlip.X * source.SizeX + xFlip.Z * source.SizeZ + xFlip.Y * source.SizeY); sbyte sizeY = (sbyte)(yFlip.X * source.SizeX + yFlip.Z * source.SizeZ + yFlip.Y * source.SizeY); sbyte sizeZ = (sbyte)(zFlip.X * source.SizeX + zFlip.Z * source.SizeZ + zFlip.Y * source.SizeY); NPVoxModel model = NPVoxModel.NewInstance(source, new NPVoxCoord( (sbyte)Mathf.Abs(sizeX), (sbyte)Mathf.Abs(sizeY), (sbyte)Mathf.Abs(sizeZ) ), reuse); sbyte xOffset = 0; if (sizeX < 0) { xOffset = (sbyte)((sizeX - 1)); } sbyte yOffset = 0; if (sizeY < 0) { yOffset = (sbyte)((sizeY - 1)); } sbyte zOffset = 0; if (sizeZ < 0) { zOffset = (sbyte)((sizeZ - 1)); } NPVoxFaces allFaces = new NPVoxFaces(); allFaces.Back = 1; allFaces.Forward = 1; allFaces.Left = 1; allFaces.Right = 1; allFaces.Up = 1; allFaces.Down = 1; bool hasVoxelGroups = source.HasVoxelGroups(); if (hasVoxelGroups) { model.InitVoxelGroups(); } model.NumVoxelGroups = source.NumVoxelGroups; model.Colortable = source.Colortable; model.NumVoxels = source.NumVoxels; // Transform Coordinates foreach (NPVoxCoord sourceCoord in source.Enumerate()) { NPVoxCoord coord = new NPVoxCoord( (sbyte)(xOffset + (xFlip.X * sourceCoord.X + xFlip.Z * sourceCoord.Z + xFlip.Y * sourceCoord.Y)), (sbyte)(yOffset + (yFlip.X * sourceCoord.X + yFlip.Z * sourceCoord.Z + yFlip.Y * sourceCoord.Y)), (sbyte)(zOffset + (zFlip.X * sourceCoord.X + zFlip.Z * sourceCoord.Z + zFlip.Y * sourceCoord.Y)) ); coord = model.LoopCoord(coord, allFaces); model.SetVoxel(coord, source.GetVoxel(sourceCoord)); if (hasVoxelGroups) { model.SetVoxelGroup(coord, source.GetVoxelGroup(sourceCoord)); } } // Transform Sockets // Matrix4x4 t = Matrix4x4.identity; // if (xFlip.X != 0) t = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(xFlip.X, 1, 1)); // if (xFlip.Y != 0) t *= Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(1, xFlip.Y, 1)); // if (xFlip.Z != 0) t *= Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(1, 1, xFlip.Z)); NPVoxSocket[] sockets = new NPVoxSocket[source.Sockets.Length]; for (int i = 0; i < sockets.Length; i++) { // Anchor NPVoxCoord sourceCoord = source.Sockets[i].Anchor; NPVoxCoord anchorCoord = new NPVoxCoord( (sbyte)(xOffset + (xFlip.X * sourceCoord.X + xFlip.Z * sourceCoord.Z + xFlip.Y * sourceCoord.Y)), (sbyte)(yOffset + (yFlip.X * sourceCoord.X + yFlip.Z * sourceCoord.Z + yFlip.Y * sourceCoord.Y)), (sbyte)(zOffset + (zFlip.X * sourceCoord.X + zFlip.Z * sourceCoord.Z + zFlip.Y * sourceCoord.Y)) ); anchorCoord = model.LoopCoord(anchorCoord, allFaces); sockets[i].Name = source.Sockets[i].Name; sockets[i].Anchor = anchorCoord; // transform Quaternion Quaternion rotation = Quaternion.Euler(source.Sockets[i].EulerAngles); Vector3 anchorRight = rotation * Vector3.right; Vector3 anchorUp = rotation * Vector3.up; Vector3 anchorForward = rotation * Vector3.forward; Vector3 newRight = anchorRight; Vector3 newUp = anchorUp; Vector3 newForward = anchorForward; if (xFlip.X < 0) { newRight.Scale(new Vector3(-1f, 1f, 1f)); newUp.Scale(new Vector3(-1f, 1f, 1f)); newForward.Scale(new Vector3(-1f, 1f, 1f)); Quaternion q = Quaternion.LookRotation(newForward, newUp); sockets[i].EulerAngles = q.eulerAngles; } // TODO: other mirrors not yet supported } model.Sockets = sockets; model.name = "zzz Flipped Model"; return(model); }
override protected Mesh CreateProduct(Mesh mesh = null) { // Debug.Log("create product"); NPVoxMeshOutput meshOutput = (Input as NPVoxMeshOutput); if (meshOutput && meshOutput.GetProduct() && TextureAtlas) { TextureAtlas.GetMaterial(SourceMaterial); NPVoxFaces includedFaces = GetIncludedFaces(); NPVoxToUnity npVoxToUnity = InputMeshFactory.GetNPVoxToUnity(); int faceCount = GetFaceCount(); NPVoxBox originalBox = InputMeshFactory.GetVoxModel().BoundingBox; NPVoxBox cutoutBox = originalBox.Clone(); NPVoxFaces cutout = InputMeshFactory.Cutout; Vector3 cutoutOffset = Vector3.zero; if (cutout != null) { Vector3 originalCenter = cutoutBox.SaveCenter; cutoutBox.Left = (sbyte)Mathf.Abs(cutout.Left); cutoutBox.Down = (sbyte)Mathf.Abs(cutout.Down); cutoutBox.Back = (sbyte)Mathf.Abs(cutout.Back); cutoutBox.Right = (sbyte)(cutoutBox.Right - (sbyte)Mathf.Abs(cutout.Right)); cutoutBox.Up = (sbyte)(cutoutBox.Up - (sbyte)Mathf.Abs(cutout.Up)); cutoutBox.Forward = (sbyte)(cutoutBox.Forward - (sbyte)Mathf.Abs(cutout.Forward)); cutoutOffset = Vector3.Scale(originalCenter - cutoutBox.SaveCenter, InputMeshFactory.VoxelSize); } // we have to be careful. Unlike cutout, which is already removed from the mesh we want to render, the inset is not yet applied and // also won't result in a "move" of the object. So it's important that we calculate a correct offset for our final mesh. NPVoxBox insetBox = cutoutBox.Clone(); Vector3 insetOffset = Vector3.zero; if (inset != null) { Vector3 cutoutCenter = cutoutBox.SaveCenter; insetBox.Left += (sbyte)Mathf.Abs(inset.Left); insetBox.Right -= (sbyte)Mathf.Abs(inset.Right); insetBox.Down += (sbyte)Mathf.Abs(inset.Down); insetBox.Up -= (sbyte)Mathf.Abs(inset.Up); insetBox.Back += (sbyte)Mathf.Abs(inset.Back); insetBox.Forward -= (sbyte)Mathf.Abs(inset.Forward); insetOffset = Vector3.Scale(cutoutCenter - insetBox.SaveCenter, InputMeshFactory.VoxelSize); } Vector3 insetCenter = insetBox.SaveCenter; if (Baked45Angle) { backSlot = CreateTexture(backSlot, includedFaces.Back != 0, insetBox.Size.X, insetBox.Size.Y, Quaternion.Euler(-45, 0, 0), npVoxToUnity.ToUnityPosition(new Vector3(insetCenter.x, insetCenter.y, insetBox.Back)), npVoxToUnity.ToUnityDirection(new Vector2(insetBox.Size.X, ((float)insetBox.Size.Y) / Mathf.Sqrt(2))) * 0.5f, Quaternion.Euler(+45, 0, 0) ); downSlot = CreateTexture(downSlot, includedFaces.Down != 0, insetBox.Size.X, insetBox.Size.Z * 3, Quaternion.Euler(-45, 0, 0), npVoxToUnity.ToUnityPosition(new Vector3(insetCenter.x, insetBox.Down, insetCenter.z)), npVoxToUnity.ToUnityDirection(new Vector2(insetBox.Size.X, ((float)insetBox.Size.Z) / Mathf.Sqrt(2))) * 0.5f, Quaternion.Euler(-45, 0, 0) ); leftSlot = CreateTexture(leftSlot, false, 0, 0, Quaternion.identity, Vector3.zero, Vector2.zero, Quaternion.identity); rightSlot = CreateTexture(rightSlot, false, 0, 0, Quaternion.identity, Vector3.zero, Vector2.zero, Quaternion.identity); upSlot = CreateTexture(upSlot, false, 0, 0, Quaternion.identity, Vector3.zero, Vector2.zero, Quaternion.identity); forwardSlot = CreateTexture(forwardSlot, false, 0, 0, Quaternion.identity, Vector3.zero, Vector2.zero, Quaternion.identity); } else { leftSlot = CreateTexture(leftSlot, includedFaces.Left != 0, insetBox.Size.Z, insetBox.Size.Y, Quaternion.Euler(0, 90, 0), npVoxToUnity.ToUnityPosition(new Vector3(insetBox.Left, insetCenter.y, insetCenter.z)), npVoxToUnity.ToUnityDirection(new Vector2(insetBox.Size.Z, insetBox.Size.Y)) * 0.5f, Quaternion.identity ); rightSlot = CreateTexture(rightSlot, includedFaces.Right != 0, insetBox.Size.Z, insetBox.Size.Y, Quaternion.Euler(0, -90, 0), npVoxToUnity.ToUnityPosition(new Vector3(insetBox.Right, insetCenter.y, insetCenter.z)), npVoxToUnity.ToUnityDirection(new Vector2(insetBox.Size.Z, insetBox.Size.Y)) * 0.5f, Quaternion.identity ); downSlot = CreateTexture(downSlot, includedFaces.Down != 0, insetBox.Size.X, insetBox.Size.Z, Quaternion.Euler(-90, 0, 0), npVoxToUnity.ToUnityPosition(new Vector3(insetCenter.x, insetBox.Down, insetCenter.z)), npVoxToUnity.ToUnityDirection(new Vector2(insetBox.Size.X, insetBox.Size.Z)) * 0.5f, Quaternion.identity ); upSlot = CreateTexture(upSlot, includedFaces.Up != 0, insetBox.Size.X, insetBox.Size.Z, Quaternion.Euler(90, 0, 180), npVoxToUnity.ToUnityPosition(new Vector3(insetCenter.x, insetBox.Up, insetCenter.z)), npVoxToUnity.ToUnityDirection(new Vector2(insetBox.Size.X, insetBox.Size.Z)) * 0.5f, Quaternion.identity ); backSlot = CreateTexture(backSlot, includedFaces.Back != 0, insetBox.Size.X, insetBox.Size.Y, Quaternion.Euler(0, 0, 0), npVoxToUnity.ToUnityPosition(new Vector3(insetCenter.x, insetCenter.y, insetBox.Back)), npVoxToUnity.ToUnityDirection(new Vector2(insetBox.Size.X, insetBox.Size.Y)) * 0.5f, Quaternion.identity ); forwardSlot = CreateTexture(forwardSlot, includedFaces.Forward != 0, insetBox.Size.X, insetBox.Size.Y, Quaternion.Euler(-180, 0, 0), npVoxToUnity.ToUnityPosition(new Vector3(insetCenter.x, insetCenter.y, insetBox.Forward)), npVoxToUnity.ToUnityDirection(new Vector2(insetBox.Size.X, insetBox.Size.Y)) * 0.5f, Quaternion.identity ); } slotsAllocatedAtTA = TextureAtlas; if (mesh == null) { mesh = new Mesh(); } else { mesh.Clear(); } mesh.name = "zzz Cube Simplifier Mesh"; int border = 1; var vertices = new Vector3[faceCount * 4]; var uvs = new Vector2[faceCount * 4]; var tris = new int[faceCount * 3 * 2]; var normals = new Vector3[faceCount * 4]; int v = 0; int t = 0; int v0 = 0; System.Action <Vector3, NPVoxTextureAtlas.Slot> addQuad = (Vector3 dir, NPVoxTextureAtlas.Slot theSlot) => { normals[v0] = dir; normals[v0 + 1] = dir; normals[v0 + 2] = dir; normals[v0 + 3] = dir; tris[t++] = v0; tris[t++] = v0 + 1; tris[t++] = v0 + 2; tris[t++] = v0; tris[t++] = v0 + 2; tris[t++] = v0 + 3; Vector2 uvMax = theSlot.GetUVmax(border); Vector2 uvMin = theSlot.GetUVmin(border); uvs[v0].x = uvMin.x; uvs[v0].y = uvMax.y; uvs[v0 + 1].x = uvMax.x; uvs[v0 + 1].y = uvMax.y; uvs[v0 + 2].x = uvMax.x; uvs[v0 + 2].y = uvMin.y; uvs[v0 + 3].x = uvMin.x; uvs[v0 + 3].y = uvMin.y; }; NPVoxBox bounds = insetBox; Vector3 LDB = cutoutOffset + npVoxToUnity.ToUnityPosition(bounds.LeftDownBack) + (Vector3.left * npVoxToUnity.VoxeSize.x + Vector3.down * npVoxToUnity.VoxeSize.y + Vector3.back * npVoxToUnity.VoxeSize.z) * 0.5f; Vector3 RDB = cutoutOffset + npVoxToUnity.ToUnityPosition(bounds.RightDownBack) + (Vector3.right * npVoxToUnity.VoxeSize.x + Vector3.down * npVoxToUnity.VoxeSize.y + Vector3.back * npVoxToUnity.VoxeSize.z) * 0.5f; Vector3 LUB = cutoutOffset + npVoxToUnity.ToUnityPosition(bounds.LeftUpBack) + (Vector3.left * npVoxToUnity.VoxeSize.x + Vector3.up * npVoxToUnity.VoxeSize.y + Vector3.back * npVoxToUnity.VoxeSize.z) * 0.5f; Vector3 RUB = cutoutOffset + npVoxToUnity.ToUnityPosition(bounds.RightUpBack) + (Vector3.right * npVoxToUnity.VoxeSize.x + Vector3.up * npVoxToUnity.VoxeSize.y + Vector3.back * npVoxToUnity.VoxeSize.z) * 0.5f; Vector3 LDF = cutoutOffset + npVoxToUnity.ToUnityPosition(bounds.LeftDownForward) + (Vector3.left * npVoxToUnity.VoxeSize.x + Vector3.down * npVoxToUnity.VoxeSize.y + Vector3.forward * npVoxToUnity.VoxeSize.z) * 0.5f; Vector3 RDF = cutoutOffset + npVoxToUnity.ToUnityPosition(bounds.RightDownForward) + (Vector3.right * npVoxToUnity.VoxeSize.x + Vector3.down * npVoxToUnity.VoxeSize.y + Vector3.forward * npVoxToUnity.VoxeSize.z) * 0.5f; Vector3 LUF = cutoutOffset + npVoxToUnity.ToUnityPosition(bounds.LeftUpForward) + (Vector3.left * npVoxToUnity.VoxeSize.x + Vector3.up * npVoxToUnity.VoxeSize.y + Vector3.forward * npVoxToUnity.VoxeSize.z) * 0.5f; Vector3 RUF = cutoutOffset + npVoxToUnity.ToUnityPosition(bounds.RightUpForward) + (Vector3.right * npVoxToUnity.VoxeSize.x + Vector3.up * npVoxToUnity.VoxeSize.y + Vector3.forward * npVoxToUnity.VoxeSize.z) * 0.5f; if (downSlot != null) { v0 = v; vertices[v++] = LDB; vertices[v++] = RDB; vertices[v++] = RDF; vertices[v++] = LDF; addQuad(Vector3.down, downSlot); } if (upSlot != null) { v0 = v; vertices[v++] = RUB; vertices[v++] = LUB; vertices[v++] = LUF; vertices[v++] = RUF; addQuad(Vector3.up, upSlot); } if (forwardSlot != null) { v0 = v; vertices[v++] = LDF; vertices[v++] = RDF; vertices[v++] = RUF; vertices[v++] = LUF; addQuad(Vector3.forward, forwardSlot); } if (backSlot != null) { v0 = v; vertices[v++] = LUB; vertices[v++] = RUB; vertices[v++] = RDB; vertices[v++] = LDB; addQuad(Vector3.back, backSlot); } if (leftSlot != null) { v0 = v; vertices[v++] = LUF; vertices[v++] = LUB; vertices[v++] = LDB; vertices[v++] = LDF; addQuad(Vector3.left, leftSlot); } if (rightSlot != null) { v0 = v; vertices[v++] = RUB; vertices[v++] = RUF; vertices[v++] = RDF; vertices[v++] = RDB; addQuad(Vector3.right, rightSlot); } mesh.vertices = vertices; mesh.triangles = tris; mesh.uv = uvs; mesh.RecalculateBounds(); mesh.normals = normals; TangentSolver.Solve(mesh); // mesh.bounds = new Bounds( // insetOffset, // new Vector3( // bounds.Size.X * npVoxToUnity.VoxeSize.x, // bounds.Size.Y * npVoxToUnity.VoxeSize.y, // bounds.Size.Z * npVoxToUnity.VoxeSize.z // ) // ); Mesh sourceMesh = meshOutput.GetProduct(); mesh.bounds = sourceMesh.bounds; mesh.name = "zzz Cube Mesh "; return(mesh); } else { Debug.LogWarning("No Input set up"); if (mesh == null) { mesh = new Mesh(); } else { mesh.Clear(); } return(mesh); } }
public int GetFaceCount() { NPVoxFaces faces = GetIncludedFaces(); return(faces.Back + faces.Forward + faces.Left + faces.Right + faces.Up + faces.Down); }
public static void CreateMesh( NPVoxModel model, Mesh mesh, Vector3 cubeSize, Vector3 NormalVariance, int NormalVarianceSeed = 0, NPVoxOptimization optimization = NPVoxOptimization.OFF, NPVoxNormalMode NormalMode = NPVoxNormalMode.SMOOTH, int BloodColorIndex = 0, NPVoxFaces loop = null, NPVoxFaces cutout = null, NPVoxFaces include = null, int MinVertexGroups = 1, NPVoxNormalMode[] NormalModePerVoxelGroup = null, NPVoxNormalProcessorList normalProcessors = null ) { bool hasVoxelGroups = model.HasVoxelGroups(); var vertices = new Vector3[model.NumVoxels * 8]; byte vertexGroupCount = model.NumVoxelGroups; var triangles = new int[vertexGroupCount, model.NumVoxels * 36]; var normals = new Vector3[model.NumVoxels * 8]; var tangents = new Vector4[model.NumVoxels * 8]; var colors = new Color[model.NumVoxels * 8]; var tmp = new NPVoxMeshTempData[model.NumVoxels]; int currentVertexIndex = 0; var currentTriangleIndex = new int[vertexGroupCount]; for (int i = 0; i < vertexGroupCount; i++) { currentTriangleIndex[i] = 0; } UnityEngine.Random.InitState(NormalVarianceSeed); if (loop == null) { loop = new NPVoxFaces(); } if (include == null) { include = new NPVoxFaces(1, 1, 1, 1, 1, 1); } NPVoxBox voxelsToInclude = model.BoundingBox; Vector3 cutoutOffset = Vector3.zero; if (cutout != null) { Vector3 originalCenter = voxelsToInclude.SaveCenter; voxelsToInclude.Left = (sbyte)Mathf.Abs(cutout.Left); voxelsToInclude.Down = (sbyte)Mathf.Abs(cutout.Down); voxelsToInclude.Back = (sbyte)Mathf.Abs(cutout.Back); voxelsToInclude.Right = (sbyte)(voxelsToInclude.Right - (sbyte)Mathf.Abs(cutout.Right)); voxelsToInclude.Up = (sbyte)(voxelsToInclude.Up - (sbyte)Mathf.Abs(cutout.Up)); voxelsToInclude.Forward = (sbyte)(voxelsToInclude.Forward - (sbyte)Mathf.Abs(cutout.Forward)); cutoutOffset = Vector3.Scale(originalCenter - voxelsToInclude.SaveCenter, cubeSize); } NPVoxToUnity npVoxToUnity = new NPVoxToUnity(model, cubeSize); Vector3 size = new Vector3( voxelsToInclude.Size.X * cubeSize.x, voxelsToInclude.Size.Y * cubeSize.y, voxelsToInclude.Size.Z * cubeSize.z ); NPVoxBox voxelNormalNeighbours = new NPVoxBox(new NPVoxCoord(-1, -1, -1), new NPVoxCoord(1, 1, 1)); // Collect temporary data to use for model generation int voxIndex = 0; foreach (NPVoxCoord voxCoord in voxelsToInclude.Enumerate()) { if (model.HasVoxel(voxCoord)) { tmp[voxIndex] = new NPVoxMeshTempData(); tmp[voxIndex].loop = loop; tmp[voxIndex].cutout = cutout; tmp[voxIndex].include = include; // Compute voxel center tmp[voxIndex].voxelCenter = npVoxToUnity.ToUnityPosition(voxCoord) + cutoutOffset; tmp[voxIndex].voxCoord = voxCoord; tmp[voxIndex].voxToUnity = npVoxToUnity; // Determine vertex group index tmp[voxIndex].vertexGroupIndex = 0; if (hasVoxelGroups) { tmp[voxIndex].vertexGroupIndex = model.GetVoxelGroup(voxCoord); } // Determine normal Mode if (NormalModePerVoxelGroup != null && NormalModePerVoxelGroup.Length > tmp[voxIndex].vertexGroupIndex) { tmp[voxIndex].normalMode = NormalModePerVoxelGroup[tmp[voxIndex].vertexGroupIndex]; } else { tmp[voxIndex].normalMode = NormalMode; } // do we have this side tmp[voxIndex].hasLeft = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.LEFT, loop)); tmp[voxIndex].hasRight = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.RIGHT, loop)); tmp[voxIndex].hasDown = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.DOWN, loop)); tmp[voxIndex].hasUp = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.UP, loop)); tmp[voxIndex].hasForward = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.FORWARD, loop)); tmp[voxIndex].hasBack = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.BACK, loop)); // do we actually want to include this side in our mesh // NOTE: cutout < 0 means we still render the mesh even though it is cutout // cutout > 0 means we don't render the mesh when cutout tmp[voxIndex].includeLeft = (tmp[voxIndex].hasLeft || (cutout.Left < 0 && voxCoord.X == voxelsToInclude.Left)) && include.Left == 1; tmp[voxIndex].includeRight = (tmp[voxIndex].hasRight || (cutout.Right < 0 && voxCoord.X == voxelsToInclude.Right)) && include.Right == 1; tmp[voxIndex].includeUp = (tmp[voxIndex].hasUp || (cutout.Up < 0 && voxCoord.Y == voxelsToInclude.Up)) && include.Up == 1; tmp[voxIndex].includeDown = (tmp[voxIndex].hasDown || (cutout.Down < 0 && voxCoord.Y == voxelsToInclude.Down)) && include.Down == 1; tmp[voxIndex].includeBack = (tmp[voxIndex].hasBack || (cutout.Back < 0 && voxCoord.Z == voxelsToInclude.Back)) && include.Back == 1; tmp[voxIndex].includeForward = (tmp[voxIndex].hasForward || (cutout.Forward < 0 && voxCoord.Z == voxelsToInclude.Forward)) && include.Forward == 1; tmp[voxIndex].isHidden = !tmp[voxIndex].hasForward && !tmp[voxIndex].hasBack && !tmp[voxIndex].hasLeft && !tmp[voxIndex].hasRight && !tmp[voxIndex].hasUp && !tmp[voxIndex].hasDown; if (tmp[voxIndex].isHidden && optimization == NPVoxOptimization.PER_VOXEL) { continue; } if (tmp[voxIndex].isHidden && BloodColorIndex > 0) { model.SetVoxel(voxCoord, (byte)BloodColorIndex); // WTF WTF WTF?!? we should not modify the MODEL in here !!!! elfapo: AAAAHHH NOOOO!!!! :O j.k. ;) } Color color = model.GetColor(voxCoord); // prepare cube vertices tmp[voxIndex].numVertices = 0; tmp[voxIndex].vertexIndexOffsetBegin = currentVertexIndex; if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeBack || tmp[voxIndex].includeLeft || tmp[voxIndex].includeDown) { tmp[voxIndex].vertexIndexOffsets[0] = tmp[voxIndex].numVertices++; tmp[voxIndex].vertexPositionOffsets[tmp[voxIndex].vertexIndexOffsets[0]] = new Vector3(-0.5f, -0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeBack || tmp[voxIndex].includeRight || tmp[voxIndex].includeDown) { tmp[voxIndex].vertexIndexOffsets[1] = tmp[voxIndex].numVertices++; tmp[voxIndex].vertexPositionOffsets[tmp[voxIndex].vertexIndexOffsets[1]] = new Vector3(0.5f, -0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeBack || tmp[voxIndex].includeLeft || tmp[voxIndex].includeUp) { tmp[voxIndex].vertexIndexOffsets[2] = tmp[voxIndex].numVertices++; tmp[voxIndex].vertexPositionOffsets[tmp[voxIndex].vertexIndexOffsets[2]] = new Vector3(-0.5f, 0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeBack || tmp[voxIndex].includeRight || tmp[voxIndex].includeUp) { tmp[voxIndex].vertexIndexOffsets[3] = tmp[voxIndex].numVertices++; tmp[voxIndex].vertexPositionOffsets[tmp[voxIndex].vertexIndexOffsets[3]] = new Vector3(0.5f, 0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeForward || tmp[voxIndex].includeLeft || tmp[voxIndex].includeDown) { tmp[voxIndex].vertexIndexOffsets[4] = tmp[voxIndex].numVertices++; tmp[voxIndex].vertexPositionOffsets[tmp[voxIndex].vertexIndexOffsets[4]] = new Vector3(-0.5f, -0.5f, 0.5f); } if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeForward || tmp[voxIndex].includeRight || tmp[voxIndex].includeDown) { tmp[voxIndex].vertexIndexOffsets[5] = tmp[voxIndex].numVertices++; tmp[voxIndex].vertexPositionOffsets[tmp[voxIndex].vertexIndexOffsets[5]] = new Vector3(0.5f, -0.5f, 0.5f); } if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeForward || tmp[voxIndex].includeLeft || tmp[voxIndex].includeUp) { tmp[voxIndex].vertexIndexOffsets[6] = tmp[voxIndex].numVertices++; tmp[voxIndex].vertexPositionOffsets[tmp[voxIndex].vertexIndexOffsets[6]] = new Vector3(-0.5f, 0.5f, 0.5f); } if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeForward || tmp[voxIndex].includeRight || tmp[voxIndex].includeUp) { tmp[voxIndex].vertexIndexOffsets[7] = tmp[voxIndex].numVertices++; tmp[voxIndex].vertexPositionOffsets[tmp[voxIndex].vertexIndexOffsets[7]] = new Vector3(0.5f, 0.5f, 0.5f); } // add cube faces int i = currentTriangleIndex[tmp[voxIndex].vertexGroupIndex]; // back if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeBack) { triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[0]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[2]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[1]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[2]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[3]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[1]; } // Forward if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeForward) { triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[6]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[4]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[5]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[7]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[6]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[5]; } // right if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeRight) { triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[1]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[3]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[5]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[3]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[7]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[5]; } // left if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeLeft) { triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[0]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[4]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[2]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[2]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[4]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[6]; } // up if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeUp) { triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[2]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[6]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[3]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[3]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[6]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[7]; } // down if (optimization != NPVoxOptimization.PER_FACE || tmp[voxIndex].includeDown) { triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[0]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[1]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[4]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[1]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[5]; triangles[tmp[voxIndex].vertexGroupIndex, i++] = tmp[voxIndex].vertexIndexOffsetBegin + tmp[voxIndex].vertexIndexOffsets[4]; } // Tangents for (int t = 0; t < tmp[voxIndex].numVertices; t++) { // store voxel center for shader usage Vector4 tangent = new Vector4(); tangent.x = tmp[voxIndex].voxelCenter.x; tangent.y = tmp[voxIndex].voxelCenter.y; tangent.z = tmp[voxIndex].voxelCenter.z; // encode model size tangent.w = ((voxelsToInclude.Size.X & 0x7F) << 14) | ((voxelsToInclude.Size.Y & 0x7F) << 7) | (voxelsToInclude.Size.Z & 0x7F); tangents[tmp[voxIndex].vertexIndexOffsetBegin + t] = tangent; } // UVs for (int t = 0; t < tmp[voxIndex].numVertices; t++) { colors[tmp[voxIndex].vertexIndexOffsetBegin + t] = color; } // translate & scale vertices to voxel position for (int t = 0; t < tmp[voxIndex].numVertices; t++) { vertices[tmp[voxIndex].vertexIndexOffsetBegin + t] = tmp[voxIndex].voxelCenter + Vector3.Scale(tmp[voxIndex].vertexPositionOffsets[t], cubeSize); } currentTriangleIndex[tmp[voxIndex].vertexGroupIndex] = i; currentVertexIndex += tmp[voxIndex].numVertices; voxIndex++; } } // elfapo: Remove invalid voxel information Array.Resize(ref tmp, voxIndex); ////////////////////////////////////// NORMAL STAGES //////////////////////////////////////// // elfapo TODO: Test area 'Normal Processor' Move Normal Processor stages to Normal Processor Pipeline: //NPVoxNormalProcessor_Voxel generator = ScriptableObject.CreateInstance<NPVoxNormalProcessor_Voxel>(); //NPVoxNormalProcessor_Variance processor = ScriptableObject.CreateInstance<NPVoxNormalProcessor_Variance>(); //generator.InitOutputBuffer(normals); //processor.InitOutputBuffer(normals); //processor.NormalVariance = NormalVariance; //processor.NormalVarianceSeed = NormalVarianceSeed; //if (NormalModePerVoxelGroup != null && NormalModePerVoxelGroup.Length > 0) //{ // for (int i = 0; i < NormalModePerVoxelGroup.Length; i++) // { // generator.ClearVoxelGroupFilters(); // generator.AddVoxelGroupFilter(i); // generator.NormalMode = NormalModePerVoxelGroup[i]; // generator.Process(model, tmp, normals, normals); // } // processor.Process(model, tmp, normals, normals); //} //else //{ // generator.NormalMode = NormalMode; // generator.Process(model, tmp, normals, normals); // processor.Process(model, tmp, normals, normals); //} //ScriptableObject.DestroyImmediate(generator); //ScriptableObject.DestroyImmediate(processor); if (normalProcessors != null) { normalProcessors.Run(model, tmp, normals, normals); } ////////////////////////////////////////////////////////////////////////////////////////////// // shrink arrays as needed if (optimization != NPVoxOptimization.OFF) { Array.Resize(ref vertices, currentVertexIndex); Array.Resize(ref normals, currentVertexIndex); Array.Resize(ref tangents, currentVertexIndex); Array.Resize(ref colors, currentVertexIndex); } mesh.vertices = vertices; if (hasVoxelGroups) { mesh.subMeshCount = Math.Max(vertexGroupCount, MinVertexGroups); for (int i = 0; i < vertexGroupCount; i++) { int numberOfTrianglesForVertexGroup = currentTriangleIndex[i]; int[] trianglesForVertexGroup = new int[numberOfTrianglesForVertexGroup]; for (int j = 0; j < numberOfTrianglesForVertexGroup; j++) { trianglesForVertexGroup[j] = triangles[i, j]; } mesh.SetTriangles(trianglesForVertexGroup, i); } } else { int numberOfTrianglesForVertexGroup = currentTriangleIndex[0]; int[] trianglesForVertexGroup = new int[numberOfTrianglesForVertexGroup]; Buffer.BlockCopy(triangles, 0, trianglesForVertexGroup, 0, numberOfTrianglesForVertexGroup * sizeof(int)); if (MinVertexGroups < 2) { mesh.triangles = trianglesForVertexGroup; } else { mesh.subMeshCount = MinVertexGroups; mesh.SetTriangles(trianglesForVertexGroup, 0); } } mesh.normals = normals; mesh.tangents = tangents; mesh.colors = colors; mesh.bounds = new Bounds(Vector3.zero, size); if (NormalMode == NPVoxNormalMode.AUTO) { mesh.RecalculateNormals(); } }
public static void CreateMesh( NPVoxModel model, Mesh mesh, Vector3 cubeSize, Vector3 NormalVariance, int NormalVarianceSeed = 0, NPVoxOptimization optimization = NPVoxOptimization.OFF, NPVoxNormalMode NormalMode = NPVoxNormalMode.SMOOTH, int BloodColorIndex = 0, NPVoxFaces loop = null, NPVoxFaces cutout = null, NPVoxFaces include = null, int MinVertexGroups = 1, NPVoxNormalMode[] NormalModePerVoxelGroup = null ) { bool hasVoxelGroups = model.HasVoxelGroups(); var vertices = new Vector3[model.NumVoxels * 8]; byte vertexGroupCount = model.NumVoxelGroups; var triangles = new int[vertexGroupCount, model.NumVoxels * 36]; var normals = new Vector3[model.NumVoxels * 8]; var tangents = new Vector4[model.NumVoxels * 8]; var colors = new Color[model.NumVoxels * 8]; int currentVertexIndex = 0; var currentTriangleIndex = new int[vertexGroupCount]; for (int i = 0; i < vertexGroupCount; i++) { currentTriangleIndex[i] = 0; } UnityEngine.Random.InitState(NormalVarianceSeed); if (loop == null) { loop = new NPVoxFaces(); } if (include == null) { include = new NPVoxFaces(1, 1, 1, 1, 1, 1); } NPVoxBox voxelsToInclude = model.BoundingBox; Vector3 cutoutOffset = Vector3.zero; if (cutout != null) { Vector3 originalCenter = voxelsToInclude.SaveCenter; voxelsToInclude.Left = (sbyte)Mathf.Abs(cutout.Left); voxelsToInclude.Down = (sbyte)Mathf.Abs(cutout.Down); voxelsToInclude.Back = (sbyte)Mathf.Abs(cutout.Back); voxelsToInclude.Right = (sbyte)(voxelsToInclude.Right - (sbyte)Mathf.Abs(cutout.Right)); voxelsToInclude.Up = (sbyte)(voxelsToInclude.Up - (sbyte)Mathf.Abs(cutout.Up)); voxelsToInclude.Forward = (sbyte)(voxelsToInclude.Forward - (sbyte)Mathf.Abs(cutout.Forward)); cutoutOffset = Vector3.Scale(originalCenter - voxelsToInclude.SaveCenter, cubeSize); } NPVoxToUnity npVoxToUnity = new NPVoxToUnity(model, cubeSize); Vector3 size = new Vector3( voxelsToInclude.Size.X * cubeSize.x, voxelsToInclude.Size.Y * cubeSize.y, voxelsToInclude.Size.Z * cubeSize.z ); NPVoxBox voxelNormalNeighbours = new NPVoxBox(new NPVoxCoord(-1, -1, -1), new NPVoxCoord(1, 1, 1)); NPVoxNormalMode normalMode = NormalMode; foreach (NPVoxCoord voxCoord in voxelsToInclude.Enumerate()) { if (model.HasVoxel(voxCoord)) { Vector3 voxelCenter = npVoxToUnity.ToUnityPosition(voxCoord) + cutoutOffset; int vertexGroupIndex = 0; if (hasVoxelGroups) { vertexGroupIndex = model.GetVoxelGroup(voxCoord); } if (NormalModePerVoxelGroup != null && NormalModePerVoxelGroup.Length > vertexGroupIndex) { normalMode = NormalModePerVoxelGroup[vertexGroupIndex]; } else { normalMode = NormalMode; } // do we have this side bool hasLeft = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.LEFT, loop)); bool hasRight = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.RIGHT, loop)); bool hasDown = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.DOWN, loop)); bool hasUp = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.UP, loop)); bool hasForward = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.FORWARD, loop)); bool hasBack = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.BACK, loop)); // do we actually want to include this side in our mesh // NOTE: cutout < 0 means we still render the mesh even though it is cutout // cutout > 0 means we don't render the mesh when cutout bool includeLeft = (hasLeft || (cutout.Left < 0 && voxCoord.X == voxelsToInclude.Left)) && include.Left == 1; bool includeRight = (hasRight || (cutout.Right < 0 && voxCoord.X == voxelsToInclude.Right)) && include.Right == 1; bool includeUp = (hasUp || (cutout.Up < 0 && voxCoord.Y == voxelsToInclude.Up)) && include.Up == 1; bool includeDown = (hasDown || (cutout.Down < 0 && voxCoord.Y == voxelsToInclude.Down)) && include.Down == 1; bool includeBack = (hasBack || (cutout.Back < 0 && voxCoord.Z == voxelsToInclude.Back)) && include.Back == 1; bool includeForward = (hasForward || (cutout.Forward < 0 && voxCoord.Z == voxelsToInclude.Forward)) && include.Forward == 1; bool isHidden = !hasForward && !hasBack && !hasLeft && !hasRight && !hasUp && !hasDown; if (isHidden && optimization == NPVoxOptimization.PER_VOXEL) { continue; } if (isHidden && BloodColorIndex > 0) { model.SetVoxel(voxCoord, (byte)BloodColorIndex); // WTF WTF WTF?!? we should not modify the MODEL in here !!!! } Color color = model.GetColor(voxCoord); // prepare cube vertices int numVertices = 0; int[] vertexIndexOffsets = new int[8]; Vector3[] vertexPositionOffsets = new Vector3[8]; if (optimization != NPVoxOptimization.PER_FACE || includeBack || includeLeft || includeDown) { vertexIndexOffsets[0] = numVertices++; vertexPositionOffsets[vertexIndexOffsets[0]] = new Vector3(-0.5f, -0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || includeBack || includeRight || includeDown) { vertexIndexOffsets[1] = numVertices++; vertexPositionOffsets[vertexIndexOffsets[1]] = new Vector3(0.5f, -0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || includeBack || includeLeft || includeUp) { vertexIndexOffsets[2] = numVertices++; vertexPositionOffsets[vertexIndexOffsets[2]] = new Vector3(-0.5f, 0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || includeBack || includeRight || includeUp) { vertexIndexOffsets[3] = numVertices++; vertexPositionOffsets[vertexIndexOffsets[3]] = new Vector3(0.5f, 0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || includeForward || includeLeft || includeDown) { vertexIndexOffsets[4] = numVertices++; vertexPositionOffsets[vertexIndexOffsets[4]] = new Vector3(-0.5f, -0.5f, 0.5f); } if (optimization != NPVoxOptimization.PER_FACE || includeForward || includeRight || includeDown) { vertexIndexOffsets[5] = numVertices++; vertexPositionOffsets[vertexIndexOffsets[5]] = new Vector3(0.5f, -0.5f, 0.5f); } if (optimization != NPVoxOptimization.PER_FACE || includeForward || includeLeft || includeUp) { vertexIndexOffsets[6] = numVertices++; vertexPositionOffsets[vertexIndexOffsets[6]] = new Vector3(-0.5f, 0.5f, 0.5f); } if (optimization != NPVoxOptimization.PER_FACE || includeForward || includeRight || includeUp) { vertexIndexOffsets[7] = numVertices++; vertexPositionOffsets[vertexIndexOffsets[7]] = new Vector3(0.5f, 0.5f, 0.5f); } // add cube faces int i = currentTriangleIndex[vertexGroupIndex]; // back if (optimization != NPVoxOptimization.PER_FACE || includeBack) { triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[0]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[2]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[1]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[2]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[3]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[1]; } // Forward if (optimization != NPVoxOptimization.PER_FACE || includeForward) { triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[6]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[4]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[5]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[7]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[6]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[5]; } // right if (optimization != NPVoxOptimization.PER_FACE || includeRight) { triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[1]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[3]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[5]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[3]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[7]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[5]; } // left if (optimization != NPVoxOptimization.PER_FACE || includeLeft) { triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[0]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[4]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[2]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[2]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[4]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[6]; } // up if (optimization != NPVoxOptimization.PER_FACE || includeUp) { triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[2]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[6]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[3]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[3]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[6]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[7]; } // down if (optimization != NPVoxOptimization.PER_FACE || includeDown) { triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[0]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[1]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[4]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[1]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[5]; triangles[vertexGroupIndex, i++] = currentVertexIndex + vertexIndexOffsets[4]; } // TODO create some kind of strategy pattern for the normal calculation, else this here is becomming a mess ... Vector3 variance = Vector3.zero; if (NormalVariance.x != 0 || NormalVariance.y != 0 || NormalVariance.z != 0) { variance.x = -NormalVariance.x * 0.5f + 2 * UnityEngine.Random.value * NormalVariance.x; variance.y = -NormalVariance.y * 0.5f + 2 * UnityEngine.Random.value * NormalVariance.y; variance.z = -NormalVariance.z * 0.5f + 2 * UnityEngine.Random.value * NormalVariance.z; } // calculate normals based on present neighbour voxels Vector3 voxelNormal = Vector3.zero; if (!isHidden) { foreach (NPVoxCoord offset in voxelNormalNeighbours.Enumerate()) { NPVoxCoord checkCoord = voxCoord + offset; checkCoord = model.LoopCoord(checkCoord, loop); if (!model.HasVoxel(checkCoord)) { voxelNormal += NPVoxCoordUtil.ToVector(offset); } } voxelNormal.Normalize(); } else { voxelNormal = voxelCenter.normalized; } // Normals for (int t = 0; t < numVertices; t++) { Vector3 normal = Vector3.zero; switch (normalMode) { case NPVoxNormalMode.VOXEL: normal = voxelNormal; normal = Vector3.zero; if (vertexPositionOffsets[t].x < 0.0f) { if (hasLeft && !hasForward && !hasBack && !hasUp && !hasDown) { normal.x = -1; } else { normal.x = voxelNormal.x; } } else if (vertexPositionOffsets[t].x > 0.0f) { if (hasRight && !hasForward && !hasBack && !hasUp && !hasDown) { normal.x = 1; } else { normal.x = voxelNormal.x; } } if (vertexPositionOffsets[t].y < 0.0f) { if (hasUp && !hasForward && !hasBack && !hasLeft && !hasRight) { normal.y = -1; } else { normal.y = voxelNormal.y; } } else if (vertexPositionOffsets[t].y > 0.0f) { if (hasDown && !hasForward && !hasBack && !hasLeft && !hasRight) { normal.y = +1; } else { normal.y = voxelNormal.y; } } if (vertexPositionOffsets[t].z < 0.0f) { if (hasBack && !hasLeft && !hasRight && !hasUp && !hasDown) { normal.z = -1; } else { normal.z = voxelNormal.z; } } else if (vertexPositionOffsets[t].z > 0.0f) { if (hasForward && !hasLeft && !hasRight && !hasUp && !hasDown) { normal.z = +1; } else { normal.z = voxelNormal.z; } } if (Mathf.Abs(normal.x) < 0.1f && Mathf.Abs(normal.y) < 0.1f && Mathf.Abs(normal.z) < 0.1f) { // we would like to have full color when we are a stand-alone voxel, however there is no way to do so right now, so we just // fallback to the centoid normal normal = voxelCenter; } normal.Normalize(); break; case NPVoxNormalMode.SMOOTH: normal = Vector3.zero; for (float xx = -0.5f; xx < 1.0f; xx += 1f) { for (float yy = -.5f; yy < 1; yy += 1) { for (float zz = -.5f; zz < 1; zz += 1) { sbyte xCoord = (sbyte)Mathf.Round(vertexPositionOffsets[t].x + xx); sbyte yCoord = (sbyte)Mathf.Round(vertexPositionOffsets[t].y + yy); sbyte zCoord = (sbyte)Mathf.Round(vertexPositionOffsets[t].z + zz); if (!model.HasVoxel(voxCoord + new NPVoxCoord((sbyte)xCoord, (sbyte)yCoord, (sbyte)zCoord))) { normal += new Vector3( xx, yy, zz ); } } } } normal.Normalize(); break; case NPVoxNormalMode.FORWARD: normal = Vector3.forward; break; case NPVoxNormalMode.BACK: normal = Vector3.back; break; case NPVoxNormalMode.UP: normal = Vector3.up; break; case NPVoxNormalMode.DOWN: normal = Vector3.down; break; case NPVoxNormalMode.LEFT: normal = Vector3.left; break; case NPVoxNormalMode.RIGHT: normal = Vector3.right; break; } normals[currentVertexIndex + t] = (normal + variance).normalized; // store voxel center for shader usage Vector4 tangent = new Vector4(); tangent.x = voxelCenter.x; tangent.y = voxelCenter.y; tangent.z = voxelCenter.z; // encode model size tangent.w = ((voxelsToInclude.Size.X & 0x7F) << 14) | ((voxelsToInclude.Size.Y & 0x7F) << 7) | (voxelsToInclude.Size.Z & 0x7F); tangents[currentVertexIndex + t] = tangent; } // UVs for (int t = 0; t < numVertices; t++) { colors[currentVertexIndex + t] = color; } // translate & scale vertices to voxel position for (int t = 0; t < numVertices; t++) { vertices[currentVertexIndex + t] = voxelCenter + Vector3.Scale(vertexPositionOffsets[t], cubeSize); } currentTriangleIndex[vertexGroupIndex] = i; currentVertexIndex += numVertices; } } // shrink arrays as needed if (optimization != NPVoxOptimization.OFF) { Array.Resize(ref vertices, currentVertexIndex); Array.Resize(ref normals, currentVertexIndex); Array.Resize(ref tangents, currentVertexIndex); Array.Resize(ref colors, currentVertexIndex); } mesh.vertices = vertices; if (hasVoxelGroups) { mesh.subMeshCount = Math.Max(vertexGroupCount, MinVertexGroups); for (int i = 0; i < vertexGroupCount; i++) { int numberOfTrianglesForVertexGroup = currentTriangleIndex[i]; int[] trianglesForVertexGroup = new int[numberOfTrianglesForVertexGroup]; for (int j = 0; j < numberOfTrianglesForVertexGroup; j++) { trianglesForVertexGroup[j] = triangles[i, j]; } mesh.SetTriangles(trianglesForVertexGroup, i); } } else { int numberOfTrianglesForVertexGroup = currentTriangleIndex[0]; int[] trianglesForVertexGroup = new int[numberOfTrianglesForVertexGroup]; Buffer.BlockCopy(triangles, 0, trianglesForVertexGroup, 0, numberOfTrianglesForVertexGroup * sizeof(int)); if (MinVertexGroups < 2) { mesh.triangles = trianglesForVertexGroup; } else { mesh.subMeshCount = MinVertexGroups; mesh.SetTriangles(trianglesForVertexGroup, 0); } } mesh.normals = normals; mesh.tangents = tangents; mesh.colors = colors; mesh.bounds = new Bounds(Vector3.zero, size); if (NormalMode == NPVoxNormalMode.AUTO) { mesh.RecalculateNormals(); } }
public static NPVoxMeshData[] GenerateVoxMeshData( NPVoxModel model, Vector3 cubeSize, NPVoxOptimization optimization = NPVoxOptimization.OFF, int BloodColorIndex = 0, NPVoxFaces loop = null, NPVoxFaces cutout = null, NPVoxFaces include = null) { bool hasVoxelGroups = model.HasVoxelGroups(); byte vertexGroupCount = model.NumVoxelGroups; var voxMeshData = new NPVoxMeshData[model.NumVoxels]; int currentVertexIndex = 0; if (loop == null) { loop = new NPVoxFaces(); } if (include == null) { include = new NPVoxFaces(1, 1, 1, 1, 1, 1); } NPVoxBox voxelsToInclude = model.BoundingBox; Vector3 cutoutOffset = Vector3.zero; if (cutout != null) { Vector3 originalCenter = voxelsToInclude.SaveCenter; voxelsToInclude.Left = ( sbyte )Mathf.Abs(cutout.Left); voxelsToInclude.Down = ( sbyte )Mathf.Abs(cutout.Down); voxelsToInclude.Back = ( sbyte )Mathf.Abs(cutout.Back); voxelsToInclude.Right = ( sbyte )(voxelsToInclude.Right - ( sbyte )Mathf.Abs(cutout.Right)); voxelsToInclude.Up = ( sbyte )(voxelsToInclude.Up - ( sbyte )Mathf.Abs(cutout.Up)); voxelsToInclude.Forward = ( sbyte )(voxelsToInclude.Forward - ( sbyte )Mathf.Abs(cutout.Forward)); cutoutOffset = Vector3.Scale(originalCenter - voxelsToInclude.SaveCenter, cubeSize); } NPVoxToUnity npVoxToUnity = new NPVoxToUnity(model, cubeSize); Vector3 size = new Vector3( voxelsToInclude.Size.X * cubeSize.x, voxelsToInclude.Size.Y * cubeSize.y, voxelsToInclude.Size.Z * cubeSize.z ); NPVoxBox voxelNormalNeighbours = new NPVoxBox(new NPVoxCoord(-1, -1, -1), new NPVoxCoord(1, 1, 1)); // Collect temporary data to use for model generation int voxIndex = 0; foreach (NPVoxCoord voxCoord in voxelsToInclude.Enumerate()) { if (model.HasVoxel(voxCoord)) { voxMeshData[voxIndex] = new NPVoxMeshData(); voxMeshData[voxIndex].loop = loop; voxMeshData[voxIndex].cutout = cutout; voxMeshData[voxIndex].include = include; // Compute voxel center voxMeshData[voxIndex].voxelCenter = npVoxToUnity.ToUnityPosition(voxCoord) + cutoutOffset; voxMeshData[voxIndex].voxCoord = voxCoord; voxMeshData[voxIndex].voxToUnity = npVoxToUnity; // Determine vertex group index voxMeshData[voxIndex].vertexGroupIndex = 0; if (hasVoxelGroups) { voxMeshData[voxIndex].vertexGroupIndex = model.GetVoxelGroup(voxCoord); } // do we have this side voxMeshData[voxIndex].hasLeft = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.LEFT, loop)); voxMeshData[voxIndex].hasRight = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.RIGHT, loop)); voxMeshData[voxIndex].hasDown = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.DOWN, loop)); voxMeshData[voxIndex].hasUp = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.UP, loop)); voxMeshData[voxIndex].hasForward = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.FORWARD, loop)); voxMeshData[voxIndex].hasBack = !model.HasVoxel(model.LoopCoord(voxCoord + NPVoxCoord.BACK, loop)); // do we actually want to include this side in our mesh // NOTE: cutout < 0 means we still render the mesh even though it is cutout // cutout > 0 means we don't render the mesh when cutout voxMeshData[voxIndex].includeLeft = (voxMeshData[voxIndex].hasLeft || (cutout.Left < 0 && voxCoord.X == voxelsToInclude.Left)) && include.Left == 1; voxMeshData[voxIndex].includeRight = (voxMeshData[voxIndex].hasRight || (cutout.Right < 0 && voxCoord.X == voxelsToInclude.Right)) && include.Right == 1; voxMeshData[voxIndex].includeUp = (voxMeshData[voxIndex].hasUp || (cutout.Up < 0 && voxCoord.Y == voxelsToInclude.Up)) && include.Up == 1; voxMeshData[voxIndex].includeDown = (voxMeshData[voxIndex].hasDown || (cutout.Down < 0 && voxCoord.Y == voxelsToInclude.Down)) && include.Down == 1; voxMeshData[voxIndex].includeBack = (voxMeshData[voxIndex].hasBack || (cutout.Back < 0 && voxCoord.Z == voxelsToInclude.Back)) && include.Back == 1; voxMeshData[voxIndex].includeForward = (voxMeshData[voxIndex].hasForward || (cutout.Forward < 0 && voxCoord.Z == voxelsToInclude.Forward)) && include.Forward == 1; voxMeshData[voxIndex].isHidden = !voxMeshData[voxIndex].hasForward && !voxMeshData[voxIndex].hasBack && !voxMeshData[voxIndex].hasLeft && !voxMeshData[voxIndex].hasRight && !voxMeshData[voxIndex].hasUp && !voxMeshData[voxIndex].hasDown; if (voxMeshData[voxIndex].isHidden && optimization == NPVoxOptimization.PER_VOXEL) { continue; } if (voxMeshData[voxIndex].isHidden && BloodColorIndex > 0) { model.SetVoxel(voxCoord, ( byte )BloodColorIndex); // WTF WTF WTF?!? we should not modify the MODEL in here !!!! elfapo: AAAAHHH NOOOO!!!! :O j.k. ;) } // prepare cube vertices voxMeshData[voxIndex].numVertices = 0; voxMeshData[voxIndex].vertexIndexOffsetBegin = currentVertexIndex; if (optimization != NPVoxOptimization.PER_FACE || voxMeshData[voxIndex].includeBack || voxMeshData[voxIndex].includeLeft || voxMeshData[voxIndex].includeDown) { voxMeshData[voxIndex].vertexIndexOffsets[0] = voxMeshData[voxIndex].numVertices++; voxMeshData[voxIndex].vertexPositionOffsets[voxMeshData[voxIndex].vertexIndexOffsets[0]] = new Vector3(-0.5f, -0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || voxMeshData[voxIndex].includeBack || voxMeshData[voxIndex].includeRight || voxMeshData[voxIndex].includeDown) { voxMeshData[voxIndex].vertexIndexOffsets[1] = voxMeshData[voxIndex].numVertices++; voxMeshData[voxIndex].vertexPositionOffsets[voxMeshData[voxIndex].vertexIndexOffsets[1]] = new Vector3(0.5f, -0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || voxMeshData[voxIndex].includeBack || voxMeshData[voxIndex].includeLeft || voxMeshData[voxIndex].includeUp) { voxMeshData[voxIndex].vertexIndexOffsets[2] = voxMeshData[voxIndex].numVertices++; voxMeshData[voxIndex].vertexPositionOffsets[voxMeshData[voxIndex].vertexIndexOffsets[2]] = new Vector3(-0.5f, 0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || voxMeshData[voxIndex].includeBack || voxMeshData[voxIndex].includeRight || voxMeshData[voxIndex].includeUp) { voxMeshData[voxIndex].vertexIndexOffsets[3] = voxMeshData[voxIndex].numVertices++; voxMeshData[voxIndex].vertexPositionOffsets[voxMeshData[voxIndex].vertexIndexOffsets[3]] = new Vector3(0.5f, 0.5f, -0.5f); } if (optimization != NPVoxOptimization.PER_FACE || voxMeshData[voxIndex].includeForward || voxMeshData[voxIndex].includeLeft || voxMeshData[voxIndex].includeDown) { voxMeshData[voxIndex].vertexIndexOffsets[4] = voxMeshData[voxIndex].numVertices++; voxMeshData[voxIndex].vertexPositionOffsets[voxMeshData[voxIndex].vertexIndexOffsets[4]] = new Vector3(-0.5f, -0.5f, 0.5f); } if (optimization != NPVoxOptimization.PER_FACE || voxMeshData[voxIndex].includeForward || voxMeshData[voxIndex].includeRight || voxMeshData[voxIndex].includeDown) { voxMeshData[voxIndex].vertexIndexOffsets[5] = voxMeshData[voxIndex].numVertices++; voxMeshData[voxIndex].vertexPositionOffsets[voxMeshData[voxIndex].vertexIndexOffsets[5]] = new Vector3(0.5f, -0.5f, 0.5f); } if (optimization != NPVoxOptimization.PER_FACE || voxMeshData[voxIndex].includeForward || voxMeshData[voxIndex].includeLeft || voxMeshData[voxIndex].includeUp) { voxMeshData[voxIndex].vertexIndexOffsets[6] = voxMeshData[voxIndex].numVertices++; voxMeshData[voxIndex].vertexPositionOffsets[voxMeshData[voxIndex].vertexIndexOffsets[6]] = new Vector3(-0.5f, 0.5f, 0.5f); } if (optimization != NPVoxOptimization.PER_FACE || voxMeshData[voxIndex].includeForward || voxMeshData[voxIndex].includeRight || voxMeshData[voxIndex].includeUp) { voxMeshData[voxIndex].vertexIndexOffsets[7] = voxMeshData[voxIndex].numVertices++; voxMeshData[voxIndex].vertexPositionOffsets[voxMeshData[voxIndex].vertexIndexOffsets[7]] = new Vector3(0.5f, 0.5f, 0.5f); } currentVertexIndex += voxMeshData[voxIndex].numVertices; voxIndex++; } } Array.Resize(ref voxMeshData, voxIndex); return(voxMeshData); }