wehub-resource-sync
789 lines
31 KiB
C#
789 lines
31 KiB
C#
using T3.Core.Rendering;
|
|
using T3.Core.Utils;
|
|
|
|
namespace Lib.mesh.generate;
|
|
|
|
[Guid("E0CEAD3C-E19C-4726-8B5C-A9FEFBF96AB9")]
|
|
internal sealed class IcosahedronMesh : Instance<IcosahedronMesh>
|
|
{
|
|
[Output(Guid = "9c86f704-a28f-4d2a-b7c0-15648f982463")]
|
|
public readonly Slot<MeshBuffers> Data = new();
|
|
|
|
public IcosahedronMesh()
|
|
{
|
|
Data.UpdateAction += Update;
|
|
}
|
|
|
|
private void Update(EvaluationContext context)
|
|
{
|
|
try
|
|
{
|
|
var scale = Scale.GetValue(context);
|
|
var stretch = Stretch.GetValue(context);
|
|
var pivot = Pivot.GetValue(context);
|
|
var rotation = Rotation.GetValue(context);
|
|
var center = Center.GetValue(context);
|
|
var subdivisions = Subdivisions.GetValue(context).Clamp(0, 5);
|
|
var spherical = Spherical.GetValue(context);
|
|
var strength = Strength.GetValue(context);
|
|
var uvMapMode = TexCoord.GetValue(context);
|
|
var uvMapMode2 = TexCoord2.GetValue(context);
|
|
var uvMapper = GetUvMapper(uvMapMode, subdivisions);
|
|
var uvMapper2 = GetUvMapper(uvMapMode2, subdivisions);
|
|
var shadingMode = Shading.GetValue(context);
|
|
|
|
var yaw = rotation.Y.ToRadians();
|
|
var pitch = rotation.X.ToRadians();
|
|
var roll = rotation.Z.ToRadians();
|
|
|
|
// Apply the icosahedron tilt adjustment
|
|
var rollOffset = roll - _icosahedronTiltAngle;
|
|
|
|
var rotationMatrix = Matrix4x4.CreateFromYawPitchRoll(yaw, pitch, rollOffset);
|
|
|
|
// Generate mesh using flat shading structure
|
|
var (vertices, triangles) = GenerateIcosahedron();
|
|
|
|
if (subdivisions > 0)
|
|
SubdivideMeshFlat(ref vertices, ref triangles, subdivisions, strength, spherical);
|
|
|
|
if (uvMapper is Unwrapped unwrappedUv)
|
|
unwrappedUv.Prepare(vertices, triangles);
|
|
|
|
if (uvMapper2 is Unwrapped unwrappedUv2)
|
|
unwrappedUv2.Prepare(vertices, triangles);
|
|
|
|
|
|
// Calculate normals based on shading mode
|
|
var normals = (shadingMode == (int)ShadingModes.Smoothed)
|
|
? CalculateSmoothNormals(vertices, triangles)
|
|
: CalculateFlatNormals(vertices, triangles);
|
|
|
|
// Debug: Log a few normals to compare
|
|
/* if (vertices.Length >= 3)
|
|
{
|
|
Log.Debug($"Shading: {(shadingMode == (int)ShadingModes.Smoothed ? "Smooth" : "Flat")}");
|
|
Log.Debug($"Normal[0]: {normals[0]}");
|
|
Log.Debug($"Normal[1]: {normals[1]}");
|
|
Log.Debug($"Normal[2]: {normals[2]}");
|
|
}*/
|
|
|
|
// Create buffers
|
|
if (_vertexBufferData.Length != vertices.Length)
|
|
_vertexBufferData = new PbrVertex[vertices.Length];
|
|
|
|
if (_indexBufferData.Length != triangles.Length)
|
|
_indexBufferData = new Int3[triangles.Length];
|
|
|
|
// Transform vertices
|
|
var centerVec = new Vector3(center.X, center.Y, center.Z);
|
|
var offset = new Vector3(
|
|
stretch.X * scale * pivot.X,
|
|
stretch.Y * scale * pivot.Y,
|
|
stretch.X * scale * pivot.Z
|
|
);
|
|
|
|
for (int i = 0; i < vertices.Length; i++)
|
|
{
|
|
var pos = new Vector3(
|
|
vertices[i].X * scale * stretch.X,
|
|
vertices[i].Y * scale * stretch.Y,
|
|
vertices[i].Z * scale * stretch.X
|
|
);
|
|
|
|
pos = Vector3.Transform(pos + offset, rotationMatrix) + centerVec;
|
|
|
|
var uv = uvMapper.CalculateUV(vertices[i], normals[i], i % 3, i / 3); // Use i / 3 for triangle index
|
|
var uv2 = uvMapper2.CalculateUV(vertices[i], normals[i], i % 3, i / 3);
|
|
|
|
_vertexBufferData[i] = new PbrVertex
|
|
{
|
|
Position = pos,
|
|
Normal = Vector3.TransformNormal(normals[i], rotationMatrix),
|
|
Tangent = Vector3.TransformNormal(Vector3.Cross(normals[i], Vector3.UnitY), rotationMatrix),
|
|
Bitangent = Vector3.TransformNormal(Vector3.Cross(normals[i], Vector3.UnitX), rotationMatrix),
|
|
Texcoord = uv,
|
|
Texcoord2 = uv2,
|
|
Selection = 1,
|
|
ColorRgb = Vector3.One,
|
|
};
|
|
}
|
|
|
|
// Fill index buffer
|
|
for (var i = 0; i < triangles.Length; i++)
|
|
{
|
|
_indexBufferData[i] = new Int3(
|
|
triangles[i].X,
|
|
triangles[i].Y,
|
|
triangles[i].Z
|
|
);
|
|
}
|
|
|
|
// Write Data
|
|
ResourceManager.SetupStructuredBuffer(_vertexBufferData, PbrVertex.Stride * vertices.Length, PbrVertex.Stride, ref _vertexBuffer);
|
|
ResourceManager.CreateStructuredBufferSrv(_vertexBuffer, ref _vertexBufferWithViews.Srv);
|
|
ResourceManager.CreateStructuredBufferUav(_vertexBuffer, UnorderedAccessViewBufferFlags.None, ref _vertexBufferWithViews.Uav);
|
|
_vertexBufferWithViews.Buffer = _vertexBuffer;
|
|
|
|
const int stride = 3 * 4;
|
|
ResourceManager.SetupStructuredBuffer(_indexBufferData, stride * triangles.Length, stride, ref _indexBuffer);
|
|
ResourceManager.CreateStructuredBufferSrv(_indexBuffer, ref _indexBufferWithViews.Srv);
|
|
ResourceManager.CreateStructuredBufferUav(_indexBuffer, UnorderedAccessViewBufferFlags.None, ref _indexBufferWithViews.Uav);
|
|
_indexBufferWithViews.Buffer = _indexBuffer;
|
|
|
|
_data.VertexBuffer = _vertexBufferWithViews;
|
|
_data.IndicesBuffer = _indexBufferWithViews;
|
|
Data.Value = _data;
|
|
Data.DirtyFlag.Clear();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error("Failed to create icosahedron mesh: " + e.Message);
|
|
}
|
|
}
|
|
|
|
private static (Vector3[] vertices, Int3[] triangles) GenerateIcosahedron()
|
|
{
|
|
var baseVertices = new Vector3[12];
|
|
baseVertices[0] = Vector3.Normalize(new Vector3(-1, phi, 0));
|
|
baseVertices[1] = Vector3.Normalize(new Vector3(1, phi, 0));
|
|
baseVertices[2] = Vector3.Normalize(new Vector3(-1, -phi, 0));
|
|
baseVertices[3] = Vector3.Normalize(new Vector3(1, -phi, 0));
|
|
baseVertices[4] = Vector3.Normalize(new Vector3(0, -1, phi));
|
|
baseVertices[5] = Vector3.Normalize(new Vector3(0, 1, phi));
|
|
baseVertices[6] = Vector3.Normalize(new Vector3(0, -1, -phi));
|
|
baseVertices[7] = Vector3.Normalize(new Vector3(0, 1, -phi));
|
|
baseVertices[8] = Vector3.Normalize(new Vector3(phi, 0, -1));
|
|
baseVertices[9] = Vector3.Normalize(new Vector3(phi, 0, 1));
|
|
baseVertices[10] = Vector3.Normalize(new Vector3(-phi, 0, -1));
|
|
baseVertices[11] = Vector3.Normalize(new Vector3(-phi, 0, 1));
|
|
|
|
// Original triangles (20 faces)
|
|
var baseTriangles = new Int3[20];
|
|
baseTriangles[0] = new Int3(0, 11, 5);
|
|
baseTriangles[1] = new Int3(0, 5, 1);
|
|
baseTriangles[2] = new Int3(0, 1, 7);
|
|
baseTriangles[3] = new Int3(0, 7, 10);
|
|
baseTriangles[4] = new Int3(0, 10, 11);
|
|
baseTriangles[5] = new Int3(5, 11, 4);
|
|
baseTriangles[6] = new Int3(1, 5, 9);
|
|
baseTriangles[7] = new Int3(7, 1, 8);
|
|
baseTriangles[8] = new Int3(10, 7, 6);
|
|
baseTriangles[9] = new Int3(11, 10, 2);
|
|
baseTriangles[10] = new Int3(3, 9, 4);
|
|
baseTriangles[11] = new Int3(3, 8, 9);
|
|
baseTriangles[12] = new Int3(3, 6, 8);
|
|
baseTriangles[13] = new Int3(3, 2, 6);
|
|
baseTriangles[14] = new Int3(3, 4, 2);
|
|
baseTriangles[15] = new Int3(4, 9, 5);
|
|
baseTriangles[16] = new Int3(9, 8, 1);
|
|
baseTriangles[17] = new Int3(8, 6, 7);
|
|
baseTriangles[18] = new Int3(6, 2, 10);
|
|
baseTriangles[19] = new Int3(2, 4, 11);
|
|
|
|
// Split vertices for flat shading (each triangle gets its own vertices)
|
|
var vertices = new List<Vector3>();
|
|
var triangles = new List<Int3>();
|
|
|
|
foreach (var tri in baseTriangles)
|
|
{
|
|
var v0 = vertices.Count;
|
|
vertices.Add(baseVertices[tri.X]);
|
|
vertices.Add(baseVertices[tri.Y]);
|
|
vertices.Add(baseVertices[tri.Z]);
|
|
triangles.Add(new Int3(v0, v0 + 1, v0 + 2));
|
|
}
|
|
|
|
return (vertices.ToArray(), triangles.ToArray());
|
|
}
|
|
|
|
private static Vector3[] CalculateFlatNormals(Vector3[] vertices, Int3[] triangles)
|
|
{
|
|
var normals = new Vector3[vertices.Length];
|
|
|
|
for (var i = 0; i < triangles.Length; i++)
|
|
{
|
|
var tri = triangles[i];
|
|
Vector3 v1 = vertices[tri.X];
|
|
Vector3 v2 = vertices[tri.Y];
|
|
Vector3 v3 = vertices[tri.Z];
|
|
|
|
Vector3 normal = Vector3.Normalize(Vector3.Cross(v2 - v1, v3 - v1));
|
|
|
|
normals[tri.X] = normal;
|
|
normals[tri.Y] = normal;
|
|
normals[tri.Z] = normal;
|
|
}
|
|
|
|
return normals;
|
|
}
|
|
|
|
private static Vector3[] CalculateSmoothNormals(Vector3[] vertices, Int3[] triangles)
|
|
{
|
|
var normals = new Vector3[vertices.Length];
|
|
|
|
// Group vertices by position to identify duplicates
|
|
var positionToIndices = new Dictionary<Vector3, List<int>>(new Vector3EqualityComparer());
|
|
for (var i = 0; i < vertices.Length; i++)
|
|
{
|
|
if (!positionToIndices.ContainsKey(vertices[i]))
|
|
positionToIndices[vertices[i]] = new List<int>();
|
|
positionToIndices[vertices[i]].Add(i);
|
|
}
|
|
|
|
// Calculate face normals and accumulate for each vertex position
|
|
var positionNormals = new Dictionary<Vector3, Vector3>(new Vector3EqualityComparer());
|
|
var positionTriangleCount = new Dictionary<Vector3, int>(new Vector3EqualityComparer());
|
|
|
|
for (var i = 0; i < triangles.Length; i++)
|
|
{
|
|
var tri = triangles[i];
|
|
var v1 = vertices[tri.X];
|
|
var v2 = vertices[tri.Y];
|
|
var v3 = vertices[tri.Z];
|
|
|
|
var normal = Vector3.Normalize(Vector3.Cross(v2 - v1, v3 - v1));
|
|
|
|
// Accumulate normal for each vertex position
|
|
foreach (var v in new[] { v1, v2, v3 })
|
|
{
|
|
if (!positionNormals.ContainsKey(v))
|
|
{
|
|
positionNormals[v] = Vector3.Zero;
|
|
positionTriangleCount[v] = 0;
|
|
}
|
|
positionNormals[v] += normal;
|
|
positionTriangleCount[v]++;
|
|
}
|
|
}
|
|
|
|
// Average normals per position
|
|
foreach (var kvp in positionNormals)
|
|
{
|
|
var pos = kvp.Key;
|
|
var normalSum = kvp.Value;
|
|
var count = positionTriangleCount[pos];
|
|
var averagedNormal = count > 0 ? Vector3.Normalize(normalSum / count) : Vector3.UnitY;
|
|
|
|
// Assign averaged normal to all vertices at this position
|
|
foreach (var index in positionToIndices[pos])
|
|
{
|
|
normals[index] = averagedNormal;
|
|
}
|
|
}
|
|
|
|
return normals;
|
|
}
|
|
|
|
// Helper class for comparing Vector3 positions with a small tolerance
|
|
private class Vector3EqualityComparer : IEqualityComparer<Vector3>
|
|
{
|
|
private const float Epsilon = 0.0001f;
|
|
|
|
public bool Equals(Vector3 a, Vector3 b)
|
|
{
|
|
return Math.Abs(a.X - b.X) < Epsilon &&
|
|
Math.Abs(a.Y - b.Y) < Epsilon &&
|
|
Math.Abs(a.Z - b.Z) < Epsilon;
|
|
}
|
|
|
|
public int GetHashCode(Vector3 obj)
|
|
{
|
|
unchecked
|
|
{
|
|
int hash = 17;
|
|
hash = hash * 23 + obj.X.GetHashCode();
|
|
hash = hash * 23 + obj.Y.GetHashCode();
|
|
hash = hash * 23 + obj.Z.GetHashCode();
|
|
return hash;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Subdivide mesh for flat shading (each triangle gets its own vertices)
|
|
private static void SubdivideMeshFlat(ref Vector3[] vertices, ref Int3[] triangles, int levels, float strength, bool spherical = true)
|
|
{
|
|
for (var i = 0; i < levels; i++)
|
|
{
|
|
var newTriangles = new List<Int3>(triangles.Length * 4);
|
|
var newVertices = new List<Vector3>();
|
|
|
|
for (var t = 0; t < triangles.Length; t++)
|
|
{
|
|
var v1 = vertices[triangles[t].X];
|
|
var v2 = vertices[triangles[t].Y];
|
|
var v3 = vertices[triangles[t].Z];
|
|
|
|
// Calculate midpoints (linear interpolation)
|
|
var a = (v1 + v2) * 0.5f;
|
|
var b = (v2 + v3) * 0.5f;
|
|
var c = (v3 + v1) * 0.5f;
|
|
|
|
// Add all vertices (optionally normalize)
|
|
var baseIndex = newVertices.Count;
|
|
newVertices.Add(spherical ? MathUtils.Lerp(v1, Vector3.Normalize(v1), strength) : v1);
|
|
newVertices.Add(spherical ? MathUtils.Lerp(a, Vector3.Normalize(a), strength) : a);
|
|
newVertices.Add(spherical ? MathUtils.Lerp(c, Vector3.Normalize(c), strength) : c);
|
|
|
|
newVertices.Add(spherical ? MathUtils.Lerp(v2, Vector3.Normalize(v2), strength) : v2);
|
|
newVertices.Add(spherical ? MathUtils.Lerp(b, Vector3.Normalize(b), strength) : b);
|
|
newVertices.Add(spherical ? MathUtils.Lerp(a, Vector3.Normalize(a), strength) : a);
|
|
|
|
newVertices.Add(spherical ? MathUtils.Lerp(v3, Vector3.Normalize(v3), strength) : v3);
|
|
newVertices.Add(spherical ? MathUtils.Lerp(c, Vector3.Normalize(c), strength) : c);
|
|
newVertices.Add(spherical ? MathUtils.Lerp(b, Vector3.Normalize(b), strength) : b);
|
|
|
|
newVertices.Add(spherical ? MathUtils.Lerp(a, Vector3.Normalize(a), strength) : a);
|
|
newVertices.Add(spherical ? MathUtils.Lerp(b, Vector3.Normalize(b), strength) : b);
|
|
newVertices.Add(spherical ? MathUtils.Lerp(c, Vector3.Normalize(c), strength) : c);
|
|
|
|
// Add new triangles (same as before)
|
|
newTriangles.Add(new Int3(baseIndex + 0, baseIndex + 1, baseIndex + 2));
|
|
newTriangles.Add(new Int3(baseIndex + 3, baseIndex + 4, baseIndex + 5));
|
|
newTriangles.Add(new Int3(baseIndex + 6, baseIndex + 7, baseIndex + 8));
|
|
newTriangles.Add(new Int3(baseIndex + 9, baseIndex + 10, baseIndex + 11));
|
|
}
|
|
|
|
triangles = newTriangles.ToArray();
|
|
vertices = newVertices.ToArray();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private IUvMapper GetUvMapper(int uvMapMode, int level)
|
|
{
|
|
return uvMapMode switch
|
|
{
|
|
0 => new Faces(), // Standard
|
|
1 => new Unwrapped(), // Unwrapped
|
|
2 => new Atlas(level),
|
|
3 => new FacesSub(level),
|
|
4 => new GridFacesSub(level),
|
|
_ => new Faces() // Default fallback
|
|
};
|
|
}
|
|
// Interface for UV mapping strategies
|
|
private interface IUvMapper
|
|
{
|
|
Vector2 CalculateUV(Vector3 vertex, Vector3 normal, int vertexIndex, int triangleIndex);
|
|
}
|
|
|
|
private class Faces : IUvMapper
|
|
{
|
|
// UV coordinates that repeat every 3 vertices
|
|
|
|
|
|
public Vector2 CalculateUV(Vector3 vertex, Vector3 normal, int vertexIndex, int triangleIndex)
|
|
{
|
|
// The pattern repeats every 3 vertices, so we can use modulo
|
|
int uvIndex = vertexIndex % 3;
|
|
|
|
if (uvIndex >= 0 && uvIndex < _baseUvs.Length)
|
|
{
|
|
return _baseUvs[uvIndex];
|
|
}
|
|
|
|
// Fallback for unexpected cases
|
|
Log.Warning($"Invalid UV index: {uvIndex}. Using fallback UV.");
|
|
return new Vector2(0.5f, 0.5f);
|
|
}
|
|
}
|
|
|
|
private class FacesSub(int subdivisionLevel) : IUvMapper
|
|
{
|
|
// Base UV coordinates for a single triangle face
|
|
/* private static readonly Vector2[] _baseUvs = new Vector2[3]
|
|
{
|
|
new Vector2(0.5f, 1.0f), // vertex 0 (center top)
|
|
new Vector2(0.067f, 0.250f), // vertex 1 (left bottom)
|
|
new Vector2(0.933f, 0.250f) // vertex 2 (right bottom)
|
|
};*/
|
|
|
|
private int _subdivisionLevel = subdivisionLevel;
|
|
|
|
public Vector2 CalculateUV(Vector3 vertex, Vector3 normal, int vertexIndex, int triangleIndex)
|
|
{
|
|
if (_subdivisionLevel == 0)
|
|
{
|
|
// No subdivision - use base UVs
|
|
var _uvIndex = vertexIndex % 3;
|
|
return _baseUvs[_uvIndex];
|
|
}
|
|
|
|
// Calculate which original face this triangle belongs to
|
|
var subTrianglesPerFace = (int)Math.Pow(4, _subdivisionLevel);
|
|
var originalFaceIndex = triangleIndex / subTrianglesPerFace;
|
|
originalFaceIndex = originalFaceIndex % 20; // Ensure we don't exceed 20 faces
|
|
|
|
// Calculate which sub-triangle within the original face
|
|
var subTriangleIndex = triangleIndex % subTrianglesPerFace;
|
|
|
|
// Get the base UV for this vertex position in the triangle
|
|
var uvIndex = vertexIndex % 3;
|
|
var baseUV = _baseUvs[uvIndex];
|
|
|
|
// Now we need to map this to the subdivided space
|
|
// We'll use a recursive approach to find the correct sub-triangle position
|
|
// Vector2 tessellatedUV = TessellateUVFace(baseUV, subTriangleIndex, _subdivisionLevel);
|
|
return TessellateUV(baseUV, _baseUvs, subTriangleIndex, _subdivisionLevel);
|
|
//return tessellatedUV;
|
|
}
|
|
}
|
|
|
|
private class GridFacesSub(int subdivisionLevel) : IUvMapper // Look ma no llm! tbh I used Blender to get the base UVs for this
|
|
{
|
|
private readonly int _subdivisionLevel = subdivisionLevel.Clamp(0, 5);
|
|
|
|
public Vector2 CalculateUV(Vector3 vertex, Vector3 normal, int vertexIndex, int triangleIndex)
|
|
{
|
|
/* if (_subdivisionLevel == 0)
|
|
{
|
|
return GetNonSubdividedUV(triangleIndex, vertexIndex);
|
|
}*/
|
|
|
|
var subTrianglesPerFace = (int)Math.Pow(4, _subdivisionLevel);
|
|
var originalFaceIndex = triangleIndex / subTrianglesPerFace;
|
|
originalFaceIndex = originalFaceIndex % 20;
|
|
var subTriangleIndex = triangleIndex % subTrianglesPerFace;
|
|
|
|
var baseTriangleUvs = GetBaseTriangleUvs(originalFaceIndex);
|
|
var uvIndex = vertexIndex % 3;
|
|
var baseUV = baseTriangleUvs[uvIndex];
|
|
|
|
//return TessellateUVFace(baseUV, subTriangleIndex, _subdivisionLevel);
|
|
return TessellateUV(baseUV, baseTriangleUvs, subTriangleIndex, _subdivisionLevel);
|
|
}
|
|
|
|
private Vector2[] GetBaseTriangleUvs(int originalFaceIndex)
|
|
{
|
|
const float cellH = 1.0f / 5;
|
|
const float cellV = 1.0f / 2;
|
|
|
|
var groupIndex = originalFaceIndex / 5;
|
|
var faceInGroup = originalFaceIndex % 5;
|
|
var xOffset = faceInGroup * cellH;
|
|
xOffset += (0.2f - 0.181819f) * 0.5f; // Center the UVs horizontally
|
|
|
|
if (originalFaceIndex < 5) // First group (faces 0-4)
|
|
{
|
|
return
|
|
[
|
|
new Vector2(0.09091f + xOffset, 0.907461f), // Top center
|
|
new Vector2(0.0f + xOffset, 0.75f ), // Left vertex
|
|
new Vector2(0.181819f + xOffset, 0.75f), // Right vertex
|
|
|
|
];
|
|
}
|
|
else if (originalFaceIndex < 10) // Second group (faces 5-9)
|
|
{
|
|
return
|
|
[
|
|
new Vector2(0.181819f + xOffset, 0.75f), // Right vertex
|
|
new Vector2(0.0f + xOffset, 0.75f), // Left vertex
|
|
new Vector2(0.090911f + xOffset, 0.59254f ) // Bottom center
|
|
];
|
|
}
|
|
else if (originalFaceIndex < 15) // Third group (faces 10-14)
|
|
{
|
|
// Apply Y shift downward (-0.157461) and X shift (+cellHWidth/2)
|
|
return
|
|
[
|
|
new Vector2(0.09091f + xOffset, 0.907461f- cellV), // Top center
|
|
new Vector2(0.0f + xOffset, 0.75f - cellV ), // Left vertex
|
|
new Vector2(0.181819f + xOffset, 0.75f- cellV), // Right vertex
|
|
|
|
];
|
|
}
|
|
else // Fourth group (faces 15-19)
|
|
{
|
|
// Apply Y shift downward (-0.157461) and X shift (+cellHWidth/2)
|
|
return
|
|
[
|
|
new Vector2(0.181819f + xOffset, 0.75f- cellV), // Right vertex
|
|
new Vector2(0.0f + xOffset, 0.75f - cellV), // Left vertex
|
|
new Vector2(0.090911f + xOffset, 0.59254f - cellV ) // Bottom center
|
|
];
|
|
}
|
|
}
|
|
}
|
|
|
|
private class Unwrapped : IUvMapper
|
|
{
|
|
private Dictionary<(int triangleIndex, int vertexIndex), Vector2> _fixedUvs;
|
|
private HashSet<int> _flippedTriangles;
|
|
|
|
// Precomputes UVs with seam fix, must be called before CalculateUV
|
|
public void Prepare(Vector3[] vertices, Int3[] triangles)
|
|
{
|
|
_fixedUvs = new Dictionary<(int, int), Vector2>();
|
|
_flippedTriangles = new HashSet<int>();
|
|
|
|
for (var triIndex = 0; triIndex < triangles.Length; triIndex++)
|
|
{
|
|
var tri = triangles[triIndex];
|
|
var indices = new[] { tri.X, tri.Y, tri.Z };
|
|
var uvs = new Vector2[3];
|
|
|
|
// Step 1: Compute spherical UVs
|
|
for (var i = 0; i < 3; i++)
|
|
{
|
|
// Match tilt rotation
|
|
var tilt = Matrix4x4.CreateFromYawPitchRoll(
|
|
yaw: 0f,
|
|
pitch: 0f,
|
|
roll: -_icosahedronTiltAngle
|
|
);
|
|
|
|
// Rotate vertex into UV-mapping space
|
|
var v = Vector3.Transform(vertices[indices[i]], tilt);
|
|
|
|
// Then compute spherical UVs from rotated point
|
|
var u = 0.5f + MathF.Atan2(v.Z, v.X) / (2 * MathF.PI);
|
|
var vCoord = 0.5f + MathF.Asin(v.Y) / MathF.PI;
|
|
if (u < 0f) u += 1f;
|
|
if (u >= 1f) u -= 1f;
|
|
uvs[i] = new Vector2(u, vCoord);
|
|
}
|
|
|
|
// Step 2: Seam fix
|
|
var minU = MathF.Min(uvs[0].X, MathF.Min(uvs[1].X, uvs[2].X));
|
|
var maxU = MathF.Max(uvs[0].X, MathF.Max(uvs[1].X, uvs[2].X));
|
|
var wraps = (maxU - minU) > 0.5f;
|
|
for (var i = 0; i < 3; i++)
|
|
if (wraps && uvs[i].X < 0.5f)
|
|
uvs[i].X += 1f;
|
|
|
|
// Step 3: Check UV winding and flip if necessary
|
|
var uvA = new Vector3(uvs[0], 0);
|
|
var uvB = new Vector3(uvs[1], 0);
|
|
var uvC = new Vector3(uvs[2], 0);
|
|
var uvNormal = Vector3.Cross(uvB - uvA, uvC - uvA);
|
|
var flipped = uvNormal.Z < 0;
|
|
|
|
if (flipped)
|
|
{
|
|
// Flip UVs
|
|
(uvs[1], uvs[2]) = (uvs[2], uvs[1]);
|
|
_flippedTriangles.Add(triIndex);
|
|
}
|
|
|
|
// Store fixed UVs with vertex mapping order preserved (adjusted if flipped)
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
int fixedIndex = flipped ? (i == 1 ? 2 : i == 2 ? 1 : 0) : i;
|
|
_fixedUvs[(triIndex, i)] = uvs[fixedIndex];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public Vector2 CalculateUV(Vector3 vertex, Vector3 normal, int vertexIndex, int triangleIndex)
|
|
{
|
|
if (_fixedUvs.TryGetValue((triangleIndex, vertexIndex), out var uv))
|
|
return uv * new Vector2(-1f, 1f) + new Vector2(1f, 0f);
|
|
|
|
return new Vector2(0.5f, 0.5f); // fallback
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
private class Atlas(int subdivisionLevel) : IUvMapper
|
|
{
|
|
private readonly int _subdivisionLevel = subdivisionLevel.Clamp(0, 5);
|
|
private const float currentMaxY = 0.472382f;
|
|
|
|
public Vector2 CalculateUV(Vector3 vertex, Vector3 normal, int vertexIndex, int triangleIndex)
|
|
{
|
|
/* if (_subdivisionLevel == 0)
|
|
{
|
|
return GetNonSubdividedUV(triangleIndex, vertexIndex);
|
|
}*/
|
|
|
|
var subTrianglesPerFace = (int)Math.Pow(4, _subdivisionLevel);
|
|
var originalFaceIndex = triangleIndex / subTrianglesPerFace;
|
|
originalFaceIndex = originalFaceIndex % 20;
|
|
var subTriangleIndex = triangleIndex % subTrianglesPerFace;
|
|
|
|
var baseTriangleUvs = GetBaseTriangleUvs(originalFaceIndex);
|
|
var uvIndex = vertexIndex % 3;
|
|
var baseUV = baseTriangleUvs[uvIndex];
|
|
|
|
//return TessellateUVFace(baseUV, subTriangleIndex, _subdivisionLevel);
|
|
return TessellateUV(baseUV, baseTriangleUvs, subTriangleIndex, _subdivisionLevel);
|
|
}
|
|
|
|
private static Vector2[] GetBaseTriangleUvs(int originalFaceIndex)
|
|
{
|
|
const float cellWidth = 0.909091f / 5;
|
|
const float yShift = 0.157461f;
|
|
var groupIndex = originalFaceIndex / 5;
|
|
var faceInGroup = originalFaceIndex % 5;
|
|
var xOffset = faceInGroup * cellWidth;
|
|
|
|
if (originalFaceIndex < 5) // First group (faces 0-4)
|
|
{
|
|
return
|
|
[
|
|
new Vector2(0.09091f + xOffset, 1.0f), // Top vertex (0.472382 normalized)
|
|
new Vector2(0.0f + xOffset, 0.314921f / currentMaxY), // Left vertex (~0.6667)
|
|
new Vector2(0.181819f + xOffset, 0.314921f / currentMaxY) // Right vertex
|
|
];
|
|
}
|
|
else if (originalFaceIndex < 10) // Second group (faces 5-9)
|
|
{
|
|
return
|
|
[
|
|
new Vector2(0.181819f + xOffset, 0.314921f / currentMaxY), // Right vertex
|
|
new Vector2(0.0f + xOffset, 0.314921f / currentMaxY), // Left vertex
|
|
new Vector2(0.090911f + xOffset, 0.157461f / currentMaxY) // Bottom center (~0.3333)
|
|
];
|
|
}
|
|
else if (originalFaceIndex < 15) // Third group (faces 10-14)
|
|
{
|
|
// Apply Y shift downward (-0.157461) and X shift (+cellWidth/2)
|
|
return
|
|
[
|
|
new Vector2(0.090911f + xOffset + cellWidth * 0.5f, (0.157461f - yShift) / currentMaxY), // Bottom center (~0.0)
|
|
new Vector2(0.181819f + xOffset + cellWidth * 0.5f, (0.314921f - yShift) / currentMaxY), // Right vertex (~0.3333)
|
|
new Vector2(0.0f + xOffset + cellWidth * 0.5f, (0.314921f - yShift) / currentMaxY) // Left vertex
|
|
];
|
|
}
|
|
else // Fourth group (faces 15-19)
|
|
{
|
|
// Apply Y shift downward (-0.157461) and X shift (+cellWidth/2)
|
|
return
|
|
[
|
|
new Vector2(0.0f + xOffset + cellWidth * 0.5f, (0.314921f - yShift) / currentMaxY), // Left vertex (~0.3333)
|
|
new Vector2(0.181819f + xOffset + cellWidth * 0.5f, (0.314921f - yShift) / currentMaxY), // Right vertex
|
|
new Vector2(0.09091f + xOffset + cellWidth * 0.5f, (0.472382f - yShift) / currentMaxY) // Top center (~0.6667)
|
|
];
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Vector2 TessellateUV(Vector2 baseUV, Vector2[] baseTriangleUvs, int subTriangleIndex, int subdivisionLevel)
|
|
{
|
|
if (subdivisionLevel == 0)
|
|
return baseUV;
|
|
|
|
var currentV0 = baseTriangleUvs[0];
|
|
var currentV1 = baseTriangleUvs[1];
|
|
var currentV2 = baseTriangleUvs[2];
|
|
|
|
var currentIndex = subTriangleIndex;
|
|
for (var level = subdivisionLevel; level > 0; level--)
|
|
{
|
|
var trianglesAtThisLevel = (int)Math.Pow(4, level - 1);
|
|
var quadrant = currentIndex / trianglesAtThisLevel;
|
|
currentIndex = currentIndex % trianglesAtThisLevel;
|
|
|
|
var mid01 = (currentV0 + currentV1) * 0.5f;
|
|
var mid12 = (currentV1 + currentV2) * 0.5f;
|
|
var mid20 = (currentV2 + currentV0) * 0.5f;
|
|
|
|
switch (quadrant)
|
|
{
|
|
case 0:
|
|
currentV1 = mid01;
|
|
currentV2 = mid20;
|
|
break;
|
|
case 1:
|
|
currentV0 = currentV1;
|
|
currentV1 = mid12;
|
|
currentV2 = mid01;
|
|
break;
|
|
case 2:
|
|
currentV0 = currentV2;
|
|
currentV1 = mid20;
|
|
currentV2 = mid12;
|
|
break;
|
|
case 3:
|
|
currentV0 = mid01;
|
|
currentV1 = mid12;
|
|
currentV2 = mid20;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Determine which vertex to return based on the original baseUV
|
|
if (baseUV == baseTriangleUvs[0]) return currentV0;
|
|
if (baseUV == baseTriangleUvs[1]) return currentV1;
|
|
if (baseUV == baseTriangleUvs[2]) return currentV2;
|
|
|
|
// For midpoints, return the interpolated value
|
|
return (currentV0 + currentV1 + currentV2) / 3f;
|
|
}
|
|
|
|
private Buffer _vertexBuffer;
|
|
private PbrVertex[] _vertexBufferData = new PbrVertex[0];
|
|
private readonly BufferWithViews _vertexBufferWithViews = new();
|
|
|
|
private Buffer _indexBuffer;
|
|
private Int3[] _indexBufferData = new Int3[0];
|
|
private readonly BufferWithViews _indexBufferWithViews = new();
|
|
|
|
private readonly MeshBuffers _data = new();
|
|
private static readonly float phi = (1f + MathF.Sqrt(5f)) / 2f; // Golden ratio, used in icosahedron generation
|
|
|
|
private static readonly float _icosahedronTiltAngle = MathF.Atan(2f / (2f * phi)); // Pre-calculate the tilt angle
|
|
|
|
// Base UV coordinates for a single triangle face
|
|
private static readonly Vector2[] _baseUvs =
|
|
[
|
|
new Vector2(0.5f, 1.0f), // vertex 0 (center top)
|
|
new Vector2(0.067f, 0.250f), // vertex 11 (left bottom)
|
|
new Vector2(0.933f, 0.250f) // vertex 5 (right bottom)
|
|
];
|
|
|
|
private enum UvModes
|
|
{
|
|
Faces,
|
|
Unwrapped,
|
|
Atlas,
|
|
FacesSub,
|
|
GridFacesSub,
|
|
}
|
|
|
|
private enum ShadingModes
|
|
{
|
|
Flat,
|
|
Smoothed,
|
|
}
|
|
|
|
[Input(Guid = "2e8c23d8-01ac-4f53-b628-91d9ab094278")]
|
|
public readonly InputSlot<int> Subdivisions = new();
|
|
|
|
[Input(Guid = "32a77592-eaa1-43e8-b1ab-74b989ecbccd")]
|
|
public readonly InputSlot<bool> Spherical = new();
|
|
|
|
[Input(Guid = "63866397-F64E-486A-8C6D-862FFD3ED42E")]
|
|
public readonly InputSlot<float> Strength = new();
|
|
|
|
[Input(Guid = "e062431e-0741-446d-ace9-e7e91080ed9f")]
|
|
public readonly InputSlot<Vector2> Stretch = new();
|
|
|
|
[Input(Guid = "bba90ae7-689f-41d3-8a48-4f1cdb42adab")]
|
|
public readonly InputSlot<float> Scale = new();
|
|
|
|
[Input(Guid = "486c1717-20cf-4cf9-951e-cedd51c88262")]
|
|
public readonly InputSlot<Vector3> Pivot = new();
|
|
|
|
[Input(Guid = "bbeccca7-9e1c-4702-bbd4-1cf0c9409354")]
|
|
public readonly InputSlot<Vector3> Center = new();
|
|
|
|
[Input(Guid = "96D161DA-F459-427C-BE67-E8F1B47D233D")]
|
|
public readonly InputSlot<Vector3> Rotation = new();
|
|
|
|
[Input(Guid = "FFD87531-8B82-4F31-9AA9-8459F92A4798", MappedType = typeof(UvModes))]
|
|
public readonly InputSlot<int> TexCoord = new();
|
|
|
|
[Input(Guid = "08dd88b7-cd91-4f17-91d9-08de5b260e7a", MappedType = typeof(UvModes))]
|
|
public readonly InputSlot<int> TexCoord2 = new();
|
|
|
|
[Input(Guid = "7438A4CA-1FA7-48CF-AD85-0E7067AE54CC", MappedType = typeof(ShadingModes))]
|
|
public readonly InputSlot<int> Shading = new();
|
|
} |