660 lines
19 KiB
C#
660 lines
19 KiB
C#
using Godot;
|
|
using KeepersCompound.LGS;
|
|
using KeepersCompound.LGS.Database;
|
|
using KeepersCompound.LGS.Database.Chunks;
|
|
using KeepersCompound.TMV.UI;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
|
|
namespace KeepersCompound.TMV;
|
|
|
|
public partial class Mission : Node3D
|
|
{
|
|
private readonly struct LightmapRectData
|
|
{
|
|
public readonly int cellIndex;
|
|
public readonly int lightmapIndex;
|
|
public readonly int textureId;
|
|
public readonly int uvStart;
|
|
public readonly int uvEnd;
|
|
|
|
public LightmapRectData(int cellIndex, int lightmapIndex, int textureId, int uvStart, int uvEnd)
|
|
{
|
|
this.cellIndex = cellIndex;
|
|
this.lightmapIndex = lightmapIndex;
|
|
this.textureId = textureId;
|
|
this.uvStart = uvStart;
|
|
this.uvEnd = uvEnd;
|
|
}
|
|
}
|
|
|
|
private const string OBJECT_MODELS_GROUP = "ObjectModels";
|
|
|
|
[Export(PropertyHint.GlobalFile, "*.mis")]
|
|
public string FileName { get; set; }
|
|
[Export]
|
|
public bool Build = false;
|
|
[Export]
|
|
public bool Clear = false;
|
|
[Export]
|
|
public bool Dump = false;
|
|
public int LightmapLayers = 33;
|
|
|
|
string _missionName;
|
|
DbFile _file;
|
|
TextureLoader _textureLoader;
|
|
List<ShaderMaterial> _materials;
|
|
Vector2I _lmLayerMask;
|
|
|
|
public override void _Ready()
|
|
{
|
|
_materials = new List<ShaderMaterial>();
|
|
_lmLayerMask = new Vector2I(~0, ~0);
|
|
|
|
var lightmapToggler = GetNode<Control>("%LightmapToggler") as LightmapLayerToggler;
|
|
lightmapToggler.Setup(this);
|
|
|
|
var resourceSelector = GetNode<Control>("%ResourceSelector") as ResourceSelector;
|
|
resourceSelector.ResourceSelected += (string campaign, string mission) =>
|
|
{
|
|
_missionName = mission;
|
|
|
|
var context = Context.Instance;
|
|
context.SetCampaign(campaign);
|
|
FileName = context.CampaignResources.GetResourcePath(ResourceType.Mission, mission);
|
|
Build = true;
|
|
};
|
|
}
|
|
|
|
public override void _Process(double delta)
|
|
{
|
|
if (Build)
|
|
{
|
|
Timing.Reset();
|
|
Timing.TimeStage("Build", () => RebuildMap());
|
|
Timing.LogAll();
|
|
Build = false;
|
|
}
|
|
if (Clear)
|
|
{
|
|
ClearMap();
|
|
Clear = false;
|
|
}
|
|
}
|
|
|
|
public override void _ShortcutInput(InputEvent @event)
|
|
{
|
|
if (@event is InputEventKey keyEvent && keyEvent.Pressed)
|
|
{
|
|
if (keyEvent.Keycode == Key.R)
|
|
{
|
|
Build = true;
|
|
}
|
|
if (keyEvent.Keycode == Key.L)
|
|
{
|
|
ToggleLightmap();
|
|
}
|
|
if (keyEvent.Keycode == Key.O)
|
|
{
|
|
ToggleObjectRendering();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ClearMap()
|
|
{
|
|
foreach (var node in GetChildren())
|
|
{
|
|
node.QueueFree();
|
|
}
|
|
|
|
_materials.Clear();
|
|
}
|
|
|
|
public void RebuildMap()
|
|
{
|
|
ClearMap();
|
|
|
|
_textureLoader = new TextureLoader();
|
|
Timing.TimeStage("DbFile Parse", () => _file = new(FileName));
|
|
Timing.TimeStage("Register Textures", () => UseChunk<TxList>("TXLIST", RegisterTextures));
|
|
Timing.TimeStage("Build WR", () => UseChunk<WorldRep>("WREXT", BuildWrMeshes));
|
|
|
|
if (_file.Chunks.TryGetValue("BRLIST", out var brList))
|
|
{
|
|
var objHierarchy = Timing.TimeStage("Hierarchy", BuildHierarchy);
|
|
Timing.TimeStage("Object Placement", () => PlaceObjects((BrList)brList, objHierarchy));
|
|
}
|
|
}
|
|
|
|
public void ToggleObjectRendering()
|
|
{
|
|
// It might be "better" to use a parent node and just toggle that, but
|
|
// the performance of this is completely fine so we'll stick with it
|
|
foreach (var node in GetTree().GetNodesInGroup(OBJECT_MODELS_GROUP))
|
|
{
|
|
var node3d = node as Node3D;
|
|
node3d.Visible = !node3d.Visible;
|
|
}
|
|
}
|
|
|
|
public void ToggleLightmap()
|
|
{
|
|
if (_lmLayerMask == Vector2I.Zero)
|
|
{
|
|
_lmLayerMask = new Vector2I(~0, ~0);
|
|
}
|
|
else
|
|
{
|
|
_lmLayerMask = Vector2I.Zero;
|
|
}
|
|
|
|
foreach (var mat in _materials)
|
|
{
|
|
mat.SetShaderParameter("lightmap_bitmask", _lmLayerMask);
|
|
}
|
|
}
|
|
|
|
public void ToggleLmLayer(uint layer)
|
|
{
|
|
if (layer >= 64)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(layer));
|
|
}
|
|
|
|
static int ToggleBit(int bitIdx, int val)
|
|
{
|
|
var mask = 1 << bitIdx;
|
|
var isEnabled = (val & mask) != 0;
|
|
if (isEnabled)
|
|
{
|
|
val &= ~mask;
|
|
}
|
|
else
|
|
{
|
|
val |= mask;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
if (layer < 32)
|
|
{
|
|
_lmLayerMask.X = ToggleBit((int)layer, _lmLayerMask.X);
|
|
}
|
|
else
|
|
{
|
|
_lmLayerMask.Y = ToggleBit((int)layer - 32, _lmLayerMask.Y);
|
|
}
|
|
|
|
foreach (var mat in _materials)
|
|
{
|
|
mat.SetShaderParameter("lightmap_bitmask", _lmLayerMask);
|
|
}
|
|
}
|
|
|
|
// TODO: Make this less of a mess
|
|
private ObjectHierarchy BuildHierarchy()
|
|
{
|
|
ObjectHierarchy objHierarchy;
|
|
if (_file.Chunks.TryGetValue("GAM_FILE", out var gamFileChunk))
|
|
{
|
|
|
|
var options = new EnumerationOptions { MatchCasing = MatchCasing.CaseInsensitive };
|
|
var name = ((GamFile)gamFileChunk).fileName;
|
|
var paths = Directory.GetFiles(FileName.GetBaseDir(), name, options);
|
|
if (!paths.IsEmpty())
|
|
{
|
|
objHierarchy = new ObjectHierarchy(_file, new DbFile(paths[0]));
|
|
}
|
|
else
|
|
{
|
|
objHierarchy = new ObjectHierarchy(_file);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
objHierarchy = new ObjectHierarchy(_file);
|
|
}
|
|
return objHierarchy;
|
|
}
|
|
|
|
private void UseChunk<T>(string name, Action<T> action)
|
|
{
|
|
if (_file.Chunks.TryGetValue(name, out var value))
|
|
{
|
|
action((T)value);
|
|
}
|
|
else
|
|
{
|
|
GD.Print($"No chunk found/loaded: {name}");
|
|
}
|
|
}
|
|
|
|
private void PlaceObjects(BrList brList, ObjectHierarchy objHierarchy)
|
|
{
|
|
foreach (var brush in brList.Brushes)
|
|
{
|
|
if (brush.media != BrList.Brush.Media.Object)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var id = (int)brush.brushInfo;
|
|
var modelNameProp = objHierarchy.GetProperty<PropLabel>(id, "P$ModelName");
|
|
var scaleProp = objHierarchy.GetProperty<PropVector>(id, "P$Scale");
|
|
var renderTypeProp = objHierarchy.GetProperty<PropRenderType>(id, "P$RenderTyp");
|
|
var jointPosProp = objHierarchy.GetProperty<PropJointPos>(id, "P$JointPos");
|
|
var txtRepl0 = objHierarchy.GetProperty<PropString>(id, "P$OTxtRepr0");
|
|
var txtRepl1 = objHierarchy.GetProperty<PropString>(id, "P$OTxtRepr1");
|
|
var txtRepl2 = objHierarchy.GetProperty<PropString>(id, "P$OTxtRepr2");
|
|
var txtRepl3 = objHierarchy.GetProperty<PropString>(id, "P$OTxtRepr3");
|
|
var renderAlpha = objHierarchy.GetProperty<PropFloat>(id, "P$RenderAlp");
|
|
var renderMode = renderTypeProp == null ? PropRenderType.Mode.Normal : renderTypeProp.mode;
|
|
|
|
if (modelNameProp == null || renderMode == PropRenderType.Mode.NotRendered)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Let's try and place an object :)
|
|
var modelName = modelNameProp.value + ".bin";
|
|
var pos = brush.position.ToGodotVec3();
|
|
var rot = brush.angle.ToGodotVec3(false);
|
|
var scale = scaleProp == null ? Vector3.One : scaleProp.value.ToGodotVec3(false);
|
|
var meshDetails = Timing.TimeStage("Get Models", () => Context.Instance.ModelLoader.Load(modelName));
|
|
if (meshDetails.Length != 0)
|
|
{
|
|
var model = new Node3D();
|
|
model.Position = pos;
|
|
model.RotationDegrees = rot;
|
|
model.Scale = scale;
|
|
|
|
var joints = jointPosProp != null ? jointPosProp.Positions : [0, 0, 0, 0, 0, 0];
|
|
var meshes = ModelLoader.TransformMeshes(joints, meshDetails);
|
|
|
|
bool GetTextReplPath(PropString prop, out string path)
|
|
{
|
|
path = "";
|
|
if (prop == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
path = prop.value;
|
|
|
|
var campaignResources = Context.Instance.CampaignResources;
|
|
if (path.StartsWith("fam", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var resType = ResourceType.Texture;
|
|
path = campaignResources.GetResourcePath(resType, prop.value);
|
|
}
|
|
else
|
|
{
|
|
var resType = ResourceType.ObjectTexture;
|
|
var convertedValue = ResourcePathManager.ConvertSeparator(prop.value);
|
|
var resName = Path.GetFileNameWithoutExtension(convertedValue);
|
|
path = campaignResources.GetResourcePath(resType, resName);
|
|
}
|
|
|
|
return path != null;
|
|
}
|
|
|
|
var repls = new PropString[] { txtRepl0, txtRepl1, txtRepl2, txtRepl3 };
|
|
foreach (var meshInstance in meshes)
|
|
{
|
|
for (var i = 0; i < 4; i++)
|
|
{
|
|
if (GetTextReplPath(repls[i], out var path))
|
|
{
|
|
var overrideMat = new StandardMaterial3D
|
|
{
|
|
AlbedoTexture = TextureLoader.LoadTexture(path),
|
|
Transparency = BaseMaterial3D.TransparencyEnum.AlphaDepthPrePass,
|
|
};
|
|
|
|
var surfaceCount = meshInstance.Mesh.GetSurfaceCount();
|
|
for (var idx = 0; idx < surfaceCount; idx++)
|
|
{
|
|
var surfaceMat = meshInstance.Mesh.SurfaceGetMaterial(idx);
|
|
if (surfaceMat.HasMeta($"TxtRepl{i}"))
|
|
{
|
|
meshInstance.SetSurfaceOverrideMaterial(idx, overrideMat);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (renderAlpha != null)
|
|
{
|
|
meshInstance.Transparency = 1.0f - renderAlpha.value;
|
|
}
|
|
|
|
model.AddChild(meshInstance);
|
|
}
|
|
|
|
model.AddToGroup(OBJECT_MODELS_GROUP);
|
|
|
|
AddChild(model);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void BuildWrMeshes(WorldRep worldRep)
|
|
{
|
|
var cells = worldRep.Cells;
|
|
var lmHdr = worldRep.DataHeader.LightmapFormat == 2;
|
|
GD.Print($"HDR Lightmap: {lmHdr}");
|
|
|
|
var packingRects = new List<RectPacker.Rect>();
|
|
var surfaceDataMap = new Dictionary<int, MeshSurfaceData>();
|
|
var rectDataMap = new Dictionary<int, LightmapRectData>();
|
|
|
|
for (var cellIdx = 0; cellIdx < cells.Length; cellIdx++)
|
|
{
|
|
var cell = cells[cellIdx];
|
|
var numPolys = cell.PolyCount;
|
|
var numRenderPolys = cell.RenderPolyCount;
|
|
var numPortalPolys = cell.PortalPolyCount;
|
|
|
|
// There's nothing to render
|
|
if (numRenderPolys == 0 || numPortalPolys >= numPolys)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// You'd think these would be the same number, but apparently not
|
|
// I think it's because water counts as a render poly and a portal poly
|
|
var maxPolyIdx = Math.Min(numRenderPolys, numPolys - numPortalPolys);
|
|
var cellIdxOffset = 0;
|
|
for (int polyIdx = 0; polyIdx < maxPolyIdx; polyIdx++)
|
|
{
|
|
var lightmapRectData = ProcessCellSurfaceData(surfaceDataMap, worldRep, cellIdx, polyIdx, cellIdxOffset);
|
|
rectDataMap.Add(packingRects.Count, lightmapRectData);
|
|
|
|
var light = cell.LightList[polyIdx];
|
|
var rect = new RectPacker.Rect
|
|
{
|
|
Width = light.Width,
|
|
Height = light.Height,
|
|
Id = packingRects.Count,
|
|
};
|
|
packingRects.Add(rect);
|
|
|
|
cellIdxOffset += cell.Polys[polyIdx].VertexCount;
|
|
}
|
|
}
|
|
|
|
var lightmapTexture = Timing.TimeStage("Build Lightmap", () =>
|
|
{
|
|
return BuildLightmapTexture(cells, packingRects.ToArray(), rectDataMap, surfaceDataMap);
|
|
});
|
|
|
|
foreach (var (textureId, surface) in surfaceDataMap)
|
|
{
|
|
if (surface.Empty)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var albedoTexture = _textureLoader.Get(textureId);
|
|
var mat = BuildMaterial(albedoTexture, lightmapTexture, lmHdr, _lmLayerMask);
|
|
_materials.Add(mat);
|
|
|
|
var mesh = new ArrayMesh();
|
|
mesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, surface.BuildSurfaceArray());
|
|
mesh.SurfaceSetMaterial(0, mat);
|
|
|
|
var meshInstance = new MeshInstance3D { Mesh = mesh };
|
|
AddChild(meshInstance);
|
|
}
|
|
}
|
|
|
|
private LightmapRectData ProcessCellSurfaceData(Dictionary<int, MeshSurfaceData> surfaceDataMap, WorldRep worldRep, int cellIdx, int polyIdx, int indicesOffset)
|
|
{
|
|
var cell = worldRep.Cells[cellIdx];
|
|
var poly = cell.Polys[polyIdx];
|
|
var normal = cell.Planes[poly.PlaneId].Normal.ToGodotVec3();
|
|
var vertices = new List<Vector3>();
|
|
var textureUvs = new List<Vector2>();
|
|
var lightmapUvs = new List<Vector2>();
|
|
|
|
var numPolyVertices = poly.VertexCount;
|
|
for (var j = 0; j < numPolyVertices; j++)
|
|
{
|
|
var vertex = cell.Vertices[cell.Indices[indicesOffset + j]];
|
|
vertices.Add(vertex.ToGodotVec3());
|
|
}
|
|
|
|
var renderPoly = cell.RenderPolys[polyIdx];
|
|
var light = cell.LightList[polyIdx];
|
|
var lightmapScale = worldRep.DataHeader.LightmapScaleMultiplier();
|
|
var textureId = CalcBaseUV(cell, poly, renderPoly, light, textureUvs, lightmapUvs, lightmapScale, indicesOffset);
|
|
|
|
if (!surfaceDataMap.ContainsKey(textureId))
|
|
{
|
|
surfaceDataMap.Add(textureId, new MeshSurfaceData());
|
|
}
|
|
var surfaceData = surfaceDataMap[textureId];
|
|
var (start, end) = surfaceData.AddPolygon(vertices, normal, textureUvs, lightmapUvs);
|
|
|
|
if (polyIdx >= cell.Lightmaps.Length) GD.Print("HUH");
|
|
|
|
return new LightmapRectData(cellIdx, polyIdx, textureId, start, end);
|
|
}
|
|
|
|
private static Texture2DArray BuildLightmapTexture(
|
|
WorldRep.Cell[] cells,
|
|
RectPacker.Rect[] packingRects,
|
|
Dictionary<int, LightmapRectData> rectDataMap,
|
|
Dictionary<int, MeshSurfaceData> surfaceDataMap)
|
|
{
|
|
var bounds = Timing.TimeStage("RectPack", () =>
|
|
{
|
|
return RectPacker.Pack(packingRects);
|
|
});
|
|
GD.Print($"Packed {packingRects.Length} rects in ({bounds.Width}, {bounds.Height})");
|
|
|
|
var lightmapFormat = Image.Format.Rgba8;
|
|
var lmLayerCount = 33; // TODO: Use LightmapLayers
|
|
var lmImages = new Godot.Collections.Array<Image>();
|
|
lmImages.Resize(lmLayerCount);
|
|
for (var i = 0; i < lmLayerCount; i++)
|
|
{
|
|
lmImages[i] = Image.CreateEmpty(bounds.Width, bounds.Height, false, lightmapFormat);
|
|
}
|
|
|
|
foreach (var rect in packingRects)
|
|
{
|
|
if (!rectDataMap.ContainsKey(rect.Id)) GD.Print("Invalid rectDataMap key");
|
|
var info = rectDataMap[rect.Id];
|
|
|
|
if (info.cellIndex >= cells.Length) GD.Print($"CellIndex too big: {info.cellIndex}/{cells.Length}");
|
|
if (info.lightmapIndex >= cells[info.cellIndex].Lightmaps.Length) GD.Print($"LightmapIndex too big: {info.lightmapIndex}/{cells[info.cellIndex].Lightmaps.Length}");
|
|
|
|
var lightmap = cells[info.cellIndex].Lightmaps[info.lightmapIndex];
|
|
var width = lightmap.Width;
|
|
var height = lightmap.Height;
|
|
var layerCount = lightmap.Layers;
|
|
var srcRect = new Rect2I(0, 0, width, height);
|
|
var dst = new Vector2I(rect.X, rect.Y);
|
|
Timing.TimeStage("Blit LM Data", () =>
|
|
{
|
|
for (var i = 0; i < layerCount; i++)
|
|
{
|
|
var bytes = Timing.TimeStage("Get LM Data", () => { return lightmap.AsBytesRgba(i); });
|
|
var cellLm = Image.CreateFromData(width, height, false, lightmapFormat, bytes);
|
|
lmImages[i].BlitRect(cellLm, srcRect, dst);
|
|
}
|
|
});
|
|
|
|
Timing.TimeStage("Transform LM UVs", () =>
|
|
{
|
|
if (!surfaceDataMap.ContainsKey(info.textureId)) GD.Print("Invalid SurfaceDataMap key");
|
|
surfaceDataMap[info.textureId].TransformUv2s(info.uvStart, info.uvEnd, (uv) =>
|
|
{
|
|
var u = uv.X;
|
|
var v = uv.Y;
|
|
|
|
// Clamp uv range to [0..1]
|
|
u %= 1;
|
|
v %= 1;
|
|
if (u < 0) u = Math.Abs(u);
|
|
if (v < 0) v = Math.Abs(v);
|
|
|
|
// Transform!
|
|
u = (rect.X + rect.Width * u) / bounds.Width;
|
|
v = (rect.Y + rect.Height * v) / bounds.Height;
|
|
return new Vector2(u, v);
|
|
});
|
|
});
|
|
}
|
|
|
|
for (var i = 0; i < lmLayerCount; i++)
|
|
{
|
|
lmImages[i].GenerateMipmaps();
|
|
}
|
|
|
|
var lightmapTexture = new Texture2DArray();
|
|
lightmapTexture.CreateFromImages(lmImages);
|
|
return lightmapTexture;
|
|
}
|
|
|
|
private int CalcBaseUV(
|
|
WorldRep.Cell cell,
|
|
WorldRep.Cell.Poly poly,
|
|
WorldRep.Cell.RenderPoly renderPoly,
|
|
WorldRep.Cell.LightmapInfo light,
|
|
List<Vector2> textureUvs,
|
|
List<Vector2> lightmapUvs,
|
|
float lightmapScale,
|
|
int cellIdxOffset)
|
|
{
|
|
// TODO: This is slightly hardcoded for ND. Check other stuff at some point. Should be handled in LG side imo
|
|
// TODO: This is a mess lol
|
|
var textureId = renderPoly.TextureId;
|
|
|
|
var texture = Timing.TimeStage("Load Textures", () => { return _textureLoader.Get(textureId); });
|
|
var texU = renderPoly.TextureVectors.Item1.ToGodotVec3();
|
|
var texV = renderPoly.TextureVectors.Item2.ToGodotVec3();
|
|
var baseU = renderPoly.TextureBases.Item1;
|
|
var baseV = renderPoly.TextureBases.Item2;
|
|
|
|
var txUScale = 64.0f / lightmapScale / texture.GetWidth();
|
|
var txVScale = 64.0f / lightmapScale / texture.GetHeight();
|
|
var lmUScale = 4.0f / light.Width;
|
|
var lmVScale = 4.0f / light.Height;
|
|
|
|
var txUBase = baseU * txUScale;
|
|
var txVBase = baseV * txVScale;
|
|
var lmUBase = lmUScale * (baseU + (0.5f - light.Bases.Item1) / 4.0f);
|
|
var lmVBase = lmVScale * (baseV + (0.5f - light.Bases.Item2) / 4.0f);
|
|
|
|
var uu = texU.Dot(texU);
|
|
var vv = texV.Dot(texV);
|
|
var uv = texU.Dot(texV);
|
|
var anchor = cell.Vertices[cell.Indices[cellIdxOffset + 0]].ToGodotVec3(); // TODO: This probably shouldn't be hardcoded idx 0
|
|
if (uv == 0.0)
|
|
{
|
|
var txUVec = texU * txUScale / uu;
|
|
var txVVec = texV * txVScale / vv;
|
|
var lmUVec = texU * lmUScale / uu;
|
|
var lmVVec = texV * lmVScale / vv;
|
|
for (var i = 0; i < poly.VertexCount; i++)
|
|
{
|
|
var v = cell.Vertices[cell.Indices[cellIdxOffset + i]].ToGodotVec3();
|
|
var delta = new Vector3(v.X - anchor.X, v.Y - anchor.Y, v.Z - anchor.Z);
|
|
var txUV = new Vector2(delta.Dot(txUVec) + txUBase, delta.Dot(txVVec) + txVBase);
|
|
var lmUV = new Vector2(delta.Dot(lmUVec) + lmUBase, delta.Dot(lmVVec) + lmVBase);
|
|
textureUvs.Add(txUV);
|
|
lightmapUvs.Add(lmUV);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var denom = 1.0f / (uu * vv - uv * uv);
|
|
|
|
var txUu = uu * txVScale * denom;
|
|
var txVv = vv * txUScale * denom;
|
|
var txUvu = txUScale * denom * uv;
|
|
var txUvv = txVScale * denom * uv;
|
|
var lmUu = uu * lmVScale * denom;
|
|
var lmVv = vv * lmUScale * denom;
|
|
var lmUvu = lmUScale * denom * uv;
|
|
var lmUvv = lmVScale * denom * uv;
|
|
for (var i = 0; i < poly.VertexCount; i++)
|
|
{
|
|
var v = cell.Vertices[cell.Indices[cellIdxOffset + i]].ToGodotVec3();
|
|
var delta = new Vector3(v.X - anchor.X, v.Y - anchor.Y, v.Z - anchor.Z);
|
|
var du = delta.Dot(texU);
|
|
var dv = delta.Dot(texV);
|
|
|
|
var txUV = new Vector2(txUBase + txVv * du - txUvu * dv, txVBase + txUu * dv - txUvv * du);
|
|
var lmUV = new Vector2(lmUBase + lmVv * du - lmUvu * dv, lmVBase + lmUu * dv - lmUvv * du);
|
|
textureUvs.Add(txUV);
|
|
lightmapUvs.Add(lmUV);
|
|
}
|
|
}
|
|
|
|
return textureId;
|
|
}
|
|
|
|
private void RegisterTextures(TxList textureList)
|
|
{
|
|
// TODO: Use PathJoin
|
|
var count = textureList.ItemCount;
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
var item = textureList.Items[i];
|
|
var path = "";
|
|
for (var j = 0; j < item.Tokens.Length; j++)
|
|
{
|
|
var token = item.Tokens[j];
|
|
if (token == 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
path += $"{textureList.Tokens[token - 1]}/";
|
|
}
|
|
path += item.Name;
|
|
|
|
if (!_textureLoader.Register(i, path))
|
|
{
|
|
GD.Print($"Failed to register texture: {path}");
|
|
}
|
|
}
|
|
|
|
if (Dump) DumpTextureList(textureList);
|
|
}
|
|
|
|
private static void DumpTextureList(TxList textureList)
|
|
{
|
|
GD.Print($"TXLIST:\n BlockSize: {textureList.BlockSize}\n ItemCount: {textureList.ItemCount}\n TokenCount: {textureList.TokenCount}\n Tokens:");
|
|
for (var i = 0; i < textureList.TokenCount; i++)
|
|
{
|
|
GD.Print($" {i}: {textureList.Tokens[i]}");
|
|
}
|
|
GD.Print($" Items:");
|
|
for (var i = 0; i < textureList.ItemCount; i++)
|
|
{
|
|
var item = textureList.Items[i];
|
|
GD.Print($" {i}:\n Tokens: [{item.Tokens[0]}, {item.Tokens[1]}, {item.Tokens[2]}, {item.Tokens[3]}]\n Name: {item.Name}");
|
|
}
|
|
}
|
|
|
|
const string MATERIAL_PATH = "res://project/materials/base.tres";
|
|
private static ShaderMaterial BuildMaterial(
|
|
Texture2D albedoTexture,
|
|
Texture2DArray lightmapTexture,
|
|
bool lmHdr,
|
|
Vector2I layerMask)
|
|
{
|
|
var material = ResourceLoader.Load<ShaderMaterial>(MATERIAL_PATH).Duplicate() as ShaderMaterial;
|
|
material.SetShaderParameter("texture_albedo", albedoTexture);
|
|
material.SetShaderParameter("lightmap_albedo", lightmapTexture);
|
|
material.SetShaderParameter("lightmap_2x", lmHdr);
|
|
material.SetShaderParameter("lightmap_bitmask", layerMask);
|
|
return material;
|
|
}
|
|
} |