public override bool PreDraw(SpriteBatch spriteBatch, Color lightColor) { float alpha = MathHelper.Clamp(projectile.localAI[0] / AppearTime, 0f, 1f) * MathHelper.Clamp((projectile.timeLeft - 50) / AppearTime, 0f, 1f); spriteBatch.End(); spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, Main.GameViewMatrix.TransformationMatrix); if (alpha > 0) { Vector2[] points = new Vector2[] { startingloc, startingloc + projectile.velocity }; TrailHelper trail = new TrailHelper("BasicEffectAlphaPass", mod.GetTexture("SmallLaser")); //UnifiedRandom rando = new UnifiedRandom(projectile.whoAmI); Color colorz = Color.Lerp(color1, Color.White, 0.50f); Color colorz2 = color2; trail.color = delegate(float percent) { return(Color.Lerp(colorz, colorz2, percent)); }; trail.projsize = Vector2.Zero; trail.coordOffset = new Vector2(0, Main.GlobalTime * -1f); trail.coordMultiplier = new Vector2(1f, 1f); trail.doFade = false; trail.trailThickness = 16; trail.trailThicknessIncrease = 0; //trail.capsize = new Vector2(6f, 0f); trail.strength = alpha * 1f; trail.DrawTrail(points.ToList(), projectile.Center); } Texture2D mainTex = SGAmod.ExtraTextures[96]; Texture2D glowTex = ModContent.GetTexture("SGAmod/Glow"); float alpha2 = MathHelper.Clamp(projectile.localAI[0] / 3f, 0f, 1f) * MathHelper.Clamp(projectile.timeLeft / 25f, 0f, 1f); if (GetType() != typeof(Accessories.RefractorLaserProj)) { spriteBatch.End(); spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.Additive, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, Main.GameViewMatrix.TransformationMatrix); Effect effect = SGAmod.TextureBlendEffect; effect.Parameters["coordMultiplier"].SetValue(new Vector2(1f, 1f)); effect.Parameters["coordOffset"].SetValue(new Vector2(0f, 0f)); effect.Parameters["noiseMultiplier"].SetValue(new Vector2(1f, 1f)); effect.Parameters["noiseOffset"].SetValue(new Vector2(0f, 0f)); effect.Parameters["Texture"].SetValue(SGAmod.Instance.GetTexture("Extra_49c")); effect.Parameters["noiseTexture"].SetValue(SGAmod.Instance.GetTexture("Extra_49c")); effect.Parameters["noiseProgress"].SetValue(projectile.localAI[0] / 30f); effect.Parameters["textureProgress"].SetValue(0f); effect.Parameters["noiseBlendPercent"].SetValue(1f); effect.Parameters["strength"].SetValue(alpha2); effect.Parameters["colorTo"].SetValue(color1.ToVector4() * new Vector4(0.5f, 0.5f, 0.5f, 1f)); effect.Parameters["colorFrom"].SetValue(Color.Black.ToVector4()); effect.CurrentTechnique.Passes["TextureBlend"].Apply(); Main.spriteBatch.Draw(mainTex, startingloc + projectile.velocity - Main.screenPosition, null, Color.White, projectile.rotation, mainTex.Size() / 2f, (alpha2 + (projectile.localAI[0] / 60f)) * 0.75f, default, 0);
public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime) { int eventIndex = msg.ReadRangedInteger(0, (int)Math.Ceiling(MaxNodeCount / (float)MaxNodesPerNetworkEvent)); int nodeCount = msg.ReadRangedInteger(0, MaxNodesPerNetworkEvent); int nodeStartIndex = eventIndex * MaxNodesPerNetworkEvent; Vector2[] nodePositions = new Vector2[nodeStartIndex + nodeCount]; for (int i = 0; i < nodes.Count && i < nodePositions.Length; i++) { nodePositions[i] = nodes[i]; } for (int i = 0; i < nodeCount; i++) { nodePositions[nodeStartIndex + i] = new Vector2(msg.ReadFloat(), msg.ReadFloat()); } if (nodePositions.Any(n => !MathUtils.IsValid(n))) { nodes.Clear(); return; } nodes = nodePositions.ToList(); UpdateSections(); Drawable = nodes.Any(); }
void GenerateLineVBO() { Vector2[] vecs = new Vector2[2]; uint[] inds = new uint[2]; inds[0] = 0; vecs[0] = new Vector2(0, 0); inds[1] = 1; vecs[1] = new Vector2(1, 0); Line = new VBO(); Line.Vertices = vecs.ToList(); Line.Indices = inds.ToList(); Line.GenerateVBO(); }
void GenerateSquareVBO() { Vector2[] vecs = new Vector2[4]; uint[] inds = new uint[4]; for (uint u = 0; u < 4; u++) { inds[u] = u; } vecs[0] = new Vector2(1, 0); vecs[1] = new Vector2(1, 1); vecs[2] = new Vector2(0, 1); vecs[3] = new Vector2(0, 0); Square = new VBO(); Square.Vertices = vecs.ToList(); Square.Indices = inds.ToList(); Square.GenerateVBO(); }
private static Rect BuildScreenRect(Vector2[] screenPoints) { List<Vector2> sp = screenPoints.ToList(); float minX = sp.Min(point => point.x); float maxX = sp.Max(point => point.x); float minY = sp.Min(point => point.y); float maxY = sp.Max(point => point.y); Rect screenRect = new Rect(minX, minY, maxX - minX + 1, maxY - minY + 1); screenRect.xMin = Mathf.Clamp(screenRect.xMin, 1.0f, Screen.width - 1); screenRect.xMax = Mathf.Clamp(screenRect.xMax, 1.0f, Screen.width - 1); screenRect.yMin = Mathf.Clamp(screenRect.yMin, 1.0f, Screen.height - 1); screenRect.yMax = Mathf.Clamp(screenRect.yMax, 1.0f, Screen.height - 1); return screenRect; }
public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime) { nodes.Clear(); int nodeCount = msg.ReadByte(); Vector2[] nodePositions = new Vector2[nodeCount]; for (int i = 0; i < nodeCount; i++) { nodePositions[i] = new Vector2(msg.ReadFloat(), msg.ReadFloat()); } if (nodePositions.Any(n => !MathUtils.IsValid(n))) { return; } nodes = nodePositions.ToList(); UpdateSections(); Drawable = nodes.Any(); }
private void CreateMadelineSprite(bool badeline = false) { PlayerSpriteMode mode; if (badeline) { mode = PlayerSpriteMode.Badeline; } else { bool backpack = player.SceneAs <Level>()?.Session.Inventory.Backpack ?? true; mode = backpack ? PlayerSpriteMode.Madeline : PlayerSpriteMode.MadelineNoBackpack; } PlayerSprite origSprite = player.Sprite; if (playerSprite != null) { origSprite = playerSprite; } playerSprite = new PlayerSprite(mode) { Position = origSprite.Position, Rotation = origSprite.Rotation, HairCount = origSprite.HairCount, Scale = origSprite.Scale, Rate = origSprite.Rate, Justify = origSprite.Justify }; if (player.StateMachine.State == Player.StStarFly) { playerSprite.Color = StarFlyColor; } playerSprite.Scale.X = playerSprite.Scale.Abs().X *(int)facing; playerSprite.Active = false; try { if (!string.IsNullOrEmpty(origSprite.CurrentAnimationID)) { playerSprite.Play(origSprite.CurrentAnimationID); playerSprite.SetAnimationFrame(origSprite.CurrentAnimationFrame); } } // ReSharper disable once EmptyGeneralCatchClause catch (Exception) { } if (playerHair == null) { playerHair = new PlayerHair(playerSprite) { Alpha = player.Hair.Alpha, Facing = facing, Border = player.Hair.Border, DrawPlayerSpriteOutline = player.Hair.DrawPlayerSpriteOutline }; Vector2[] nodes = new Vector2[player.Hair.Nodes.Count]; player.Hair.Nodes.CopyTo(nodes); playerHair.Nodes = nodes.ToList(); playerHair.Active = false; } Color hairColor = Player.NormalHairColor; if (player.StateMachine.State != Player.StStarFly) { switch (player.Dashes) { case 0: hairColor = badeline ? Player.UsedBadelineHairColor : Player.UsedHairColor; break; case 1: hairColor = badeline ? Player.NormalBadelineHairColor : Player.NormalHairColor; break; case 2: hairColor = badeline ? Player.TwoDashesBadelineHairColor : Player.TwoDashesHairColor; break; } } else { hairColor = StarFlyColor; } playerHair.Color = hairColor; }
public static dynamic ParseBufferViews(this byte[] bufferBytes, Accessor accessors, BufferView bufferViews) { if (accessors.ComponentType == Accessor.ComponentTypeEnum.UNSIGNED_SHORT && accessors.Type == Accessor.TypeEnum.VEC4) { byte[] subarray = bufferBytes.SubArray(bufferViews.ByteOffset, bufferViews.ByteLength); var size = subarray.Count() / sizeof(ushort); var ints = new int[size]; for (var index = 0; index < size; index++) { ints[index] = BitConverter.ToUInt16(subarray, index * sizeof(ushort)); } Vector4[] vectors = new Vector4[ints.Count() / 4]; for (int f = 0; f < ints.Count(); f += 4) { vectors[f / 4] = new Vector4(ints[f], ints[f + 1], ints[f + 2], ints[f + 3]); } return(vectors.ToList()); } if (accessors.ComponentType == Accessor.ComponentTypeEnum.UNSIGNED_SHORT && accessors.Type == Accessor.TypeEnum.SCALAR) { byte[] subarray = bufferBytes.SubArray(bufferViews.ByteOffset, bufferViews.ByteLength); var size = subarray.Count() / sizeof(ushort); int[] ints = new int[size]; for (var index = 0; index < size; index++) { ints[index] = BitConverter.ToUInt16(subarray, index * sizeof(ushort)); } return(ints); } if (accessors.ComponentType == Accessor.ComponentTypeEnum.UNSIGNED_INT && accessors.Type == Accessor.TypeEnum.SCALAR) { byte[] subarray = bufferBytes.SubArray(bufferViews.ByteOffset, bufferViews.ByteLength); var size = subarray.Count() / sizeof(uint); int[] ints = new int[size]; for (var index = 0; index < size; index++) { ints[index] = (int)BitConverter.ToUInt32(subarray, index * sizeof(uint)); } return(ints); } if (accessors.ComponentType == Accessor.ComponentTypeEnum.UNSIGNED_BYTE && accessors.Type == Accessor.TypeEnum.SCALAR) { byte[] subarray = bufferBytes.SubArray(bufferViews.ByteOffset, bufferViews.ByteLength); int[] ints = new int[subarray.Length]; for (var index = 0; index < subarray.Length; index++) { ints[index] = subarray[index]; } return(ints); } if (accessors.ComponentType == Accessor.ComponentTypeEnum.FLOAT && accessors.Type == Accessor.TypeEnum.VEC3) { byte[] subarray = bufferBytes.SubArray(bufferViews.ByteOffset, bufferViews.ByteLength); var size = subarray.Count() / sizeof(float); var floats = new float[size]; for (var index = 0; index < size; index++) { floats[index] = BitConverter.ToSingle(subarray, index * sizeof(float)); } Vector3[] vectors = new Vector3[floats.Count() / 3]; for (int f = 0; f < floats.Count(); f += 3) { vectors[f / 3] = new Vector3(floats[f], floats[f + 1], floats[f + 2]); } return(vectors.ToList()); } if (accessors.ComponentType == Accessor.ComponentTypeEnum.FLOAT && accessors.Type == Accessor.TypeEnum.VEC2) { byte[] subarray = bufferBytes.SubArray(bufferViews.ByteOffset, bufferViews.ByteLength); var size = subarray.Count() / sizeof(float); var floats = new float[size]; for (var index = 0; index < size; index++) { floats[index] = BitConverter.ToSingle(subarray, index * sizeof(float)); } Vector2[] vectors = new Vector2[floats.Count() / 2]; for (int f = 0; f < floats.Count(); f += 2) { vectors[f / 2] = new Vector2(floats[f], floats[f + 1]); } return(vectors.ToList()); } if (accessors.ComponentType == Accessor.ComponentTypeEnum.FLOAT && accessors.Type == Accessor.TypeEnum.VEC4) { byte[] subarray = bufferBytes.SubArray(bufferViews.ByteOffset, bufferViews.ByteLength); var size = subarray.Count() / sizeof(float); var floats = new float[size]; for (var index = 0; index < size; index++) { floats[index] = BitConverter.ToSingle(subarray, index * sizeof(float)); } Vector4[] vectors = new Vector4[floats.Count() / 4]; for (int f = 0; f < floats.Count(); f += 4) { vectors[f / 4] = new Vector4(floats[f], floats[f + 1], floats[f + 2], floats[f + 3]); } return(vectors.ToList()); } return(null); }
/*create meash for linear rendered 3D object*/ public void CreateMesh(Curve curve, float offset, Material linearMaterial, Material crossMaterial, Polygon cross) { List <Vector2> fragments = cross.toFragments(); int segmentCount = Mathf.CeilToInt(curve.length * curve.maximumCurvature / maxAngleDiff); int base_vcount = (segmentCount + 1) * fragments.Count; int base_tcount = segmentCount * 2 * 3 * fragments.Count; int[] crossTriangles = cross.createMeshTriangle(); int cross_vcount = fragments.Count; int cross_tcount = crossTriangles.Length; Vector2[] crossUVs = cross.createUV(); Vector3[] all_vertices = new Vector3[base_vcount + 2 * cross_vcount]; int[] linear_triangles = new int[base_tcount]; Vector2[] linearUVs = new Vector2[base_vcount]; for (int i = 0; i != segmentCount + 1; ++i) { Vector3 roadPoint = curve.At(1.0f / segmentCount * i); float direction = curve.Angle_2d(1.0f / segmentCount * i) - Mathf.PI / 2; List <Vector3> localFragments = fragments.ConvertAll((input) => roadPoint + Algebra.toVector3(Algebra.twodRotate(Vector2.right * (offset + input.x), direction)) + Vector3.up * input.y); /*stretch Z*/ List <float> cross_y_offset = cross.getVResizeOffset(roadPoint.y); for (int j = 0; j != localFragments.Count; ++j) { localFragments[j] += Vector3.up * cross_y_offset[j]; } float cross_diameter = fragments.Sum((input) => input.magnitude); float partial_diameter = 0f; for (int j = i * cross_vcount, local_j = 0; j != i * cross_vcount + cross_vcount; ++j, ++local_j) { all_vertices[j] = localFragments[local_j]; linearUVs[j] = new Vector2(partial_diameter / cross_diameter, i * 1.0f / segmentCount * curve.length / cross_diameter); partial_diameter += fragments[local_j].magnitude; } } for (int i = 0; i != cross_vcount; ++i) { all_vertices[base_vcount + i] = all_vertices[i]; all_vertices[base_vcount + cross_vcount + i] = all_vertices[base_vcount - cross_vcount + i]; } for (int i = 0, triangle = 0; i != segmentCount; ++i) { for (int j = 0; j != cross_vcount; ++j, triangle += 6) { linear_triangles[triangle] = i * cross_vcount + j; linear_triangles[triangle + 1] = i * cross_vcount + (j + 1) % cross_vcount; linear_triangles[triangle + 2] = (i + 1) * cross_vcount + j; linear_triangles[triangle + 3] = i * cross_vcount + (j + 1) % cross_vcount; linear_triangles[triangle + 4] = (i + 1) * cross_vcount + (j + 1) % cross_vcount; linear_triangles[triangle + 5] = (i + 1) * cross_vcount + j; } } int[] cross_triangles = new int[2 * cross_tcount]; /*Add tris at start*/ for (int j = 0; j != cross_tcount; ++j) { cross_triangles[j] = crossTriangles[j] + base_vcount; } /*Add tris at end*/ for (int j = 0; j != cross_tcount; ++j) { if (j % 3 == 1) { cross_triangles[cross_tcount + j] = crossTriangles[j + 1]; } else { if (j % 3 == 2) { cross_triangles[cross_tcount + j] = crossTriangles[j - 1]; } else { cross_triangles[cross_tcount + j] = crossTriangles[j]; } } cross_triangles[cross_tcount + j] += (base_vcount + cross_vcount); } Vector2[] modifiedCrossUVs = new Vector2[base_vcount + 2 * cross_vcount]; for (int i = 0; i != base_vcount; ++i) { modifiedCrossUVs[i] = linearUVs[i]; } for (int i = 0; i != cross_vcount; ++i) { modifiedCrossUVs[i + base_vcount] = modifiedCrossUVs[i + base_vcount + cross_vcount] = crossUVs[i]; } GetComponent <MeshRenderer>().sharedMaterials = new Material[2] { crossMaterial, linearMaterial }; MeshFilter meshFilter = GetComponent <MeshFilter>(); if (meshFilter.sharedMesh == null) { meshFilter.sharedMesh = new Mesh(); } meshFilter.sharedMesh.subMeshCount = 2; meshFilter.sharedMesh.SetVertices(all_vertices.ToList()); meshFilter.sharedMesh.SetTriangles(cross_triangles, 0); meshFilter.sharedMesh.SetTriangles(linear_triangles, 1); meshFilter.sharedMesh.SetUVs(0, modifiedCrossUVs.ToList()); }
/// <summary> /// Partitions a connected node group by: /// 1. Repeatedly running BFS on its nodes to find cycles and removing edges for the next BFS until no more /// cycles can be found. /// 1.1 Note that the BFS only runs on nodes with two or less VALID EDGES. Edges are only removed IFF either /// of its vertices has two or less valid edges. This ensures we do not remove an edge that could be used /// twice, for example two adjacent cycles that share an edge. /// 2. The cycle is added to a list of perimeters (AKA a list of nodes) IFF it is NOT a hole. /// </summary> /// <param name="connectedGroup">ConnectedNodeGroup that is being partitioned.</param> /// <param name="idsContainedInGroup">The IDs of the ConnectedNodeGroups contained within <param>connectedGroup</param></param> /// <param name="connectedGroups">List of all ConnectedNodeGroups.</param> /// <param name="nodes">List of all nodes.</param> /// <param name="holes">Holes of the polygon that was made into a PolygonSplittingGraph.</param> /// <returns></returns> public static List <ChordlessPolygon> PartitionConnectedNodeGroup(ConnectedNodeGroup connectedGroup, SortedDictionary <int, HashSet <int> > idsContainedInGroup, SortedList <int, ConnectedNodeGroup> connectedGroups, SortedList <int, PolygonSplittingGraphNode> nodes, List <Vector2>[] holes) { if (connectedGroup is null) { throw new ArgumentNullException(nameof(connectedGroup)); } if (idsContainedInGroup is null) { throw new ArgumentNullException(nameof(idsContainedInGroup)); } if (connectedGroups is null) { throw new ArgumentNullException(nameof(connectedGroups)); } if (nodes is null) { throw new ArgumentNullException(nameof(nodes)); } if (holes is null) { throw new ArgumentNullException(nameof(holes)); } var outerPerimCycle = new List <PolygonSplittingGraphNode>(); var polyCycles = new List <List <PolygonSplittingGraphNode> >(); var holeCycles = new List <List <PolygonSplittingGraphNode> >(); List <List <PolygonSplittingGraphNode> > allFaces = _GetAllFaces(connectedGroup); var uniqueFaces = new List <List <Vector2> >(); foreach (List <PolygonSplittingGraphNode> newFace in allFaces) { //construct Vector2[] or List<Vector2> describing face perim in Vector2s var newFacePerim = new Vector2[newFace.Count]; for (int i = 0; i < newFace.Count; i++) { PolygonSplittingGraphNode node = newFace[i]; newFacePerim[i] = new Vector2(node.x, node.y); } bool newFaceUnique = true; foreach (List <Vector2> uniqueFace in uniqueFaces) { if (GeometryFuncs.ArePolysIdentical(uniqueFace.ToArray(), newFacePerim)) { newFaceUnique = false; break; } } if (newFaceUnique) { uniqueFaces.Add(newFacePerim.ToList()); if (IsCycleHole(newFacePerim, holes)) { holeCycles.Add(newFace); } else if (IsCycleOuterPerim(newFacePerim, connectedGroup.outerPerimNodes)) { outerPerimCycle.AddRange(newFace); } else if (IsCycleComplex(newFacePerim)) { continue; } else { polyCycles.Add(newFace); } } } var innerHoles = holeCycles.Select(_FinaliseInnerHole).ToList(); var partitions = new List <ChordlessPolygon>(); foreach (List <PolygonSplittingGraphNode> polyCycle in polyCycles) { partitions.Add(_FinalisePartition(polyCycle, connectedGroup, connectedGroups, idsContainedInGroup, nodes, innerHoles)); } if (partitions.Count == 0 && outerPerimCycle.Count > 0) //planar face that represents the outer perim is only relevant IFF there are no other (non-hole) faces { partitions.Add(_FinalisePartition(outerPerimCycle, connectedGroup, connectedGroups, idsContainedInGroup, nodes, innerHoles)); } return(partitions); }
private void DrawLine(Vector3 startPoint, Vector3 finishPoint) { Vector3 firstNewVerticle = RevertInYBasedOnPoint(finishPoint, SetPositionOnCircle(finishPoint, lineWeight, -AngleBetweenTwoPoints(startPoint, finishPoint))); Vector3 secondNewVerticle = SetPositionOnCircle(finishPoint, lineWeight, AngleBetweenTwoPoints(startPoint, finishPoint)); if (_mesh.vertices.Length >= 2) { var lenght = _mesh.vertices.Length; var copyOfVertices = _mesh.vertices; copyOfVertices[lenght - 1] = Vector3.Lerp(_mesh.vertices[lenght - 1], secondNewVerticle, .5f); copyOfVertices[lenght - 2] = Vector3.Lerp(_mesh.vertices[lenght - 2], firstNewVerticle, .5f); _mesh.vertices = copyOfVertices; } //verts Vector3[] verts = new Vector3[] { firstNewVerticle, secondNewVerticle }; _mesh.vertices = AddArrays <Vector3>(_mesh.vertices, verts); //normals if (_mesh.normals.Length > 1) { _mesh.normals[_mesh.normals.Length - 1] = new Vector3(0, 0, -1); _mesh.normals[_mesh.normals.Length - 2] = new Vector3(0, 0, -1); } //tris int vertLenght = _mesh.vertices.Length; if (vertLenght >= 4) { int[] tris = new int[] { vertLenght - 4, vertLenght - 3, vertLenght - 2, vertLenght - 2, vertLenght - 3, vertLenght - 1 }; _mesh.triangles = AddArrays <int>(_mesh.triangles, tris); } Vector2[] tempUvs = new Vector2[_mesh.vertices.Length]; for (int i = 0; i < _mesh.vertices.Length; i++) { switch (i % 4) { case 0: tempUvs[i] = new Vector2(0, 0); break; case 1: tempUvs[i] = new Vector2(0, 1); break; case 2: tempUvs[i] = new Vector2(1, 0); break; case 3: tempUvs[i] = new Vector2(1, 1); break; } } _mesh.SetUVs(0, tempUvs.ToList()); _mesh.RecalculateBounds(); _mesh.RecalculateNormals(); }
public static bool ImportNewObjPatternUV(FullModelData fm, string filepath) { Log.Default.Info("Importing new obj with file for UV patterns: {0}", filepath); //Preload the .obj List <obj_data> objects = new List <obj_data>(); try { using (FileStream fs = new FileStream(filepath, FileMode.Open, FileAccess.Read)) { using (StreamReader sr = new StreamReader(fs)) { string line; obj_data obj = new obj_data(); bool reading_faces = false; int prevMaxVerts = 0; int prevMaxUvs = 0; int prevMaxNorms = 0; while ((line = sr.ReadLine()) != null) { //preloading objects if (line.StartsWith("#")) { continue; } else if (line.StartsWith("o ") || line.StartsWith("g ")) { if (reading_faces) { reading_faces = false; prevMaxVerts += obj.verts.Count; prevMaxUvs += obj.uv.Count; prevMaxNorms += obj.normals.Count; objects.Add(obj); obj = new obj_data(); } obj.object_name = line.Substring(2); } else if (line.StartsWith("usemtl ")) { obj.material_name = line.Substring(2); } else if (line.StartsWith("v ")) { if (reading_faces) { reading_faces = false; prevMaxVerts += obj.verts.Count; prevMaxUvs += obj.uv.Count; prevMaxNorms += obj.normals.Count; objects.Add(obj); obj = new obj_data(); } String[] verts = line.Replace(" ", " ").Split(' '); Vector3 vert = new Vector3(); vert.X = Convert.ToSingle(verts[1], CultureInfo.InvariantCulture); vert.Y = Convert.ToSingle(verts[2], CultureInfo.InvariantCulture); vert.Z = Convert.ToSingle(verts[3], CultureInfo.InvariantCulture); obj.verts.Add(vert); } else if (line.StartsWith("vt ")) { if (reading_faces) { reading_faces = false; prevMaxVerts += obj.verts.Count; prevMaxUvs += obj.uv.Count; prevMaxNorms += obj.normals.Count; objects.Add(obj); obj = new obj_data(); } String[] uvs = line.Split(' '); Vector2 uv = new Vector2(); uv.X = Convert.ToSingle(uvs[1], CultureInfo.InvariantCulture); uv.Y = Convert.ToSingle(uvs[2], CultureInfo.InvariantCulture); obj.uv.Add(uv); } else if (line.StartsWith("vn ")) { if (reading_faces) { reading_faces = false; prevMaxVerts += obj.verts.Count; prevMaxUvs += obj.uv.Count; prevMaxNorms += obj.normals.Count; objects.Add(obj); obj = new obj_data(); } String[] norms = line.Split(' '); Vector3 norm = new Vector3(); norm.X = Convert.ToSingle(norms[1], CultureInfo.InvariantCulture); norm.Y = Convert.ToSingle(norms[2], CultureInfo.InvariantCulture); norm.Z = Convert.ToSingle(norms[3], CultureInfo.InvariantCulture); obj.normals.Add(norm); } else if (line.StartsWith("f ")) { reading_faces = true; String[] faces = line.Substring(2).Split(' '); for (int x = 0; x < 3; x++) { ushort fa = 0, fb = 0, fc = 0; if (obj.verts.Count > 0) { fa = (ushort)(Convert.ToUInt16(faces[x].Split('/')[0]) - prevMaxVerts - 1); } if (obj.uv.Count > 0) { fb = (ushort)(Convert.ToUInt16(faces[x].Split('/')[1]) - prevMaxUvs - 1); } if (obj.normals.Count > 0) { fc = (ushort)(Convert.ToUInt16(faces[x].Split('/')[2]) - prevMaxNorms - 1); } if (fa < 0 || fb < 0 || fc < 0) { throw new Exception("What the actual flapjack, something is *VERY* wrong"); } obj.faces.Add(new Face(fa, fb, fc)); } } } if (!objects.Contains(obj)) { objects.Add(obj); } } } //Read each object foreach (obj_data obj in objects) { //Locate the proper model uint modelSectionid = 0; foreach (KeyValuePair <uint, ISection> pair in fm.parsed_sections) { if (modelSectionid != 0) { break; } if (pair.Value is Model) { UInt64 tryp; if (UInt64.TryParse(obj.object_name, out tryp)) { if (tryp == ((Model)pair.Value).HashName.Hash) { modelSectionid = pair.Key; } } else { if (Hash64.HashString(obj.object_name) == ((Model)pair.Value).HashName.Hash) { modelSectionid = pair.Key; } } } } //Apply new changes if (modelSectionid == 0) { continue; } Model model_data_section = (Model)fm.parsed_sections[modelSectionid]; PassthroughGP passthrough_section = model_data_section.PassthroughGP; Geometry geometry_section = passthrough_section.Geometry; Topology topology_section = passthrough_section.Topology; //Arrange UV and Normals Vector2[] new_arranged_UV = new Vector2[geometry_section.verts.Count]; for (int x = 0; x < new_arranged_UV.Length; x++) { new_arranged_UV[x] = new Vector2(100f, 100f); } Vector2 sentinel = new Vector2(100f, 100f); if (topology_section.facelist.Count != obj.faces.Count / 3) { return(false); } for (int fcount = 0; fcount < topology_section.facelist.Count; fcount += 3) { Face f1 = obj.faces[fcount + 0]; Face f2 = obj.faces[fcount + 1]; Face f3 = obj.faces[fcount + 2]; //UV if (obj.uv.Count > 0) { if (new_arranged_UV[topology_section.facelist[fcount / 3 + 0].a].Equals(sentinel)) { new_arranged_UV[topology_section.facelist[fcount / 3 + 0].a] = obj.uv[f1.b]; } if (new_arranged_UV[topology_section.facelist[fcount / 3 + 0].b].Equals(sentinel)) { new_arranged_UV[topology_section.facelist[fcount / 3 + 0].b] = obj.uv[f2.b]; } if (new_arranged_UV[topology_section.facelist[fcount / 3 + 0].c].Equals(sentinel)) { new_arranged_UV[topology_section.facelist[fcount / 3 + 0].c] = obj.uv[f3.b]; } } } geometry_section.UVs[1] = new_arranged_UV.ToList(); passthrough_section.Geometry.UVs[1] = new_arranged_UV.ToList(); } } catch (Exception exc) { System.Windows.Forms.MessageBox.Show(exc.ToString()); return(false); } return(true); }
private static void AddObject(bool is_new, obj_data obj, Model model_data_section, PassthroughGP passthrough_section, Geometry geometry_section, Topology topology_section) { List <Face> called_faces = new List <Face>(); List <int> duplicate_verts = new List <int>(); Dictionary <int, Face> dup_faces = new Dictionary <int, Face>(); bool broken = false; for (int x_f = 0; x_f < obj.faces.Count; x_f++) { Face f = obj.faces[x_f]; broken = false; foreach (Face called_f in called_faces) { if (called_f.a == f.a && called_f.b != f.b) { duplicate_verts.Add(x_f); broken = true; break; } } if (!broken) { called_faces.Add(f); } } Dictionary <int, Face> done_faces = new Dictionary <int, Face>(); foreach (int dupe in duplicate_verts) { int replacedF = -1; foreach (KeyValuePair <int, Face> pair in done_faces) { Face f = pair.Value; if (f.a == obj.faces[dupe].a && f.b == obj.faces[dupe].b) { replacedF = pair.Key; } } Face new_face; if (replacedF > -1) { new_face = new Face(obj.faces[replacedF].a, obj.faces[replacedF].b, obj.faces[dupe].c); } else { new_face = new Face((ushort)obj.verts.Count, obj.faces[dupe].b, obj.faces[dupe].c); obj.verts.Add(obj.verts[obj.faces[dupe].a]); done_faces.Add(dupe, obj.faces[dupe]); } obj.faces[dupe] = new_face; } Vector3 new_Model_data_bounds_min = new Vector3(); // Z (max), X (low), Y (low) Vector3 new_Model_data_bounds_max = new Vector3(); // Z (low), X (max), Y (max) foreach (Vector3 vert in obj.verts) { //Z // Note these were previously broken if (vert.Z < new_Model_data_bounds_min.Z) { new_Model_data_bounds_min.Z = vert.Z; } if (vert.Z > new_Model_data_bounds_max.Z) { new_Model_data_bounds_max.Z = vert.Z; } //X if (vert.X < new_Model_data_bounds_min.X) { new_Model_data_bounds_min.X = vert.X; } if (vert.X > new_Model_data_bounds_max.X) { new_Model_data_bounds_max.X = vert.X; } //Y if (vert.Y < new_Model_data_bounds_min.Y) { new_Model_data_bounds_min.Y = vert.Y; } if (vert.Y > new_Model_data_bounds_max.Y) { new_Model_data_bounds_max.Y = vert.Y; } } //Arrange UV and Normals List <Vector3> new_arranged_Geometry_normals = new List <Vector3>(); List <Vector3> new_arranged_Geometry_unknown20 = new List <Vector3>(); List <Vector3> new_arranged_Geometry_unknown21 = new List <Vector3>(); List <int> added_uvs = new List <int>(); List <int> added_normals = new List <int>(); Vector2[] new_arranged_UV = new Vector2[obj.verts.Count]; for (int x = 0; x < new_arranged_UV.Length; x++) { new_arranged_UV[x] = new Vector2(100f, 100f); } Vector2 sentinel = new Vector2(100f, 100f); Vector3[] new_arranged_Normals = new Vector3[obj.verts.Count]; for (int x = 0; x < new_arranged_Normals.Length; x++) { new_arranged_Normals[x] = new Vector3(0f, 0f, 0f); } Vector3[] new_arranged_unknown20 = new Vector3[obj.verts.Count]; Vector3[] new_arranged_unknown21 = new Vector3[obj.verts.Count]; List <Face> new_faces = new List <Face>(); for (int fcount = 0; fcount < obj.faces.Count; fcount += 3) { Face f1 = obj.faces[fcount + 0]; Face f2 = obj.faces[fcount + 1]; Face f3 = obj.faces[fcount + 2]; //UV if (obj.uv.Count > 0) { if (new_arranged_UV[f1.a].Equals(sentinel)) { new_arranged_UV[f1.a] = obj.uv[f1.b]; } if (new_arranged_UV[f2.a].Equals(sentinel)) { new_arranged_UV[f2.a] = obj.uv[f2.b]; } if (new_arranged_UV[f3.a].Equals(sentinel)) { new_arranged_UV[f3.a] = obj.uv[f3.b]; } } //normal if (obj.normals.Count > 0) { new_arranged_Normals[f1.a] = obj.normals[f1.c]; new_arranged_Normals[f2.a] = obj.normals[f2.c]; new_arranged_Normals[f3.a] = obj.normals[f3.c]; } Face new_f = new Face(f1.a, f2.a, f3.a); new_faces.Add(new_f); } for (int x = 0; x < new_arranged_Normals.Length; x++) { new_arranged_Normals[x] = Vector3.Normalize(new_arranged_Normals[x]); } List <Vector3> obj_verts = obj.verts; ComputeTangentBasis(ref new_faces, ref obj_verts, ref new_arranged_UV, ref new_arranged_Normals, ref new_arranged_unknown20, ref new_arranged_unknown21); List <RenderAtom> new_Model_items2 = new List <RenderAtom>(); foreach (RenderAtom modelitem in model_data_section.RenderAtoms) { RenderAtom new_model_item = new RenderAtom(); new_model_item.BaseVertex = modelitem.BaseVertex; new_model_item.TriangleCount = (uint)new_faces.Count; new_model_item.BaseIndex = modelitem.BaseIndex; new_model_item.GeometrySliceLength = (uint)obj.verts.Count; new_model_item.MaterialId = modelitem.MaterialId; new_Model_items2.Add(new_model_item); } model_data_section.RenderAtoms = new_Model_items2; if (model_data_section.version != 6) { model_data_section.BoundsMin = new_Model_data_bounds_min; model_data_section.BoundsMax = new_Model_data_bounds_max; model_data_section.BoundingRadius = obj.verts.Select(i => i.Length()).Max(); } geometry_section.vert_count = (uint)obj.verts.Count; geometry_section.verts = obj.verts; geometry_section.normals = new_arranged_Normals.ToList(); geometry_section.UVs[0] = new_arranged_UV.ToList(); geometry_section.binormals = new_arranged_unknown20.ToList(); geometry_section.tangents = new_arranged_unknown21.ToList(); topology_section.facelist = new_faces; }
private void ProcessMesh(List <Vector3> positions, MeshFilter filter, bool ground) { if (positions.Count >= 3) { //UVs var uvs = new Vector2[positions.Count]; for (var x = 0; x < positions.Count; x++) { if ((x % 2) == 0) { uvs[x] = new Vector2(0, 0); } else { uvs[x] = new Vector2(1, 1); } } int[] tris; if (ground) { tris = _triangulator .TriangulatePolygon( positions.Select(position => new Vector2(position.x, position.z)).ToArray()); } else { tris = new int[3 * positions.Count]; var baseIndex = 0; for (var x = 0; x < tris.Length; x += 3) { if (x % 2 == 0) { tris[x] = baseIndex % positions.Count; tris[x + 1] = (baseIndex + 1) % positions.Count; tris[x + 2] = (baseIndex + 2) % positions.Count; } else { tris[x + 2] = baseIndex % positions.Count; tris[x + 1] = (baseIndex + 1) % positions.Count; tris[x] = (baseIndex + 2) % positions.Count; } baseIndex++; } } if (filter.mesh == null) { filter.mesh = new Mesh(); } filter.mesh.Clear(); filter.mesh.SetVertices(positions); filter.mesh.SetUVs(0, uvs.ToList()); filter.mesh.SetTriangles(tris, 0); filter.mesh.name = "MyMesh"; filter.mesh.RecalculateNormals(); filter.mesh.RecalculateBounds(); } else { filter.mesh.Clear(); } }
public static AbstractGeometry3D BuildSkyPlane(SkyPlaneData data) { var count = (data.PlaneResolution + 1) * (data.PlaneResolution + 1); var points = new Vector3[count]; var tex = new Vector2[count]; // Determine the size of each quad on the sky plane. float quadSize = data.PlaneWidth / (float)data.PlaneResolution; // Calculate the radius of the sky plane based on the width. float radius = data.PlaneWidth / 2.0f; // Calculate the height constant to increment by. float constant = (data.PlaneTop - data.PlaneBottom) / (radius * radius); // Calculate the texture coordinate increment value. float textureDelta = (float)data.TextureRepeat / (float)data.PlaneResolution; // Loop through the sky plane and build the coordinates based on the increment values given. for (int j = 0; j <= data.PlaneResolution; j++) { for (int i = 0; i <= data.PlaneResolution; i++) { // Calculate the vertex coordinates. float positionX = (-0.5f * data.PlaneWidth) + ((float)i * quadSize); float positionZ = (-0.5f * data.PlaneWidth) + ((float)j * quadSize); float positionY = data.PlaneTop - (constant * ((positionX * positionX) + (positionZ * positionZ))); // Calculate the texture coordinates. float tu = (float)i * textureDelta; float tv = (float)j * textureDelta; // Calculate the index into the sky plane array to add this coordinate. int index = j * (data.PlaneResolution + 1) + i; // Add the coordinates to the sky plane array. points[index] = new Vector3(positionX, positionY, positionZ); tex[index] = new Vector2(tu, tv); } } var vertexCount = (data.PlaneResolution + 1) * (data.PlaneResolution + 1) * 6; var indices = new int[vertexCount]; var positions = new Vector3[vertexCount]; var texture = new Vector2[vertexCount]; // Initialize the index into the vertex array. int indx = 0; // Load the vertex and index array with the sky plane array data. for (int j = 0; j < data.PlaneResolution; j++) { for (int i = 0; i < data.PlaneResolution; i++) { int index1 = j * (data.PlaneResolution + 1) + i; int index2 = j * (data.PlaneResolution + 1) + (i + 1); int index3 = (j + 1) * (data.PlaneResolution + 1) + i; int index4 = (j + 1) * (data.PlaneResolution + 1) + (i + 1); // Triangle 1 - Upper Left positions[indx] = points[index1]; texture[indx] = tex[index1]; indices[indx] = indx; indx++; // Triangle 1 - Upper Right positions[indx] = points[index2]; texture[indx] = tex[index2]; indices[indx] = indx; indx++; // Triangle 1 - Bottom Left positions[indx] = points[index3]; texture[indx] = tex[index3]; indices[indx] = indx; indx++; // Triangle 2 - Bottom Left positions[indx] = points[index3]; texture[indx] = tex[index3]; indices[indx] = indx; indx++; // Triangle 2 - Upper Right positions[indx] = points[index2]; texture[indx] = tex[index2]; indices[indx] = indx; indx++; // Triangle 2 - Bottom Right positions[indx] = points[index4]; texture[indx] = tex[index4]; indices[indx] = indx; indx++; } } return(new AbstractGeometry3D { Positions = positions.ToList(), Indices = indices.ToList(), TextureCoordinates = texture.ToList(), }); }
public void CreateMesh(Vector2[] vertsToCopy, Transform transform,int triangleIndex) { List<Vector3> resultsLocal = new List<Vector3>(); List<int> resultsTriIndexesLocal = new List<int>(); List<int> resultsTriIndexesReversedLocal = new List<int>(); List<Vector2> uvsLocal = new List<Vector2>(); List<Vector3> normalsLocal = new List<Vector3>(); Sprite spr = transform.GetComponent<SpriteRenderer>().sprite; Rect rec = spr.rect; Vector3 bound = transform.GetComponent<Renderer>().bounds.max- transform.GetComponent<Renderer>().bounds.min ; TextureImporter textureImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(spr)) as TextureImporter; List<PolygonPoint> p2 = new List<PolygonPoint>(); if (triangleIndex > 0) { vertsToCopy = CreateSubVertPoints (spr.bounds,vertsToCopy.ToList(), triangleIndex).ToArray(); } int i = 0; for (i = 0; i < vertsToCopy.Count(); i ++) { p2.Add(new PolygonPoint(vertsToCopy [i].x, vertsToCopy [i].y)); } Polygon _polygon = new Polygon(p2); if (triangleIndex > 0) { List<TriangulationPoint> triPoints = GenerateGridPoints (spr.bounds, triangleIndex, _polygon); _polygon.AddSteinerPoints (triPoints); } P2T.Triangulate(_polygon); int idx = 0; foreach (DelaunayTriangle triangle in _polygon.Triangles) { Vector3 v = new Vector3(); foreach (TriangulationPoint p in triangle.Points) { v = new Vector3((float)p.X, (float)p.Y,0); if(!resultsLocal.Contains(v)) { resultsLocal.Add(v); resultsTriIndexesLocal.Add(idx); Vector2 newUv = new Vector2((v.x/bound.x) + 0.5f, (v.y /bound.y) + 0.5f); newUv.x *= rec.width/ spr.texture.width; newUv.y *= rec.height/ spr.texture.height; newUv.x += (rec.x)/ spr.texture.width; newUv.y += (rec.y) / spr.texture.height; SpriteMetaData[] smdArray = textureImporter.spritesheet; Vector2 pivot = new Vector2(.0f,.0f);; for (int k = 0; k < smdArray.Length; k++) { if (smdArray[k].name == spr.name) { switch(smdArray[k].alignment) { case(0): smdArray[k].pivot = Vector2.zero; break; case(1): smdArray[k].pivot = new Vector2(0f,1f) -new Vector2(.5f,.5f); break; case(2): smdArray[k].pivot = new Vector2(0.5f,1f) -new Vector2(.5f,.5f); break; case(3): smdArray[k].pivot = new Vector2(1f,1f) -new Vector2(.5f,.5f); break; case(4): smdArray[k].pivot = new Vector2(0f,.5f) -new Vector2(.5f,.5f); break; case(5): smdArray[k].pivot = new Vector2(1f,.5f) -new Vector2(.5f,.5f); break; case(6): smdArray[k].pivot = new Vector2(0f,0f) -new Vector2(.5f,.5f); break; case(7): smdArray[k].pivot = new Vector2(0.5f,0f) -new Vector2(.5f,.5f); break; case(8): smdArray[k].pivot = new Vector2(1f,0f) -new Vector2(.5f,.5f); break; case(9): smdArray[k].pivot -= new Vector2(.5f,.5f); break; } pivot = smdArray[k].pivot ; } } if(textureImporter.spriteImportMode == SpriteImportMode.Single) pivot = textureImporter.spritePivot-new Vector2(.5f,.5f); newUv.x += ((pivot.x)*rec.width)/ spr.texture.width; newUv.y += ((pivot.y)*rec.height)/ spr.texture.height; uvsLocal.Add(newUv); normalsLocal.Add(new Vector3(0,0,-1)); idx++; } else { resultsTriIndexesLocal.Add(resultsLocal.LastIndexOf(v)); } } } for (int j = resultsTriIndexesLocal.Count-1; j >=0; j--) { resultsTriIndexesReversedLocal.Add(resultsTriIndexesLocal[j]); } results.AddRange(resultsLocal); resultsTriIndexes.AddRange(resultsTriIndexesLocal); resultsTriIndexesReversed.AddRange(resultsTriIndexesReversedLocal); uvs.AddRange(uvsLocal); normals.AddRange(normalsLocal); resultsLocal.Clear(); resultsTriIndexesLocal.Clear(); resultsTriIndexesReversedLocal.Clear(); uvsLocal.Clear(); normalsLocal.Clear(); finalVertices = results.ToArray(); finalNormals = normals.ToArray(); finalUvs= uvs.ToArray(); finalTriangles = resultsTriIndexesReversed.ToArray(); }
//the callback from polyNav for when path is ready to use void SetPath(Vector2[] path){ //in case the agent stoped somehow, but a path was pending if (requests == 0) return; requests --; if (path == null || path.Length == 0){ OnInvalid(); return; } activePath = path.ToList(); if (OnNavigationStarted != null) OnNavigationStarted(); }
private void OnGUI() { EditorGUILayout.BeginVertical(); /******************************************************************************** * Prepare Mesh for Simulation: * Use this to pack the triangle ID to the uv2 coordinates of the mesh for the * simulation. ********************************************************************************/ scrollPos = EditorGUILayout.BeginScrollView(scrollPos); meshPrep = (Mesh)EditorGUILayout.ObjectField(meshPrep, typeof(Mesh), false); if (GUILayout.Button("Prepare Mesh for Vertex Shader")) { Vector2[] uvs2 = new Vector2[meshPrep.vertices.Length]; for (int i = 0; i < meshPrep.triangles.Length; i++) { uvs2[meshPrep.triangles[i]] = new Vector2(i / 3, i); if (i % 100 == 0) { EditorUtility.DisplayProgressBar( "If I'm a progress bar", "Then I will give you the illusion of progress: " + i.ToString() + "/" + meshPrep.triangles.Length.ToString(), (float)i / (float)meshPrep.triangles.Length ); } } EditorUtility.ClearProgressBar(); meshPrep.uv2 = uvs2; meshPrep.SetUVs(1, uvs2.ToList <Vector2>()); meshPrep.MarkModified(); Mesh outMesh = Instantiate(meshPrep); EditorUtility.SetDirty(meshPrep); AssetDatabase.CreateAsset(outMesh, "Assets\\StartShape.Asset"); EditorUtility.SetDirty(outMesh); AssetDatabase.SaveAssets(); } /******************************************************************************** * Show Stats: * Use this to get information about a mesh that will get packed into simulation * textures. ********************************************************************************/ meshStats = (Mesh)EditorGUILayout.ObjectField(meshStats, typeof(Mesh), false); if (GUILayout.Button("Show Stats")) { Debug.Log("If I can be a texture containing " + meshStats.triangles.Length + " verticies as pixels named " + meshStats.name + ".exr"); } /******************************************************************************** * Populate List: * Populate the list of meshes located in the folder Assets/world.execute/keyframes/ * that will be packed into the textures for our simulation. ********************************************************************************/ if (GUILayout.Button("Populate List")) { string path = "Assets/Keyframes/"; string[] files = Directory.GetFiles(path); int n = 0; foreach (string file in files) { if (Path.GetExtension(file) == ".FBX" || Path.GetExtension(file) == ".fbx") { Mesh mesh = (Mesh)AssetDatabase.LoadAssetAtPath(file, typeof(Mesh)); if (mesh != null) { n++; } } } nOfMeshes = n; meshes = new Mesh[nOfMeshes]; n = 0; foreach (string file in files) { if (Path.GetExtension(file) == ".FBX" || Path.GetExtension(file) == ".fbx") { Mesh mesh = (Mesh)AssetDatabase.LoadAssetAtPath(file, typeof(Mesh)); if (mesh != null) { meshes[n] = mesh; n++; } } } } //Display the mesh list. nOfMeshes = EditorGUILayout.IntField(nOfMeshes); if (meshes == null || meshes.Length != nOfMeshes) { meshes = new Mesh[nOfMeshes]; } for (int i = 0; i < nOfMeshes; i++) { meshes[i] = (Mesh)EditorGUILayout.ObjectField(i.ToString(), meshes[i], typeof(Mesh), false); } /******************************************************************************** * Make Texture: * Begin packing the meshes into two textures. One that contains the mesh verticies * in triangle order. And the second containing offset and sizes of the * mesh. The offset and size have to be stored split into 2 numbers, as the * Quest only supports 16bit floats for HDR Textures. So we rebuild the number * with-in the Simulation. ********************************************************************************/ if (GUILayout.Button("Make Texture")) { int tCount = 0; int tCurrent = 0; int index = 0; //calculate number of triangles and safety check. foreach (Mesh mesh in meshes) { if (mesh != null) { tCount += mesh.triangles.Length; } } //Debug.Log(tCount + " / " + max); if (tCount > max) { Debug.Log("Cannot Continue, too many triangles in combined meshes."); return; } //create, then zero the textures first. Texture2D meshTex = new Texture2D(2048, 2048, TextureFormat.RGBAFloat, false); Texture2D indexTex = new Texture2D(32, 32, TextureFormat.RGBAFloat, false); for (int i = 0; i < 2048; i++) { for (int j = 0; j < 2048; j++) { meshTex.SetPixel(i, j, Vector4.zero); } } for (int i = 0; i < 32; i++) { for (int j = 0; j < 32; j++) { indexTex.SetPixel(i, j, Vector4.zero); } } meshTex.Apply(); indexTex.Apply(); foreach (Mesh mesh in meshes) { if (mesh != null) { Debug.Log("If I can be a mesh containing " + mesh.triangles.Length + " verticies"); int[] tris = mesh.triangles; Vector3[] verts = mesh.vertices; Color[] colors = meshTex.GetPixels(); for (int i = 0; i < mesh.triangles.Length; i++) { int n = tCurrent + i; int x = n % 2048; int y = n / 2048; int t = tris[i]; Vector4 color = new Vector4(verts[t].x, verts[t].y, verts[t].z, 1); colors[n] = color; if (i % 100 == 0) { EditorUtility.DisplayProgressBar( "If I'm a progress bar", "Then I will give you the illusion of progress: " + n.ToString() + "/" + tCount, (float)n / (float)tCount ); } } meshTex.SetPixels(colors); Debug.Log("Then, I will give you my pixels for execution."); int x2 = index % 32; int y2 = index / 32; int p1 = tCurrent % 2048; int p2 = tCurrent / 2048; int l1 = mesh.triangles.Length % 2048; int l2 = mesh.triangles.Length / 2048; //Alpha is 1, just so I can tell something is there. Vector4 color2 = new Vector4(p1, p2, l1, l2); //position, then length. indexTex.SetPixel(x2, y2, color2); indexTex.Apply(); //end of loop stuff. tCurrent += mesh.triangles.Length; index++; } } EditorUtility.ClearProgressBar(); meshTex.Apply(); byte[] bytes = meshTex.EncodeToEXR(Texture2D.EXRFlags.None); Object.DestroyImmediate(meshTex); File.WriteAllBytes(Application.dataPath + "/world.execute/meshData.exr", bytes); indexTex.Apply(); bytes = indexTex.EncodeToEXR(Texture2D.EXRFlags.None); Object.DestroyImmediate(indexTex); File.WriteAllBytes(Application.dataPath + "/world.execute/indexData.exr", bytes); } /******************************************************************************** * World.Execute(me): * If you want to test the Simulation, before publishing, you can attach the * required components here, press play, and then click "World.Execute(me);" * to test the simulation before uploading. ********************************************************************************/ worldExecute = (Material)EditorGUILayout.ObjectField(worldExecute, typeof(Material), true); worldExecuteAudio = (AudioSource)EditorGUILayout.ObjectField(worldExecuteAudio, typeof(AudioSource), true); if (GUILayout.Button("World.Execute(me);")) { if (!playing) { worldExecute.SetFloat("_StartTime", UnityEngine.Time.timeSinceLevelLoad); worldExecute.SetInt("_Play", 1); worldExecuteAudio.time = 0; worldExecuteAudio.Play(); playing = true; } else { worldExecute.SetFloat("_StartTime", 0); worldExecute.SetInt("_Play", 0); worldExecuteAudio.time = 0; worldExecuteAudio.Stop(); playing = false; } } EditorGUILayout.EndScrollView(); EditorGUILayout.EndVertical(); }