// Called when the node enters the scene tree for the first time.
public override void _Ready()
{
StreamReader textReader = new StreamReader(@"./UMA/Content/UMA_Core/HumanMale/Slots/Body/UMA_Human_Male_Legs_Slot.asset");
textReader.ReadLine();
textReader.ReadLine();
textReader.ReadLine();
var deserializer = new DeserializerBuilder()
.WithNamingConvention(new CamelCaseNamingConvention())
.Build();
var slotData = deserializer.Deserialize <SlotYaml>(textReader);
GD.Print(slotData.MonoBehaviour.MName);
var verticeOrder = decodeUnitysCompressionSubMesh(slotData.MonoBehaviour.MeshData.Submeshes[0].Triangles);
var surfaceArray = new Godot.Collections.Array();
surfaceArray.Resize(ARRAY_MAX);
surfaceArray[ARRAY_VERTEX] = slotData.MonoBehaviour.MeshData.Vertices;
surfaceArray[ARRAY_NORMAL] = slotData.MonoBehaviour.MeshData.Normals;
surfaceArray[ARRAY_TANGENTS] = CreateTangents(slotData.MonoBehaviour.MeshData.Tangents);
surfaceArray[ARRAY_TEX_UV] = slotData.MonoBehaviour.MeshData.Uv;
surfaceArray[ARRAY_INDEX] = verticeOrder;
ArrayMesh legMesh = new ArrayMesh();
legMesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, surfaceArray, null, ARRAY_FORMAT_VERTEX + ARRAY_FORMAT_NORMAL + ARRAY_FORMAT_TANGENT + ARRAY_FORMAT_TANGENT);
var legMaterial = (SpatialMaterial)GD.Load("res://skin.material");
GD.Print("Surface Count" + legMesh.GetSurfaceCount());
var node = (MeshInstance)FindNode("UmaMeshNode");
GD.Print(node.GetType());
GD.Print(node.Mesh.ToString());
legMesh.SurfaceSetMaterial(0, legMaterial);
node.SetMesh(legMesh);
GD.Print(node.Mesh.ToString());
/*
* DynamicCharacterAvatar characterAvatar= new DynamicCharacterAvatar();
*
* DynamicAssetLoader.Instance = new DynamicAssetLoader();
*
* UMA.UMAContext.Instance = new UMA.UMAContext();
* characterAvatar.context = UMA.UMAContext.Instance;
* UMA.UMAContext.Instance.raceLibrary = new DynamicRaceLibrary();
*
* UMATextRecipe textRecipe = new UMATextRecipe();
* textRecipe.recipeString = @"{""version"":3,""packedSlotDataList"":[],""slotsV2"":[],""slotsV3"":[{""id"":""MaleEyes"",""scale"":100,""copyIdx"":-1,""overlays"":[{""id"":""EyeOverlay"",""colorIdx"":3,""rect"":[0,0,0,0]},{""id"":""Default Eye Adjust"",""colorIdx"":2,""rect"":[0,0,0,0]}]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":""MaleInnerMouth"",""scale"":100,""copyIdx"":-1,""overlays"":[{""id"":""InnerMouth"",""colorIdx"":4,""rect"":[0,0,0,0]}]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":""MaleTorso"",""scale"":100,""copyIdx"":-1,""overlays"":[{""id"":""M_BodOverlay 1"",""colorIdx"":0,""rect"":[0,0,0,0]}]},{""id"":""MaleFeet"",""scale"":100,""copyIdx"":16,""overlays"":[]},{""id"":""MaleHands"",""scale"":100,""copyIdx"":16,""overlays"":[]},{""id"":""MaleLegs"",""scale"":100,""copyIdx"":16,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":"""",""scale"":1,""copyIdx"":-1,""overlays"":[]},{""id"":""M_Highpoly Head"",""scale"":100,""copyIdx"":-1,""overlays"":[{""id"":""M_Face"",""colorIdx"":0,""rect"":[0,0,0,0]}]}],""colors"":[],""fColors"":[{""name"":""Skin"",""colors"":[255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0]},{""name"":""Hair"",""colors"":[255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0]},{""name"":""Eyes"",""colors"":[255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0]},{""name"":""-"",""colors"":[255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0]},{""name"":""-"",""colors"":[234,234,234,255,0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0]}],""sharedColorCount"":3,""race"":""HumanMale"",""packedDna"":[{""dnaType"":""DynamicUMADna"",""dnaTypeHash"":815443803,""packedDna"":""{\""bDnaAsset\"":{\""instanceID\"":12024},\""bDnaAssetName\"":\""HumanMaleDynamicDnaAsset\"",\""bDnaSettings\"":[{\""name\"":\""skinGreenness\"",\""value\"":128},{\""name\"":\""skinBlueness\"",\""value\"":128},{\""name\"":\""skinRedness\"",\""value\"":128},{\""name\"":\""height\"",\""value\"":128},{\""name\"":\""headSize\"",\""value\"":128},{\""name\"":\""headWidth\"",\""value\"":128},{\""name\"":\""neckThickness\"",\""value\"":128},{\""name\"":\""armLength\"",\""value\"":128},{\""name\"":\""forearmLength\"",\""value\"":128},{\""name\"":\""armWidth\"",\""value\"":128},{\""name\"":\""forearmWidth\"",\""value\"":128},{\""name\"":\""handsSize\"",\""value\"":128},{\""name\"":\""feetSize\"",\""value\"":128},{\""name\"":\""legSeparation\"",\""value\"":128},{\""name\"":\""upperMuscle\"",\""value\"":128},{\""name\"":\""lowerMuscle\"",\""value\"":128},{\""name\"":\""upperWeight\"",\""value\"":128},{\""name\"":\""lowerWeight\"",\""value\"":128},{\""name\"":\""legsSize\"",\""value\"":128},{\""name\"":\""belly\"",\""value\"":128},{\""name\"":\""waist\"",\""value\"":128},{\""name\"":\""gluteusSize\"",\""value\"":128},{\""name\"":\""earsSize\"",\""value\"":128},{\""name\"":\""earsPosition\"",\""value\"":128},{\""name\"":\""earsRotation\"",\""value\"":128},{\""name\"":\""noseSize\"",\""value\"":128},{\""name\"":\""noseCurve\"",\""value\"":128},{\""name\"":\""noseWidth\"",\""value\"":128},{\""name\"":\""noseInclination\"",\""value\"":128},{\""name\"":\""nosePosition\"",\""value\"":128},{\""name\"":\""nosePronounced\"",\""value\"":128},{\""name\"":\""noseFlatten\"",\""value\"":128},{\""name\"":\""chinSize\"",\""value\"":128},{\""name\"":\""chinPronounced\"",\""value\"":128},{\""name\"":\""chinPosition\"",\""value\"":128},{\""name\"":\""mandibleSize\"",\""value\"":128},{\""name\"":\""jawsSize\"",\""value\"":128},{\""name\"":\""jawsPosition\"",\""value\"":128},{\""name\"":\""cheekSize\"",\""value\"":128},{\""name\"":\""cheekPosition\"",\""value\"":128},{\""name\"":\""lowCheekPronounced\"",\""value\"":128},{\""name\"":\""lowCheekPosition\"",\""value\"":128},{\""name\"":\""foreheadSize\"",\""value\"":128},{\""name\"":\""foreheadPosition\"",\""value\"":128},{\""name\"":\""lipsSize\"",\""value\"":128},{\""name\"":\""mouthSize\"",\""value\"":128},{\""name\"":\""eyeRotation\"",\""value\"":128},{\""name\"":\""eyeSize\"",\""value\"":128},{\""name\"":\""breastSize\"",\""value\"":128},{\""name\"":\""eyeSpacing\"",\""value\"":128}]}""}],""wardrobeSet"":[],""packedRecipeType"":""Standard""}";
* GD.Print(textRecipe.recipeString);
* characterAvatar.umaRecipe = textRecipe;
*
* UMAGenerator generator = new UMAGenerator();
* characterAvatar.umaGenerator = generator;
*
* characterAvatar.Start();
* GD.Print("It actually made it to the end of the Start routine!");*/
}
/**
* create overlay
*/
private ArrayMesh createOverlays(ArrayMesh oldMesh, UMAReciepe reciepe)
{
Dictionary <int, string> oldSurfaces = new Dictionary <int, string>();
for (int surface = 0; surface < oldMesh.GetSurfaceCount(); surface++)
{
var name = oldMesh.SurfaceGetName(surface);
oldSurfaces.Add(surface, name);
}
foreach (var slot in reciepe.slots)
{
var slotName = slot.Key;
var path = System.IO.Path.Combine(reciepe.slotPath, slot.Key + ".tscn");
var restBones = extractBinds(path);
foreach (var overlay in slot.Value)
{
var overlayName = slotName + "/Overlay_" + overlay.Key;
if (!oldSurfaces.ContainsValue(overlayName))
{
var overlayPath = System.IO.Path.Combine(overlay.Value.overlayPath, overlay.Key + ".tscn");
oldMesh = createSurfaceOverlay(oldMesh, slotName, overlayPath, overlayName, restBones);
}
}
}
return(oldMesh);
}
void CombinaQuads(String nome)
{
MeshInstance cube = new MeshInstance
{
Name = nome
};
ArrayMesh cubeArray = new ArrayMesh();
Godot.Collections.Array kids = GetChildren();
Material[] materiais = new Material[kids.Count];
int contador = 0;
foreach (MeshInstance meshI in kids)
{
cubeArray.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, meshI.Mesh.SurfaceGetArrays(0));
materiais[contador] = meshI.GetSurfaceMaterial(0);
meshI.QueueFree();
contador++;
}
cube.Mesh = cubeArray;
for (int i = 0; i < materiais.Length; i++)
{
cube.SetSurfaceMaterial(i, materiais[i]);
}
AddChild(cube);
}
/**
* Clean up old surfacess
**/
private ArrayMesh cleanOldSlots(ArrayMesh oldMesh, UMAReciepe reciepe)
{
List <string> oldSurfaces = new List <string>();
for (int surface = 0; surface < oldMesh.GetSurfaceCount(); surface++)
{
oldSurfaces.Add(oldMesh.SurfaceGetName(surface));
}
var allSlotNames = reciepe.slots.Select(tf => tf.Key).ToList();
//clean up current surface by new slots
foreach (var oldSurface in oldSurfaces)
{
bool exist = false;
foreach (var reicpeSlotName in allSlotNames)
{
if (oldSurface.Contains(reicpeSlotName))
{
exist = true;
}
}
if (!exist)
{
Console.WriteLine("[UMA] Delete surface " + oldSurface);
oldMesh.SurfaceRemove(oldMesh.SurfaceFindByName(oldSurface));
changes++;
}
}
return(oldMesh);
}
/**
* Create surface for overlay
*/
public ArrayMesh createSurfaceOverlay(ArrayMesh mesh, string slotName, string urlPath, string overlayName, List <UMAReciepeBindPose> origBindPoses)
{
var file = ResourceLoader.Load <PackedScene>(urlPath);
var instance = file.Instance();
var meshes = new List <MeshInstance>();
if (instance is Spatial)
{
foreach (var child in (instance as Spatial).GetChildren())
{
if (child is MeshInstance)
{
meshes.Add(child as MeshInstance);
}
}
}
if (instance is MeshInstance)
{
meshes.Add(instance as MeshInstance);
}
var mdt = new MeshDataTool();
var idx = mesh.SurfaceFindByName(slotName);
mdt.CreateFromSurface(mesh, idx);
int totalSurfaces = 0;
foreach (var mi in meshes)
{
var newMesh = (mi as MeshInstance).Mesh;
var newSkin = (mi as MeshInstance).Skin;
for (int surface = 0; surface < newMesh.GetSurfaceCount(); surface++)
{
mesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, createSurfaceByBones(newMesh as ArrayMesh, surface, newSkin, origBindPoses));
var lastId = mesh.GetSurfaceCount() - 1;
var mat = newMesh.SurfaceGetMaterial(surface);
mat.ResourceLocalToScene = true;
if (mat is SpatialMaterial)
{
(mat as SpatialMaterial).ParamsGrow = true;
(mat as SpatialMaterial).ParamsGrowAmount = 0.005f;
}
mesh.SurfaceSetMaterial(lastId, mat);
mesh.SurfaceSetName(lastId, (totalSurfaces == 0) ? overlayName : overlayName + "/" + totalSurfaces);
totalSurfaces++;
}
changes++;
}
return(mesh);
}
private ArrayMesh draw_hex_tri(Vector3[] base_verts, ref ArrayMesh local_array_mesh)
{
Mesh a = new ArrayMesh();
Godot.Collections.Array mesh_arrays = new Godot.Collections.Array();
int[] indices = new int[] { 0, 1, 2, 0, 2, 3 };
mesh_arrays.Resize((int)Mesh.ArrayType.Max);
for (int i = 0; i < 3; i++)
{
List <Vector3> verts = new List <Vector3>();
for (int i2 = 0; i2 < base_verts.Length; i2++)
{
verts.Add(point_rotation(base_verts[i2], base_verts[2], 120f * i));
}
//mesh_arrays[Godot.Mesh] = verts;
mesh_arrays[(int)ArrayMesh.ArrayType.Vertex] = verts.ToArray();
mesh_arrays[(int)ArrayMesh.ArrayType.Index] = indices;
}
local_array_mesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, mesh_arrays);
return(local_array_mesh);
}
private void FillMesh(ref ArrayMesh mesh, bool calculateBounds, bool autoIndexFormat)
{
if (vertexCount > 65535)
{
if (autoIndexFormat)
{
//FIXME
//mesh.indexFormat = IndexFormat.UInt32;
}
else
{
// BEGIN: Modified by Microsoft Corporation for generic logging purposes.
API.MREAPI.Logger.LogError("A mesh can't have more than 65535 vertices with 16 bit index buffer. Vertex count: " + vertexCount);
// END: Modified by Microsoft Corporation for generic logging purposes.
//FIXME
//mesh.indexFormat = IndexFormat.UInt16;
}
}
else
{
//FIXME
//mesh.indexFormat = IndexFormat.UInt16;
}
//mesh.Name = name;
var array = new Godot.Collections.Array();
array.Resize((int)ArrayMesh.ArrayType.Max);
if (vertices.Count > 0)
{
array[(int)ArrayMesh.ArrayType.Vertex] = vertices.ToArray();
}
if (normals.Count > 0)
{
array[(int)ArrayMesh.ArrayType.Normal] = normals.ToArray();
}
if (tangents.Count > 0)
{
array[(int)ArrayMesh.ArrayType.Tangent] = tangents.ToArray();
}
if (uv.Count > 0)
{
array[(int)ArrayMesh.ArrayType.TexUv] = uv.ToArray();
}
if (uv2.Count > 0)
{
array[(int)ArrayMesh.ArrayType.TexUv2] = uv2.ToArray();
}
if (colors.Count > 0)
{
array[(int)ArrayMesh.ArrayType.Color] = colors.ToArray();
}
if (triangles.Count > 0)
{
array[(int)ArrayMesh.ArrayType.Index] = triangles.ToArray();
}
mesh.AddSurfaceFromArrays(Godot.ArrayMesh.PrimitiveType.Triangles, array);
}
// Called when the node enters the scene tree for the first time.
public override void _Ready()
{
global = GetNode <Global>("/root/Global");
OnStartTimerTimeout();
CharacterContainer = GetNode <Spatial>("/root/Spatial/CharacterContainer");
SurfaceTool surfaceTool = new SurfaceTool();
planeMesh = new PlaneMesh();
planeMesh.Material = (Material)ResourceLoader.Load("mesh_material.tres");
planeMesh.SubdivideWidth = width - 2; //Subtract two bc there's already two vertices before we start subdividing
planeMesh.SubdivideDepth = height - 2;
planeMesh.Size = new Vector2(42.4f, 24f); //42.47f (42.4f, 24f)
surfaceTool.CreateFrom(planeMesh, 0);
arrayPlane = surfaceTool.Commit();
meshInstance = new MeshInstance();
meshInstance.Mesh = arrayPlane;
NewDetectedBody();
AddChild(meshInstance);
AddChild(detectBody);
UpdateShapes();
}
/// <summary>
/// Creates a new mesh from the data in the draft
/// </summary>
/// <param name="calculateBounds"> Calculate the bounding box of the Mesh after setting the triangles. </param>
/// <param name="autoIndexFormat"> Use 16 bit or 32 bit index buffers based on vertex count. </param>
public Mesh ToMesh(bool calculateBounds = true, bool autoIndexFormat = true)
{
var mesh = new ArrayMesh();
FillMesh(ref mesh, calculateBounds, autoIndexFormat);
return(mesh);
}
protected override IMeshData <MorphableVertex> CreateMorphedMesh(ArrayMesh source, ArrayMesh target)
{
var baseMesh = source.GetSurfaces().Filter(v => v.Key == Surface).Head();
var morph = target.GetSurfaces().Filter(v => v.Key == Surface).Head();
return(baseMesh.Data.Join(Key, morph.Data));
}
public override UnifiedObject Mirror()
{
StaticObject clone = (StaticObject)this.Clone();
ArrayMesh originalMesh = (ArrayMesh)this.m_meshInstance.Mesh;
int originalSurfaceCount = originalMesh.GetSurfaceCount();
ArrayMesh newMesh = new ArrayMesh();
for (int i = 0; i < originalSurfaceCount; i++)
{
MeshDataTool mdt = new MeshDataTool();
mdt.CreateFromSurface(originalMesh, i);
for (int j = 0; j < mdt.GetVertexCount(); j++)
{
Vector3 vert = mdt.GetVertex(j);
vert.x *= -1;
mdt.SetVertex(j, vert);
}
mdt.CommitToSurface(newMesh);
}
clone.ObjectMeshInstance.Mesh = newMesh;
return(clone);
}
public static ArrayMesh AddNoiseToMesh(PlaneMesh plane, float[,] noiseMap, int chunkSize, int heightMultiplier, Curve heightCurve)
{
SurfaceTool st = new SurfaceTool();
st.CreateFrom(plane, 0);
ArrayMesh mesh = new ArrayMesh();
MeshDataTool dt = new MeshDataTool();
mesh = st.Commit();
dt.CreateFromSurface(mesh, 0);
for (int y = 0; y < chunkSize; y++)
{
for (int x = 0; x < chunkSize; x++)
{
int z = y;
int vertexIndex = z * chunkSize + x;
Vector3 vertex = dt.GetVertex(vertexIndex);
vertex.y = heightCurve.Interpolate(noiseMap[chunkSize - x - 1, chunkSize - z - 1]) * heightMultiplier;
dt.SetVertex(vertexIndex, vertex);
}
}
for (int surface = 0; surface < mesh.GetSurfaceCount(); surface++)
{
mesh.SurfaceRemove(surface);
}
dt.CommitToSurface(mesh);
st.Begin(Mesh.PrimitiveType.Triangles);
st.CreateFrom(mesh, 0);
st.Index();
st.GenerateNormals();
return(st.Commit());
}
public override void _Ready()
{
// ----
// GD.Print(heightTerrain.Name); // <--- ERROR HERE, PRODUCES A CRASH RUNNING IN EDITOR
// ----
for (int i = 0; i < this.GetChildCount(); i++)
{
Node child = this.GetChild(i);
this.RemoveChild(child);
}
float [,] noiseMap = Noise.GenerateNoiseMap(noise, chunkSize, noiseScale);
MeshInstance world = new MeshInstance();
world.Name = "World";
PlaneMesh plane = MapGenerator.GeneratePlaneMesh(chunkSize);
SpatialMaterial mat = new SpatialMaterial();
mat.AlbedoTexture = MapDisplay.DrawNoiseMapToTexture(noiseMap);
mat.AlbedoTexture.Flags = 1;
plane.Material = mat;
ArrayMesh mesh = MapGenerator.AddNoiseToMesh(plane, noiseMap, chunkSize, heightMultiplier, heightCurve);
world.Mesh = mesh;
AddChild(world);
world.Owner = this;
}
/// <summary>
/// Finalizes mesh drawing and adds the built mesh to
/// the world environment.
/// </summary>
public void CommitSurface()
{
GD.Print("COMMITING DRAWING");
ArrayMesh finalSurface = Surface.Commit();
adder.AddMesh(finalSurface);
}
public static ArrayMesh GenerateMesh(float[,] noiseMap, float heightMultiplier, Curve heightCurve, int lod)
{
int width = noiseMap.GetLength(0);
int height = noiseMap.GetLength(1);
Vector3[] vertices = new Vector3[width * height];
Vector3[] normals = new Vector3[width * height];
Vector2[] uvs = new Vector2[width * height];
int[] indices = new int[(width - 1) * (height - 1) * 6];
float topLeftX = (width - 1) / -2f;
float topLeftZ = (height - 1) / -2f;
int simplificationFactor = lod == 0 ? 1 : lod * 2;
int verticesPerLine = (width - 1) / simplificationFactor + 1;
int vertices_idx = 0;
for (int y = 0; y < height; y += simplificationFactor)
{
for (int x = 0; x < width; x += simplificationFactor)
{
vertices[vertices_idx] = new Vector3(topLeftX + x, heightCurve.Interpolate(noiseMap[x, y]) * heightMultiplier, topLeftZ + y);
uvs[vertices_idx] = new Vector2(x / (float)width, y / (float)height);
++vertices_idx;
}
}
int indices_idx = 0;
vertices_idx = 0;
for (int y = 0; y < height; y += simplificationFactor)
{
for (int x = 0; x < width; x += simplificationFactor)
{
if (x < width - 1 && y < height - 1)
{
AddTriangle(vertices, indices, normals, vertices_idx, vertices_idx + verticesPerLine + 1, vertices_idx + verticesPerLine, indices_idx);
AddTriangle(vertices, indices, normals, vertices_idx, vertices_idx + 1, vertices_idx + verticesPerLine + 1, indices_idx + 3);
indices_idx += 6;
}
++vertices_idx;
}
}
var meshArrays = new Godot.Collections.Array();
meshArrays.Resize((int)ArrayMesh.ArrayType.Max);
meshArrays[(int)ArrayMesh.ArrayType.Vertex] = vertices;
meshArrays[(int)ArrayMesh.ArrayType.TexUv] = uvs;
meshArrays[(int)ArrayMesh.ArrayType.Index] = indices;
meshArrays[(int)ArrayMesh.ArrayType.Normal] = normals;
ArrayMesh mesh = new ArrayMesh();
mesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, meshArrays);
return(mesh);
}
public ComputedMembraneData(List <Vector2> organellePositions, MembraneType type, List <Vector2> vertices2D,
ArrayMesh mesh, int surfaceIndex)
{
OrganellePositions = organellePositions;
Type = type;
Vertices2D = vertices2D;
GeneratedMesh = mesh;
SurfaceIndex = surfaceIndex;
}
//Creates a mesh from a surface tool
public static ArrayMesh CreateMeshFromSurfaceTool(SurfaceTool surfTool)
{
var mesh = new ArrayMesh();
surfTool.GenerateNormals();
surfTool.Index();
surfTool.Commit(mesh);
return(mesh);
}
protected ArrayMesh changeSkinColorSurface(ArrayMesh oldMesh, UMAReciepe reciepe)
{
var skinableSlots = new Dictionary <string, string>();
foreach (var slot in reciepe.slots)
{
var origSlot = _slotList[slot.Key];
var slotName = slot.Key;
float glow = origSlot.Glow;
if (origSlot.skinGroup.ToString() != "None")
{
skinableSlots.Add(slot.Key, origSlot.skinGroup.ToString());
}
foreach (var overlay in slot.Value)
{
var overlayName = slotName + "/Overlay_" + overlay.Key;
var origOverlay = origSlot.overlayList[overlay.Key];
if (origOverlay != null)
{
string materialPath = null;
if (!String.IsNullOrEmpty(overlay.Value.usedMaterial) && origOverlay.isSkinable)
{
materialPath = System.IO.Path.Combine(origOverlay.fabricPath, overlay.Value.usedMaterial + ".tres");
}
bool useAlbedoColor = origOverlay.useSkinColor;
Color albedoColor = overlay.Value.overlayAlbedoColor;
assignMaterialOverlay(oldMesh, overlayName, useAlbedoColor, albedoColor, materialPath, glow);
}
}
}
foreach (var skinableSlot in skinableSlots)
{
var color = reciepe.skinColor.FirstOrDefault(df => df.Key == skinableSlot.Value);
if (color.Key == null)
{
continue;
}
var surface = oldMesh.SurfaceFindByName(skinableSlot.Key);
if (surface >= 0)
{
var mat = oldMesh.SurfaceGetMaterial(surface);
if (mat != null && mat is SpatialMaterial)
{
(mat as SpatialMaterial).AlbedoColor = color.Value;
}
}
}
return(oldMesh);
}
void apply_color(ArrayMesh am)
{
int surface_count = am.GetSurfaceCount();
SpatialMaterial[] mats = make_materials(surface_count);
for (int i = 0; i < surface_count; i++)
{
am.SurfaceSetMaterial(i, mats[i]);
}
}
private void GenerateMesh()
{
ArrayMesh mesh = MeshGenerator.GenerateMesh(noiseMap, MeshHeightMultiplier, MeshHeightCurve, LevelOfDetail);
MeshInstance meshInstance = GetNode<MeshInstance>("MeshInstance");
meshInstance.Mesh = mesh;
meshInstance.CreateTrimeshCollision();
SpatialMaterial material = new SpatialMaterial();
material.AlbedoTexture = TextureGenerator.GenerateColorTexture(noiseMap, RegionThresholds, RegionColors);
mesh.SurfaceSetMaterial(0, material);
}
//Creates a mesh instance from a mesh.
public static MeshInstance CreateMeshInstanceFromMesh(ArrayMesh mesh)
{
var meshInstance = new MeshInstance();
meshInstance.SetMesh(mesh);
//meshInstance.SetCastShadowsSetting(GeometryInstance.ShadowCastingSetting.On);
meshInstance.CreateTrimeshCollision();
return(meshInstance);
}
public void Generate()
{
planeMesh = new PlaneMesh();
planeMesh.Size = new Vector2(chunkSize, chunkSize);
planeMesh.SubdivideDepth = Mathf.RoundToInt(chunkSize * 0.5f);
planeMesh.SubdivideWidth = Mathf.RoundToInt(chunkSize * 0.5f);
surfaceTool = new SurfaceTool();
meshDataTool = new MeshDataTool();
surfaceTool.CreateFrom(planeMesh, 0);
arrayPlane = surfaceTool.Commit();
meshDataTool.CreateFromSurface(arrayPlane, 0);
for (int i = 0; i < meshDataTool.GetVertexCount(); i++)
{
Vector3 vertex = meshDataTool.GetVertex(i);
vertex.y = noise.GetNoise3d(
vertex.x + position.x,
vertex.y,
vertex.z + position.z) * References.steepness;
meshDataTool.SetVertex(i, vertex);
avgHeight += vertex.y;
}
avgHeight /= meshDataTool.GetVertexCount();
for (int i = 0; i < arrayPlane.GetSurfaceCount(); i++)
{
arrayPlane.SurfaceRemove(i);
}
for (int i = 0; i < meshDataTool.GetFaceCount(); i++)
{
Vector3 A = meshDataTool.GetVertex(meshDataTool.GetFaceVertex(i, 0));
Vector3 B = meshDataTool.GetVertex(meshDataTool.GetFaceVertex(i, 1));
Vector3 C = meshDataTool.GetVertex(meshDataTool.GetFaceVertex(i, 2));
Vector3 face = (A + B + C) / 3 + position;
Vector3 normal = meshDataTool.GetFaceNormal(i);
slope += Maths.Angle(Vector3.Up, normal);
}
slope /= meshDataTool.GetFaceCount();
meshDataTool.CommitToSurface(arrayPlane);
surfaceTool.Begin(Mesh.PrimitiveType.Triangles);
surfaceTool.CreateFrom(arrayPlane, 0);
surfaceTool.GenerateNormals();
meshInstance = new MeshInstance();
meshInstance.Mesh = surfaceTool.Commit();
meshInstance.SetSurfaceMaterial(0, (Material)ResourceLoader.Load("res://Assets/Shader/Terrain.material"));
meshInstance.CreateTrimeshCollision();
meshInstance.CastShadow = GeometryInstance.ShadowCastingSetting.On;
AddChild(meshInstance);
}
public static IEnumerable <string> GetBlendShapeNames(this ArrayMesh mesh)
{
Ensure.That(mesh, nameof(mesh)).IsNotNull();
var count = mesh.GetBlendShapeCount();
for (var i = 0; i < count; i++)
{
yield return(mesh.GetBlendShapeName(i));
}
}
public static IEnumerable <IMeshSurface> GetSurfaces(this ArrayMesh mesh)
{
Ensure.That(mesh, nameof(mesh)).IsNotNull();
var count = mesh.GetSurfaceCount();
for (var i = 0; i < count; i++)
{
yield return(new ArrayMeshSurface(mesh, i));
}
}
public void SetMaterial(Material material)
{
if (meshInstance == null)
{
GD.Print(name + " has no mesh to set material to");
return;
}
ArrayMesh mesh = meshInstance.Mesh as ArrayMesh;
mesh.SurfaceSetMaterial(0, material);
}
public Material GetMaterial()
{
if (meshInstance == null)
{
GD.Print(name + " has no mesh to get material from");
return(null);
}
ArrayMesh mesh = meshInstance.Mesh as ArrayMesh;
return(mesh.SurfaceGetMaterial(0));
}
public ArrayMesh CreateTheMesh()
{
Array arr = new Array();
arr.Resize((int)Mesh.ArrayType.Max);
arr[(int)Mesh.ArrayType.Vertex] = verts.ToArray();
arr[(int)Mesh.ArrayType.Index] = indices.ToArray();
arr[(int)Mesh.ArrayType.TexUv] = uvs.ToArray();
var arrayMesh = new ArrayMesh();
arrayMesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, arr);
return(arrayMesh);
}
private void ConstructArrayMesh(Vector3[] vertices, int[] triangles, Vector3[] normals)
{
var mesht = new ArrayMesh();
object[] arr = new object[(int)Mesh.ArrayType.Max];
arr[(int)Mesh.ArrayType.Vertex] = vertices;
arr[(int)Mesh.ArrayType.Index] = triangles;
arr[(int)Mesh.ArrayType.Normal] = normals;
mesht.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, new Godot.Collections.Array(arr));
this.Mesh = mesht;
this.Mesh.SurfaceSetMaterial(0, ResourceLoader.Load("Terrain/terrain.tres") as Material);
}
// Apply the default material on each surface
private static void ApplyMaterial(ArrayMesh mesh)
{
if (DefaultMaterial is null)
{
DefaultMaterial = (SpatialMaterial)ResourceLoader.Load(DefaultMaterialPath);
}
// Apply the material on each surface
for (int i = 0; i < mesh.GetSurfaceCount(); i++)
{
mesh.SurfaceSetMaterial(i, DefaultMaterial);
}
}
protected void assignMaterialOverlay(ArrayMesh oldMesh, string overlayName, bool useAlbedo, Color albedoColor, string materialPath, float glow)
{
if (oldMesh == null)
{
return;
}
for (int surface = 0; surface < oldMesh.GetSurfaceCount(); surface++)
{
var name = oldMesh.SurfaceGetName(surface);
if (!name.Contains(overlayName))
{
continue;
}
var material = oldMesh.SurfaceGetMaterial(surface);
if (!String.IsNullOrEmpty(materialPath))
{
//fix path combine (system.io)
materialPath = materialPath.Replace(@"\", @"/");
if ((material == null) || (material.ResourcePath != materialPath))
{
var newMaterial = GD.Load <Material>(materialPath);
if (newMaterial is SpatialMaterial)
{
(newMaterial as SpatialMaterial).ParamsGrow = true;
(newMaterial as SpatialMaterial).ParamsGrowAmount = glow;
}
newMaterial.ResourceLocalToScene = true;
material = newMaterial;
}
}
if (material != null)
{
if (useAlbedo)
{
(material as SpatialMaterial).AlbedoColor = albedoColor;
}
(material as SpatialMaterial).ParamsGrow = true;
(material as SpatialMaterial).ParamsGrowAmount = glow;
oldMesh.SurfaceSetMaterial(surface, material);
}
}
}
