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