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 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);
}
/**
* 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);
}
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);
}
private void Generate()
{
if (!_initialized)
{
return;
}
_surfaceTool.Clear();
_meshDataTool.Clear();
_surfaceTool.CreateFrom(_meshInstance.Mesh, 0);
_meshDataTool.CreateFromSurface(_surfaceTool.Commit(), 0);
int numVertices = _meshDataTool.GetVertexCount();
_data = new float[numVertices];
for (int i = 0; i < numVertices; i++)
{
Vector3 vertex = _meshDataTool.GetVertex(i);
_data[i] = Amplitude * _noise.GetNoise2d(vertex.x, vertex.z);
_meshDataTool.SetVertex(i, new Vector3(vertex.x, _data[i], vertex.z));
_meshDataTool.SetVertexNormal(i, Vector3.Up);
}
for (int i = 0; i < numVertices - _resX; i++)
{
Vector3 a = _meshDataTool.GetVertex(i);
Vector3 b = _meshDataTool.GetVertex(i + 1);
Vector3 c = _meshDataTool.GetVertex(i + _resX);
Vector3 normal = (c - a).Cross(b - a);
for (int j = i; j < i + 3; j++)
{
_meshDataTool.SetVertexNormal(j, _meshDataTool.GetVertexNormal(j) + normal);
}
}
for (int i = 0; i < numVertices; i++)
{
_meshDataTool.SetVertexNormal(i, _meshDataTool.GetVertexNormal(i).Normalized());
}
ArrayMesh newMesh = new ArrayMesh();
_meshDataTool.CommitToSurface(newMesh);
_meshInstance.Mesh = newMesh;
_meshInstance.RemoveChild(_meshInstance.GetChild(0));
_meshInstance.CreateTrimeshCollision();
}
private void Deform()
{
var sn = new OpenSimplexNoise();
sn.Period = Period;
sn.Octaves = Octaves;
sn.Seed = Seed;
sn.Persistence = Persistence;
sn.Lacunarity = Lacunarity;
var mesh = sphere.Mesh;
var st = new SurfaceTool();
st.CreateFrom(mesh, 0);
var array = st.Commit();
var dt = new MeshDataTool();
dt.CreateFromSurface(array, 0);
var count = dt.GetVertexCount();
var origin = Vector3.Zero;
for (int i = 0; i < count; i++)
{
var vertex = dt.GetVertex(i);
var n = -vertex.DirectionTo(origin);
var noise = sn.GetNoise3d(vertex.x, vertex.y, vertex.z);
noise = Mathf.Clamp(noise, -1f, 1f);
vertex += n * noise * MoveFactor;
dt.SetVertex(i, vertex);
}
var surfCount = array.GetSurfaceCount();
for (int i = 0; i < surfCount; i++)
{
array.SurfaceRemove(i);
}
dt.CommitToSurface(array);
st.Begin(Mesh.PrimitiveType.Triangles);
st.CreateFrom(array, 0);
st.GenerateNormals();
sphere.Mesh = st.Commit();
UpdateMaterial();
}
public override void _Ready()
{
// Assignment of required nodes
topViewPlane = GetNode <Spatial>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/ObjectRoot/TopViewPlane");
frontViewPlane = GetNode <Spatial>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/ObjectRoot/FrontViewPlane");
sideViewPlane = GetNode <Spatial>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/ObjectRoot/RightViewPlane");
mainDisplayRoot = GetNode <Node2D>("HorizontalViewContainer/MainProjectionDisplayContainer/MainProjectionViewport/ProjectionRoot");
topViewRoot = GetNode <Node2D>("HorizontalViewContainer/MainProjectionDisplayContainer/ViewGridContainer/TopViewportContainer/TopViewport/TopViewRoot");
frontViewRoot = GetNode <Node2D>("HorizontalViewContainer/MainProjectionDisplayContainer/ViewGridContainer/FrontViewportContainer/FrontViewport/FrontViewRoot");
sideViewRoot = GetNode <Node2D>("HorizontalViewContainer/MainProjectionDisplayContainer/ViewGridContainer/SideViewportContainer/SideViewport/SideViewRoot");
//objectMesh = GetNode<MeshInstance>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/ObjectRoot/Spatial/ObjectMesh6");
objectBody = GetNode <StaticBody>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/ObjectRoot/Object3");
objectMesh = GetNode <MeshInstance>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/ObjectRoot/Object3/ObjectMesh");
ControlsNode = GetNode <Control>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/Controls");
FocusZoomSlider = GetNode <HSlider>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/Controls/ControlsPanel/ViewControl/FocusZoomSlider");
ObjectXDegSlider = GetNode <HSlider>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/Controls/ControlsPanel/ObjectControl/HBoxContainer/SlidersVBoxContainer/ObjectXDegSlider");
ObjectYDegSlider = GetNode <HSlider>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/Controls/ControlsPanel/ObjectControl/HBoxContainer/SlidersVBoxContainer/ObjectYDegSlider");
ObjectZDegSlider = GetNode <HSlider>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/Controls/ControlsPanel/ObjectControl/HBoxContainer/SlidersVBoxContainer/ObjectZDegSlider");
viewList = GetNode <OptionButton>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/Controls/ControlsPanel/ViewControl/ViewSelectList");
viewGrid = GetNode <GridContainer>("HorizontalViewContainer/MainProjectionDisplayContainer/ViewGridContainer");
// Creating SimplifiedMesh object data from mesh
objectArrayMesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, objectMesh.Mesh.SurfaceGetArrays(0));
objectData.CreateFromSurface(objectArrayMesh, 0);
basicObjectMesh = new SimplifiedMesh(objectData);
PlaneControl.objectMesh = objectMesh;
PlaneControl.basicObjectMesh = basicObjectMesh;
PlaneControl.ray = GetNode <RayCast>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/ObjectRoot/HiddenLineRayCast");
//PlaneControl.pointCollision = GetNode<Area>("HorizontalViewContainer/ObjectViewContainter/ObjectViewport/ObjectRoot/PointCollision");
//GetTree().CallGroup("Slider", "Connect", "value_changed", this, nameof(ChangeDisplay));
selectedView = viewList.GetSelectedId();
SetDisplay();
Display();
}
public void RebuildOutputMesh()
{
GD.Print("REBUILDING COLOR MESH");
var inputNode = FindNode("Input") as MeshInstance;
var outputNode = FindNode("Output") as MeshInstance;
var mesh = inputNode.Mesh as ArrayMesh;
if (mesh == null)
{
GD.Print("no mesh found on input node. aborting");
return;
}
var surfaceCount = mesh.GetSurfaceCount();
var surfaceQueue = new Queue <MeshDataTool>();
for (var i = 0; i < surfaceCount; i++)
{
var mdt = new MeshDataTool();
mdt.CreateFromSurface(mesh, 0);
BarycentricProcessor._SetVertexColorToBarycentric(mdt);
mesh.SurfaceRemove(0);
surfaceQueue.Enqueue(mdt);
}
//replace our mesh with modified version
while (surfaceQueue.Count > 0)
{
var mdt = surfaceQueue.Dequeue();
mdt.CommitToSurface(mesh);
mdt.Dispose();
}
outputNode.Mesh = mesh;
}
// Declare member variables here. Examples:
// private int a = 2;
// private string b = "text";
// Called when the node enters the scene tree for the first time.
public override void _Ready()
{
var orig = GetNode <MeshInstance>("orig");
var tights = GetNode <MeshInstance>("tights");
var result = GetNode <MeshInstance>("result");
var tmpMesh = new ArrayMesh();
var surfaceTool = new SurfaceTool();
surfaceTool.Begin(Mesh.PrimitiveType.Triangles);
var tool = new MeshDataTool();
tool.CreateFromSurface((ArrayMesh)tights.Mesh, 0);
var tool2 = new MeshDataTool();
tool2.CreateFromSurface((ArrayMesh)orig.Mesh, 0);
List <Vector3> vertices = new List <Vector3>();
for (int v = 0; v < tool2.GetVertexCount(); v++)
{
vertices.Add(tool2.GetVertex(v));
}
for (int v = 0; v < tool.GetVertexCount(); v++)
{
// surfaceTool.AddNormal(tool.GetVertexNormal(v));
// surfaceTool.AddColor(tool.GetVertexColor(v));
// surfaceTool.AddUv(tool.GetVertexUv(v));
// surfaceTool.AddUv2(tool.GetVertexUv2(v));
// surfaceTool.AddTangent(tool.GetVertexTangent(v));
var newVer = tool.GetVertex(v);
var replace = vertices.OrderBy(df => newVer.DistanceTo(df)).FirstOrDefault();
if (replace != null && replace != Vector3.Zero && replace.DistanceTo(newVer) > 0.03f)
{
GD.Print("replace" + newVer + " by dist " + replace.DistanceTo(newVer));
surfaceTool.AddVertex(replace);
}
else
{
surfaceTool.AddVertex(newVer);
}
}
for (int fc = 0; fc < tool.GetFaceCount(); fc++)
{
for (var i = 0; i <= 2; i++)
{
var ind = tool.GetFaceVertex(fc, i);
surfaceTool.AddIndex(ind);
}
}
surfaceTool.Commit(tmpMesh);
result.Mesh = tmpMesh;
}
private Godot.Collections.Array createSurfaceByBones(ArrayMesh mesh, int surface, Skin newSkin, List <UMAReciepeBindPose> origBindPoses)
{
var mdt = new MeshDataTool();
mdt.CreateFromSurface(mesh, surface);
var st = new SurfaceTool();
st.Begin(Mesh.PrimitiveType.Triangles);
var newBindPoses = new List <UMAReciepeBindPose>();
if (newSkin != null)
{
for (int i = 0; i < newSkin.GetBindCount(); i++)
{
newBindPoses.Add(new UMAReciepeBindPose
{
boneName = newSkin.GetBindName(i),
transform = newSkin.GetBindPose(i),
boneIndex = newSkin.GetBindBone(i)
});
}
}
var boneAmount = 0;
for (int i = 0; i < mdt.GetVertexCount(); i++)
{
var oldVer = mdt.GetVertex(i);
var oldNorm = mdt.GetVertexNormal(i);
var newVer = new Vector3();
var newNorm = new Vector3();
var indexes = mdt.GetVertexBones(i);
// st.AddTangent(mdt.GetVertexTangent(i));
st.AddBones(mdt.GetVertexBones(i));
st.AddWeights(mdt.GetVertexWeights(i));
int boneId = 0;
foreach (var weight in mdt.GetVertexWeights(i))
{
if (newBindPoses.Count >= indexes[boneId] && origBindPoses.Count >= indexes[boneId])
{
var restBoneNew = newBindPoses[indexes[boneId]];
var restBoneTemplate = origBindPoses[indexes[boneId]];
var dataup = restBoneNew.transform.Xform(Vector3.Up);
var dataright = restBoneNew.transform.Xform(Vector3.Right);
var templateup = restBoneTemplate.transform.Xform(Vector3.Up);
var templateright = restBoneTemplate.transform.Xform(Vector3.Right);
if (Mathf.Abs(dataup.AngleTo(templateup)) > 1 || Mathf.Abs(dataright.AngleTo(templateright)) > 1)
{
Transform convertMatrix = restBoneTemplate.transform.Inverse() * restBoneNew.transform;
newVer += convertMatrix.Xform(oldVer) * weight;
newNorm += convertMatrix.basis.Xform(oldNorm) * weight;
}
else
{
newVer += oldVer * weight;
newNorm += oldNorm * weight;
}
}
else
{
newVer += oldVer * weight;
newNorm += oldNorm * weight;
}
boneId++;
}
st.AddUv(mdt.GetVertexUv(i));
if (mdt.GetVertexColor(i) != null)
{
st.AddColor(mdt.GetVertexColor(i));
}
if (mdt.GetVertexUv2(i) != null)
{
st.AddUv2(mdt.GetVertexUv2(i));
}
st.AddNormal(newNorm);
st.AddVertex(newVer);
boneAmount += mdt.GetVertexBones(i).Length;
}
//creating indexes
for (int face = 0; face < mdt.GetFaceCount(); face++)
{
for (int faceI = 0; faceI < 3; faceI++)
{
var ind = mdt.GetFaceVertex(face, faceI);
st.AddIndex(ind);
}
}
st.GenerateTangents();
return(st.CommitToArrays());
}
public override void _Ready()
{
var mesh = new PlaneMesh();
mesh.Size = new Vector2(size, size);
mesh.SubdivideDepth = 3;
mesh.SubdivideWidth = (int)position.x == 0 ? (int)size : 3;
var surface_tool = new SurfaceTool();
surface_tool.CreateFrom(mesh, 0);
var mesh_tool = new MeshDataTool();
mesh_tool.CreateFromSurface(surface_tool.Commit(), 0);
var biome = GetBiome(/*hydro_noise.GetNoise2dv(position / size), */ heat_noise.GetNoise2d(position.x / size / 10.0f, position.y));
for (int i = 0; i < mesh_tool.GetVertexCount(); ++i)
{
var vertex = mesh_tool.GetVertex(i);
var vertex_global_pos = position + new Vector2(vertex.x, vertex.z);
var height_noise_val = height_noise.GetNoise2dv(vertex_global_pos);
vertex.y = height_noise_val * 20;
var color_factor = (height_noise_val + 1) / 2.0f;
var hydro_val = (int)Math.Round(hydro_noise.GetNoise2dv(vertex_global_pos));
if ((int)vertex.x == 0 && (int)position.x == 0)
{
mesh_tool.SetVertexColor(i, new Color(color_factor, color_factor / 2, 0.0f));
}
else if (hydro_val == -1)
{
mesh_tool.SetVertexColor(i, biome.dry_color * color_factor);
}
else if (hydro_val == 1)
{
mesh_tool.SetVertexColor(i, biome.humid_color * color_factor);
}
else
{
mesh_tool.SetVertexColor(i, biome.ground_color * color_factor);
}
mesh_tool.SetVertex(i, vertex);
}
/*if (base_tree_mesh == null && ResourceLoader.Exists("res://assets/tree.obj"))
* {
* base_tree_mesh = ResourceLoader.Load<Mesh>("res://assets/tree.obj");
* }
* if (base_tree_material == null && ResourceLoader.Exists("res://assets/tree.tres"))
* {
* Console.WriteLine("OK");
* base_tree_material = ResourceLoader.Load<SpatialMaterial>("res://assets/tree.tres");
* }
*
* MultiMesh trees = new MultiMesh();
* trees.Mesh = base_tree_mesh;
* trees.TransformFormat = MultiMesh.TransformFormatEnum.Transform3d;
*
* if ((int)position.x == 0)
* {
* var points1 = Utility.UniformPoissonDiskSampler.SampleRectangle(-new Vector2(size, size) / 2, new Vector2(-5, size / 2.0f), biome.tree_spacing);
* var points2 = Utility.UniformPoissonDiskSampler.SampleRectangle(new Vector2(5, 0), new Vector2(size, size) / 2, biome.tree_spacing);
* trees.InstanceCount = points1.Count + points2.Count;
*
* int i = 0;
* foreach (var p in points1)
* {
* trees.SetInstanceTransform(i, Transform.Identity.Scaled(new Vector3(1, biome.tree_size, 1)).Translated(new Vector3(p.x, height_noise.GetNoise2dv(position + p) * 20, p.y)));
++i;
* }
*
* foreach (var p in points2)
* {
* trees.SetInstanceTransform(i, Transform.Identity.Scaled(new Vector3(1, biome.tree_size, 1)).Translated(new Vector3(p.x, height_noise.GetNoise2dv(position + p) * 20, p.y)));
++i;
* }
* }
* else
* {
* var points = Utility.UniformPoissonDiskSampler.SampleRectangle(-new Vector2(size, size) / 2, new Vector2(size, size) / 2, biome.tree_spacing);
* trees.InstanceCount = points.Count;
* int i = 0;
* foreach (var p in points)
* {
* trees.SetInstanceTransform(i, Transform.Identity.Scaled(new Vector3(1, biome.tree_size, 1)).Translated(new Vector3(p.x, height_noise.GetNoise2dv(position + p) * 20, p.y)));
++i;
* }
* }
*
* MultiMeshInstance child = new MultiMeshInstance();
* child.Multimesh = trees;
* child.MaterialOverride = base_tree_material;
* AddChild(child);*/
var array = new ArrayMesh();
mesh_tool.CommitToSurface(array);
Mesh = array;
if (base_shader == null && ResourceLoader.Exists("res://assets/chunk_shader.tres"))
{
base_shader = ResourceLoader.Load <ShaderMaterial>("res://assets/chunk_shader.tres");
}
var shader = base_shader;
MaterialOverride = shader;
}
