public StatePatrol(Person person, Vector3[] list) : base( person ){ pointList = new Vector3[list.Count()]; List<Vector3> tmp = new List<Vector3> (list); pointList = tmp.Select (point => point + owner.ComponentTransform.localPosition).ToArray (); pathLength = pointList.Length; }
public static void LoadScaledPlanet(GameObject smallPlanet, string name, bool bLoadTemp = false) { var root = ConfigNode.Load(DataPath + name + ".cfg"); if (root != null) { var sConfig = root.nodes.GetNode("ScaledTransform"); //print(cbConfig); if (sConfig != null) { var scaledBody = PFUtil.FindScaled(name); var ratio = float.Parse(sConfig.GetValue("ratio")); var newScale = (float)PFUtil.FindCB(name).Radius *ratio; scaledBody.transform.localScale = new Vector3(newScale, newScale, newScale); } } var binName = name + ".bin"; if (!bLoadTemp) { var colorTexture = PFUtil.LoadTexture(DataPath + name + "_map.png"); var bumpTexture = PFUtil.LoadTexture(DataPath + name + "_normal.png"); LoadScaledPlanetTextures(name, colorTexture, bumpTexture); } else { var colorTexture = PFUtil.LoadTexture(DataPath + name + "_map_.png"); var bumpTexture = PFUtil.LoadTexture(DataPath + name + "_normal_.png"); binName = name + "_.bin"; LoadScaledPlanetTextures(name, colorTexture, bumpTexture); } if (KSP.IO.File.Exists <PlanetFactory>(binName)) { //print("Loading mesh"); var smallPlanetMeshFilter = (MeshFilter)smallPlanet.GetComponentInChildren((typeof(MeshFilter))); var newVerts = new Vector3[smallPlanetMeshFilter.mesh.vertices.Count()]; var reader = KSP.IO.BinaryReader.CreateForType <PlanetFactory>(binName); for (var i = 0; i < newVerts.Count(); i++) { newVerts[i].x = reader.ReadSingle(); newVerts[i].y = reader.ReadSingle(); newVerts[i].z = reader.ReadSingle(); } smallPlanetMeshFilter.mesh.vertices = newVerts; smallPlanetMeshFilter.mesh.RecalculateNormals(); //smallPlanetMeshFilter.mesh.tangents = null; PFUtil.RecalculateTangents(smallPlanetMeshFilter.mesh); } }
public static Mesh Generate(PathInfo path, float width) { Vector3[] pointsLHS = AddThirdDimension(Subdivide(new Vector2[] { path.GetOffsetStart(width / 2), path.GetOffsetMiddle(width / 2), path.GetOffsetEnd(width / 2) }, subdivisions), path.Height.getValue); Vector3[] pointsRHS = AddThirdDimension(Subdivide(new Vector2[] { path.GetOffsetStart(-width / 2), path.GetOffsetMiddle(-width / 2), path.GetOffsetEnd(-width / 2) }, subdivisions), path.Height.getValue); Vector3[] points = new Vector3[pointsLHS.Length + pointsRHS.Length]; for (int i = 0; i < pointsLHS.Length; i++) { points[i * 2] = pointsLHS[i]; points[i * 2 + 1] = pointsRHS[i]; } int[] tris = new int[(points.Count() - 2) * 6]; int c = 0; for (int i = 0; i < points.Count() - 2; i++) { tris[c++] = i; tris[c++] = i + 1; tris[c++] = i + 2; tris[c++] = i + 2; tris[c++] = i + 1; tris[c++] = i++; tris[c++] = i; tris[c++] = i + 1; tris[c++] = i + 2; tris[c++] = i + 2; tris[c++] = i + 1; tris[c++] = i; } Mesh mesh = new Mesh(); mesh.Clear(); mesh.SetVertices(new List <Vector3>(points)); mesh.triangles = tris; mesh.RecalculateNormals(); mesh.RecalculateBounds(); return(mesh); }
private static bool IsRectTransformInsideScreen(RectTransform rectTransform) { var isInside = false; var corners = new Vector3[4]; rectTransform.GetWorldCorners(corners); var rect = new Rect(0, 0, Screen.width, Screen.height); var visibleCorners = corners.Count(corner => rect.Contains(corner)); if (visibleCorners == 4) { isInside = true; } return(isInside); }
public IConvexHullShapeImp AddConvexHullShape(float3[] points, bool optimized) { var btPoints = new Vector3[points.Count()]; for (int i = 0; i < btPoints.Count(); i++) { var point = Translater.Float3ToBtVector3(points[i]); btPoints[i] = point; } var btConvexHullShape = new ConvexHullShape(btPoints); //btConvexHullShape.LocalScaling = new Vector3(3, 3, 3); if (optimized == true) { var btShapeHull = new ShapeHull(btConvexHullShape); var margin = btConvexHullShape.Margin; btShapeHull.BuildHull(margin); ConvexHullShape simplifiedConvexShape = new ConvexHullShape(btShapeHull.Vertices); BtCollisionShapes.Add(simplifiedConvexShape); var retval = new ConvexHullShapeImp(); retval.BtConvexHullShape = simplifiedConvexShape; simplifiedConvexShape.UserObject = retval; return(retval); } else { BtCollisionShapes.Add(btConvexHullShape); var retval = new ConvexHullShapeImp(); retval.BtConvexHullShape = btConvexHullShape; btConvexHullShape.UserObject = retval; return(retval); } }
/// <summary> /// srcのSkinnedMeshRendererを正規化して、dstにアタッチする /// </summary> /// <param name="src">正規化前のSkinnedMeshRendererのTransform</param> /// <param name="dst">正規化後のSkinnedMeshRendererのTransform</param> /// <param name="boneMap">正規化前のボーンから正規化後のボーンを得る</param> static void NormalizeSkinnedMesh(Transform src, Transform dst, Dictionary <Transform, Transform> boneMap, bool clearBlendShape) { var srcRenderer = src.GetComponent <SkinnedMeshRenderer>(); if (srcRenderer == null || !srcRenderer.enabled || srcRenderer.sharedMesh == null || srcRenderer.sharedMesh.vertexCount == 0) { // 有効なSkinnedMeshRendererが無かった return; } var srcMesh = srcRenderer.sharedMesh; var originalSrcMesh = srcMesh; // clear blendShape if (clearBlendShape) { for (int i = 0; i < srcMesh.blendShapeCount; ++i) { srcRenderer.SetBlendShapeWeight(i, 0); } } // 元の Transform[] bones から、無効なboneを取り除いて前に詰めた配列を作る var dstBones = srcRenderer.bones .Where(x => x != null && boneMap.ContainsKey(x)) .Select(x => boneMap[x]) .ToArray(); var hasBoneWeight = srcRenderer.bones != null && srcRenderer.bones.Length > 0; if (!hasBoneWeight) { // Before bake, bind no weight bones //Debug.LogFormat("no weight: {0}", srcMesh.name); srcMesh = srcMesh.Copy(true); var bw = new BoneWeight { boneIndex0 = 0, boneIndex1 = 0, boneIndex2 = 0, boneIndex3 = 0, weight0 = 1.0f, weight1 = 0.0f, weight2 = 0.0f, weight3 = 0.0f, }; srcMesh.boneWeights = Enumerable.Range(0, srcMesh.vertexCount).Select(x => bw).ToArray(); srcMesh.bindposes = new Matrix4x4[] { Matrix4x4.identity }; srcRenderer.rootBone = srcRenderer.transform; dstBones = new[] { boneMap[srcRenderer.transform] }; srcRenderer.bones = new[] { srcRenderer.transform }; srcRenderer.sharedMesh = srcMesh; } // BakeMesh var mesh = srcMesh.Copy(false); mesh.name = srcMesh.name + ".baked"; srcRenderer.BakeMesh(mesh); var blendShapeValues = new Dictionary <int, float>(); for (int i = 0; i < srcMesh.blendShapeCount; i++) { var val = srcRenderer.GetBlendShapeWeight(i); if (val > 0) { blendShapeValues.Add(i, val); } } // 新しい骨格のボーンウェイトを作成する mesh.boneWeights = MapBoneWeight(srcMesh.boneWeights, boneMap, srcRenderer.bones, dstBones); // recalc bindposes mesh.bindposes = dstBones.Select(x => x.worldToLocalMatrix * dst.transform.localToWorldMatrix).ToArray(); //var m = src.localToWorldMatrix; // include scaling var m = default(Matrix4x4); m.SetTRS(Vector3.zero, src.rotation, Vector3.one); // rotation only mesh.ApplyMatrix(m); // // BlendShapes // var meshVertices = mesh.vertices; var meshNormals = mesh.normals; #if VRM_NORMALIZE_BLENDSHAPE_TANGENT var meshTangents = mesh.tangents.Select(x => (Vector3)x).ToArray(); #endif var originalBlendShapePositions = new Vector3[meshVertices.Length]; var originalBlendShapeNormals = new Vector3[meshVertices.Length]; var originalBlendShapeTangents = new Vector3[meshVertices.Length]; var report = new BlendShapeReport(srcMesh); var blendShapeMesh = new Mesh(); for (int i = 0; i < srcMesh.blendShapeCount; ++i) { // check blendShape srcRenderer.sharedMesh.GetBlendShapeFrameVertices(i, 0, originalBlendShapePositions, originalBlendShapeNormals, originalBlendShapeTangents); var hasVertices = originalBlendShapePositions.Count(x => x != Vector3.zero); var hasNormals = originalBlendShapeNormals.Count(x => x != Vector3.zero); #if VRM_NORMALIZE_BLENDSHAPE_TANGENT var hasTangents = originalBlendShapeTangents.Count(x => x != Vector3.zero); #else var hasTangents = 0; #endif var name = srcMesh.GetBlendShapeName(i); if (string.IsNullOrEmpty(name)) { name = String.Format("{0}", i); } report.SetCount(i, name, hasVertices, hasNormals, hasTangents); srcRenderer.SetBlendShapeWeight(i, 100.0f); srcRenderer.BakeMesh(blendShapeMesh); if (blendShapeMesh.vertices.Length != mesh.vertices.Length) { throw new Exception("different vertex count"); } var value = blendShapeValues.ContainsKey(i) ? blendShapeValues[i] : 0; srcRenderer.SetBlendShapeWeight(i, value); Vector3[] vertices = blendShapeMesh.vertices; for (int j = 0; j < vertices.Length; ++j) { if (originalBlendShapePositions[j] == Vector3.zero) { vertices[j] = Vector3.zero; } else { vertices[j] = m.MultiplyPoint(vertices[j]) - meshVertices[j]; } } Vector3[] normals = blendShapeMesh.normals; for (int j = 0; j < normals.Length; ++j) { if (originalBlendShapeNormals[j] == Vector3.zero) { normals[j] = Vector3.zero; } else { normals[j] = m.MultiplyVector(normals[j]) - meshNormals[j]; } } Vector3[] tangents = blendShapeMesh.tangents.Select(x => (Vector3)x).ToArray(); #if VRM_NORMALIZE_BLENDSHAPE_TANGENT for (int j = 0; j < tangents.Length; ++j) { if (originalBlendShapeTangents[j] == Vector3.zero) { tangents[j] = Vector3.zero; } else { tangents[j] = m.MultiplyVector(tangents[j]) - meshTangents[j]; } } #endif var frameCount = srcMesh.GetBlendShapeFrameCount(i); for (int f = 0; f < frameCount; f++) { var weight = srcMesh.GetBlendShapeFrameWeight(i, f); try { mesh.AddBlendShapeFrame(name, weight, vertices, hasNormals > 0 ? normals : null, hasTangents > 0 ? tangents : null ); } catch (Exception) { Debug.LogErrorFormat("fail to mesh.AddBlendShapeFrame {0}.{1}", mesh.name, srcMesh.GetBlendShapeName(i) ); throw; } } } if (report.Count > 0) { Debug.LogFormat("{0}", report.ToString()); } var dstRenderer = dst.gameObject.AddComponent <SkinnedMeshRenderer>(); dstRenderer.sharedMaterials = srcRenderer.sharedMaterials; if (srcRenderer.rootBone != null) { dstRenderer.rootBone = boneMap[srcRenderer.rootBone]; } dstRenderer.bones = dstBones; dstRenderer.sharedMesh = mesh; if (!hasBoneWeight) { // restore bones srcRenderer.bones = new Transform[] { }; srcRenderer.sharedMesh = originalSrcMesh; } }
//TODO: Make work public void Render(Matrix4d viewproj, Matrix4d parentmodel) { Vector3[] positionArray = new Vector3[lines.Count]; Vector4[] colorArray = new Vector4[lines.Count]; int i; //Random r = new Random(); if (lines.Count() == 0) { return; } for (i = 0; i < lines.Count; i++) { positionArray[i] = MassiveTools.Vector3FromVector3d(lines[i].Position - Globals.GlobalOffset); colorArray[i] = lines[i].Color; } lines.Clear(); vertexCount = positionArray.Length; //GL.ClearColor(new Color4(0, 0, 0, 0.5f)); //GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); Matrix4 mvp = MTransform.GetFloatMatrix(viewproj); Matrix4 model = MTransform.GetFloatMatrix(parentmodel); GL.UseProgram(shaderProgram); int loc = GL.GetUniformLocation(shaderProgram, "mvp"); GL.UniformMatrix4(loc, false, ref mvp); loc = GL.GetUniformLocation(shaderProgram, "model"); GL.UniformMatrix4(loc, false, ref model); lineVertexBuffer = GL.GenBuffer(); if (Globals.Avatar.Target == null) { return; } Vector3 tp = MassiveTools.Vector3FromVector3d(Globals.Avatar.Target.transform.Position); //Vector3[] lineVertices = { new Vector3(0, 0, 0), new Vector3((float)r.NextDouble(), .5f, 0.5f) - MassiveTools.FromV3d(Globals.GlobalOffset)}; //vertexCount = lineVertices.Length; GL.BindBuffer(BufferTarget.ArrayBuffer, lineVertexBuffer); GL.BufferData(BufferTarget.ArrayBuffer, System.Runtime.InteropServices.Marshal.SizeOf(positionArray[0]) * vertexCount, positionArray, BufferUsageHint.StreamDraw); vertexInfo = GL.GenVertexArray(); GL.BindVertexArray(vertexInfo); int locVPosition = GL.GetAttribLocation(shaderProgram, "vPosition"); GL.EnableVertexAttribArray(locVPosition); GL.VertexAttribPointer(locVPosition, 3, VertexAttribPointerType.Float, false, System.Runtime.InteropServices.Marshal.SizeOf(positionArray[0]), 0); //GL.BindVertexArray(0); //GL.BindBuffer(BufferTarget.ArrayBuffer, 0); //GL.UseProgram(0); //GL.ClearColor(Color4.Black); GL.Clear(ClearBufferMask.DepthBufferBit); int loca = GL.GetUniformLocation(shaderProgram, "mcolor"); if (UserColorCoding == true) { for (int ri = 0; ri <= positionArray.Count() - 2; ri += 2) { Vector4 v = colorArray[ri]; GL.Uniform4(loca, ref v); GL.DrawArrays(PrimitiveType.LineStrip, ri, 2); } } else { Vector4 v = new Vector4(1, 1, 1, 0.9f); GL.Uniform4(loca, ref v); GL.DrawArrays(PrimitiveType.LineStrip, 0, positionArray.Count()); } //GL.DrawArrays(PrimitiveType.LineStrip, ri, vertexCount); GL.BindVertexArray(0); GL.BindBuffer(BufferTarget.ArrayBuffer, 0); GL.UseProgram(0); }
public static void GenerateScaledSpace(CelestialBody body, Mesh meshinput) { PQS bodyPQS = body.pqsController; Single joolScaledRad = 1000f; Single joolRad = 6000000f; Single scale = (float)bodyPQS.radius / joolScaledRad; Vector3[] vertices = new Vector3[meshinput.vertices.Count()]; // One could use pqs.radiusMin and pqs.radiusMax to determine minimum and maximum height. // But to be safe, the height limit values will be determined manually. Single radiusMin = 0; Single radiusMax = 0; bodyPQS.isBuildingMaps = true; for (Int32 i = 0; i < meshinput.vertices.Count(); i++) { Vector3 vertex = meshinput.vertices[i]; Single rootrad = (float)Math.Sqrt(vertex.x * vertex.x + vertex.y * vertex.y + vertex.z * vertex.z); Single localRadius = (float)bodyPQS.GetSurfaceHeight(vertex) / scale; vertices[i] = vertex * (localRadius / rootrad); if (i == 0) { radiusMin = radiusMax = localRadius; } else { if (radiusMin > localRadius) { radiusMin = localRadius; } if (radiusMax < localRadius) { radiusMax = localRadius; } } } bodyPQS.isBuildingMaps = false; // Adjust the mesh so the maximum radius has 1000 unit in scaled space. // (so the planets will fit in the science archive list) Single r = radiusMax / 1000; for (Int32 i = 0; i < vertices.Count(); i++) { vertices[i] /= r; } // Use the lowest radius as collision radius. Single radius = radiusMin / r; // Calculate the local scale. Vector3 localScale = Vector3.one * ((float)bodyPQS.radius / joolRad) * r; // Apply the mesh to ScaledSpace MeshFilter meshfilter = body.scaledBody.GetComponent <MeshFilter>(); SphereCollider collider = body.scaledBody.GetComponent <SphereCollider>(); meshfilter.sharedMesh.vertices = vertices; meshfilter.sharedMesh.RecalculateNormals(); Utility.RecalculateTangents(meshfilter.sharedMesh); collider.radius = radius; body.scaledBody.transform.localScale = localScale; // Serialize Directory.CreateDirectory(KSPUtil.ApplicationRootPath + Body.ScaledSpaceCacheDirectory); Utility.SerializeMesh(meshfilter.sharedMesh, KSPUtil.ApplicationRootPath + Body.ScaledSpaceCacheDirectory + "/" + body.name + ".bin"); }
public Mesh CreateMeshFromVerts(Vector3[] vertsToCopy, Mesh mesh, List<int> pathSplitIds, Transform SpriteGO = null) { 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 = new Sprite(); Rect rec = new Rect(); Vector3 bound = Vector3.zero; TextureImporter textureImporter = new TextureImporter(); if(SpriteGO !=null && SpriteGO.GetComponent<SpriteRenderer>() && SpriteGO.GetComponent<SpriteRenderer>().sprite) { spr = SpriteGO.GetComponent<SpriteRenderer>().sprite; rec = spr.rect; bound = SpriteGO.GetComponent<Renderer>().bounds.max- SpriteGO.GetComponent<Renderer>().bounds.min ; textureImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(spr)) as TextureImporter; } List<PolygonPoint> p2 = new List<PolygonPoint>(); List<TriangulationPoint> extraPoints = new List<TriangulationPoint>(); int i = 0; for (i = 0; i < vertsToCopy.Count(); i ++) { if(i<pathSplitIds[0]) p2.Add(new PolygonPoint(vertsToCopy [i].x, vertsToCopy [i].y)); else extraPoints.Add(new TriangulationPoint(vertsToCopy [i].x, vertsToCopy [i].y)); } Polygon _polygon = new Polygon(p2); // this is how to add more points _polygon.AddSteinerPoints (extraPoints); P2T.Triangulate(_polygon); if (spr == null) { bound = new Vector3((float)(_polygon.Bounds.MaxX - _polygon.Bounds.MinX),(float)(_polygon.Bounds.MaxY - _polygon.Bounds.MinY),0 ) ; } 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-(float)_polygon.Bounds.MinX) /bound.x) , ((v.y-(float)_polygon.Bounds.MinY) /bound.y) ); if (spr != null) { 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(); mesh.vertices = finalVertices; mesh.triangles = finalTriangles; mesh.uv = finalUvs; mesh.normals = finalNormals; mesh = calculateMeshTangents (mesh); return mesh; }
unsafe private void ProcessGraph(hkaiDirectedGraphExplicitCost graph) { var verts = graph.m_positions; int indexCount = 0; foreach (var g in graph.m_nodes) { // Simple formula for indices count for a triangulation of a poly indexCount += g.m_numEdges; } var MeshIndices = new int[indexCount * 2]; var MeshVertices = new PositionColor[indexCount * 2]; var vertPos = new Vector3[indexCount * 2]; var factory = Scene.Renderer.Factory; int idx = 0; for (int id = 0; id < graph.m_nodes.Count; id++) { var sedge = graph.m_nodes[id].m_startEdgeIndex; var ecount = graph.m_nodes[id].m_numEdges; for (int e = 0; e < ecount; e++) { var vert1 = graph.m_positions[id]; var vert2 = graph.m_positions[(int)graph.m_edges[graph.m_nodes[id].m_startEdgeIndex + e].m_target]; MeshVertices[idx] = new PositionColor(); MeshVertices[idx + 1] = new PositionColor(); MeshVertices[idx].Position = new Vector3(vert1.X, vert1.Y, vert1.Z); MeshVertices[idx + 1].Position = new Vector3(vert2.X, vert2.Y, vert2.Z); vertPos[idx] = new Vector3(vert1.X, vert1.Y, vert1.Z); vertPos[idx + 1] = new Vector3(vert2.X, vert2.Y, vert2.Z); MeshVertices[idx].Color[0] = (byte)(235); MeshVertices[idx].Color[1] = (byte)(200); MeshVertices[idx].Color[2] = (byte)(255); MeshVertices[idx].Color[3] = (byte)(255); MeshVertices[idx + 1].Color[0] = (byte)(235); MeshVertices[idx + 1].Color[1] = (byte)(200); MeshVertices[idx + 1].Color[2] = (byte)(255); MeshVertices[idx + 1].Color[3] = (byte)(255); MeshIndices[idx] = idx; MeshIndices[idx + 1] = idx + 1; idx += 2; } } GraphVertexCount = MeshVertices.Length; GraphIndexCount = MeshIndices.Length; uint buffersize = (uint)GraphIndexCount * 4u; if (GraphVertexCount > 0) { fixed(void *ptr = vertPos) { Bounds = BoundingBox.CreateFromPoints((Vector3 *)ptr, vertPos.Count(), 12, Quaternion.Identity, Vector3.Zero, Vector3.One); } } else { Bounds = new BoundingBox(); } var lsize = MeshLayoutUtils.GetLayoutVertexSize(MeshLayoutType.LayoutPositionColor); uint vbuffersize = (uint)MeshVertices.Length * lsize; CostGraphGeomBuffer = Scene.Renderer.GeometryBufferAllocator.Allocate(vbuffersize, buffersize, (int)lsize, 4, (h) => { h.FillIBuffer(MeshIndices, () => { MeshIndices = null; }); h.FillVBuffer(MeshVertices, () => { MeshVertices = null; }); }); }
public static void LoadScaledPlanet(GameObject smallPlanet, string name,bool bLoadTemp=false) { var root = ConfigNode.Load(DataPath + name + ".cfg"); if (root != null) { var sConfig = root.nodes.GetNode("ScaledTransform"); //print(cbConfig); if (sConfig != null) { var scaledBody = PFUtil.FindScaled(name); var ratio = float.Parse(sConfig.GetValue("ratio")); var newScale = (float)PFUtil.FindCB(name).Radius * ratio; scaledBody.transform.localScale = new Vector3(newScale, newScale, newScale); } } var binName = name + ".bin"; if (!bLoadTemp) { var colorTexture = PFUtil.LoadTexture(DataPath + name + "_map.png"); var bumpTexture = PFUtil.LoadTexture(DataPath + name + "_normal.png"); LoadScaledPlanetTextures(name, colorTexture, bumpTexture); } else { var colorTexture = PFUtil.LoadTexture(DataPath + name + "_map_.png"); var bumpTexture = PFUtil.LoadTexture(DataPath + name + "_normal_.png"); binName = name + "_.bin"; LoadScaledPlanetTextures(name, colorTexture, bumpTexture); } if (KSP.IO.File.Exists<PlanetFactory>(binName)) { //print("Loading mesh"); var smallPlanetMeshFilter = (MeshFilter) smallPlanet.GetComponentInChildren((typeof (MeshFilter))); var newVerts = new Vector3[smallPlanetMeshFilter.mesh.vertices.Count()]; var reader = KSP.IO.BinaryReader.CreateForType<PlanetFactory>(binName); for (var i = 0; i < newVerts.Count(); i++) { newVerts[i].x = reader.ReadSingle(); newVerts[i].y = reader.ReadSingle(); newVerts[i].z = reader.ReadSingle(); } smallPlanetMeshFilter.mesh.vertices = newVerts; smallPlanetMeshFilter.mesh.RecalculateNormals(); //smallPlanetMeshFilter.mesh.tangents = null; PFUtil.RecalculateTangents(smallPlanetMeshFilter.mesh); } }