ZeroDream/CodeWalker
2
0
Fork 0
mirror of https://mirror.ghproxy.com/https://github.com/dexyfex/CodeWalker synced 2024-11-29 18:32:55 +08:00
Code Issues Packages Projects Releases Wiki Activity
40f1d81318
CodeWalker/Project/Panels/GenerateLODLightsPanel.cs

544 lines
23 KiB
C#
Raw Normal View History

Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
using CodeWalker.GameFiles;
using SharpDX;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace CodeWalker.Project.Panels
{
public partial class GenerateLODLightsPanel : ProjectPanel
{
public ProjectForm ProjectForm { get; set; }
public ProjectFile CurrentProjectFile { get; set; }
public GenerateLODLightsPanel(ProjectForm projectForm)
{
ProjectForm = projectForm;
InitializeComponent();
if (ProjectForm?.WorldForm == null)
{
//could happen in some other startup mode - world form is required for this..
GenerateButton.Enabled = false;
UpdateStatus("Unable to generate - World View not available!");
}
}
public void SetProject(ProjectFile project)
{
CurrentProjectFile = project;
}
private void GenerateComplete()
{
try
{
if (InvokeRequired)
{
Invoke(new Action(() => { GenerateComplete(); }));
}
else
{
GenerateButton.Enabled = true;
}
}
catch { }
}
private void UpdateStatus(string text)
{
try
{
if (InvokeRequired)
{
Invoke(new Action(() => { UpdateStatus(text); }));
}
else
{
StatusLabel.Text = text;
}
}
catch { }
}
private void GenerateButton_Click(object sender, EventArgs e)
{
//var space = ProjectForm?.WorldForm?.Space;
//if (space == null) return;
var gameFileCache = ProjectForm?.WorldForm?.GameFileCache;
if (gameFileCache == null) return;
Generate LOD Lights now using drawable's light type
2019-01-22 10:34:21 +08:00
var path = ProjectForm.CurrentProjectFile.GetFullFilePath("lodlights") + "\\";
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
GenerateButton.Enabled = false;
List<YmapFile> projectYmaps = ProjectForm.CurrentProjectFile.YmapFiles;
var pname = NameTextBox.Text;
Task.Run(() =>
{
Generate LOD Lights making random hashes, now sorting by streetLight and hash
2019-01-26 07:24:20 +08:00
var lights = new List<Light>();
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
var eemin = new Vector3(float.MaxValue);
var eemax = new Vector3(float.MinValue);
var semin = new Vector3(float.MaxValue);
var semax = new Vector3(float.MinValue);
Trying to generate hash for LOD lights
2019-01-26 18:00:13 +08:00
//var rnd = new Random();
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
foreach (var ymap in projectYmaps)
{
Fixed bug in Generate LOD Lights when ymaps had no entities
2019-01-22 07:03:28 +08:00
if (ymap?.AllEntities == null) continue;
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
foreach (var ent in ymap.AllEntities)
{
if (ent.Archetype == null) continue;
bool waiting = false;
var dwbl = gameFileCache.TryGetDrawable(ent.Archetype, out waiting);
while (waiting)
{
dwbl = gameFileCache.TryGetDrawable(ent.Archetype, out waiting);
UpdateStatus("Waiting for " + ent.Archetype.AssetName + " to load...");
Thread.Sleep(20);
}
UpdateStatus("Adding lights from " + ent.Archetype.Name + "...");
if (dwbl != null)
{
Drawable ddwbl = dwbl as Drawable;
FragDrawable fdwbl = dwbl as FragDrawable;
LightAttributes_s[] lightAttrs = null;
if (ddwbl != null)
{
Updated ResourceBaseTypes, added Save method to YtdFile
2019-01-27 14:14:10 +08:00
lightAttrs = ddwbl.LightAttributes?.data_items;
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
}
else if (fdwbl != null)
{
Updated ResourceBaseTypes, added Save method to YtdFile
2019-01-27 14:14:10 +08:00
lightAttrs = fdwbl.OwnerFragment?.LightAttributes?.data_items;
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
}
if (lightAttrs != null)
{
eemin = Vector3.Min(eemin, ent.BBMin);
eemax = Vector3.Max(eemax, ent.BBMax);
semin = Vector3.Min(semin, ent.BBMin - ent._CEntityDef.lodDist);
semax = Vector3.Max(semax, ent.BBMax + ent._CEntityDef.lodDist);
Trying to generate hash for LOD lights
2019-01-26 18:00:13 +08:00
for (int li = 0; li<lightAttrs.Length;li++)
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
{
Trying to generate hash for LOD lights
2019-01-26 18:00:13 +08:00
var la = lightAttrs[li];
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
//transform this light with the entity position and orientation
//generate lights data from it!
Generate LOD Lights now using bone ids
2019-01-21 16:30:49 +08:00
//gotta transform the light position by the given bone! annoying
Bone bone = null;
Matrix xform = Matrix.Identity;
int boneidx = 0;
var skeleton = dwbl.Skeleton;
if (skeleton?.Bones?.Data != null)
{
for (int j = 0; j < skeleton.Bones.Data.Count; j++)
{
var tbone = skeleton.Bones.Data[j];
if (tbone.Id == la.BoneId)
{
boneidx = j;
bone = tbone;
break;
}
}
if (bone != null)
{
var modeltransforms = skeleton.Transformations;
var fragtransforms = fdwbl?.OwnerFragmentPhys?.OwnerFragPhysLod?.FragTransforms?.Data;
var fragtransformid = fdwbl?.OwnerFragmentPhys?.OwnerFragPhysIndex ?? 0;
var fragoffset = fdwbl?.OwnerFragmentPhys?.OwnerFragPhysLod.Unknown_30h ?? Vector4.Zero;
fragoffset.W = 0.0f;
Generate LOD Lights type added
2019-01-21 18:05:32 +08:00
if ((fragtransforms != null) && (fragtransformid < fragtransforms.Length))
Generate LOD Lights now using bone ids
2019-01-21 16:30:49 +08:00
{
Generate LOD Lights type added
2019-01-21 18:05:32 +08:00
xform = fragtransforms[fragtransformid];
xform.Row4 += fragoffset;
Generate LOD Lights now using bone ids
2019-01-21 16:30:49 +08:00
}
else
{
//when using the skeleton's matrices, they need to be transformed by parent
xform = modeltransforms[boneidx];
xform.Column4 = Vector4.UnitW;
//xform = Matrix.Identity;
ushort[] pinds = skeleton.ParentIndices;
ushort parentind = ((pinds != null) && (boneidx < pinds.Length)) ? pinds[boneidx] : (ushort)65535;
while (parentind < pinds.Length)
{
Matrix ptrans = (parentind < modeltransforms.Length) ? modeltransforms[parentind] : Matrix.Identity;
ptrans.Column4 = Vector4.UnitW;
xform = Matrix.Multiply(ptrans, xform);
parentind = ((pinds != null) && (parentind < pinds.Length)) ? pinds[parentind] : (ushort)65535;
}
}
}
}
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
Vector3 lpos = new Vector3(la.PositionX, la.PositionY, la.PositionZ);
Vector3 ldir = new Vector3(la.DirectionX, la.DirectionY, la.DirectionZ);
Generate LOD Lights now using bone ids
2019-01-21 16:30:49 +08:00
Vector3 bpos = xform.Multiply(lpos);
Generate LOD Lights type added
2019-01-21 18:05:32 +08:00
Vector3 bdir = xform.MultiplyRot(ldir);
Generate LOD Lights now using bone ids
2019-01-21 16:30:49 +08:00
Vector3 epos = ent.Orientation.Multiply(bpos) + ent.Position;
Generate LOD Lights type added
2019-01-21 18:05:32 +08:00
Vector3 edir = ent.Orientation.Multiply(bdir);
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
uint r = la.ColorR;
uint g = la.ColorG;
uint b = la.ColorB;
Generate LOD Lights now using bone ids
2019-01-21 16:30:49 +08:00
uint i = (byte)Math.Min(la.Intensity*4, 255);
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
uint c = (i << 24) + (r << 16) + (g << 8) + b;
Trying to generate hash for LOD lights
2019-01-26 18:00:13 +08:00
uint h = GetLightHash(ent, li);// (uint)rnd.NextLong();
if (ent._CEntityDef.guid == 91259075)
{ } //h = 2324437992? should be:19112537
if (ent._CEntityDef.guid == 889043351)
{ } //h = 422028630 ? should be:4267224866
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
Generate LOD Lights streetLight research, fix for MenyooXML import static objects
2019-01-26 06:00:38 +08:00
//any other way to know if it's a streetlight?
Trying to generate hash for LOD lights
2019-01-26 18:00:13 +08:00
//var name = ent.Archetype.Name;
var flags = la.Flags;
bool isStreetLight = (((flags >> 10) & 1u) == 1);// (name != null) && (name.Contains("street") || name.Contains("traffic"));
isStreetLight = false; //TODO: fix this!
Generate LOD Lights streetLight research, fix for MenyooXML import static objects
2019-01-26 06:00:38 +08:00
Generate LOD Lights type added
2019-01-21 18:05:32 +08:00
//@Calcium:
//1 = point
//2 = spot
//4 = capsule
Generate LOD Lights now using drawable's light type
2019-01-22 10:34:21 +08:00
uint type = la.Type;
Generate LOD Lights streetLight research, fix for MenyooXML import static objects
2019-01-26 06:00:38 +08:00
uint unk = isStreetLight ? 1u : 0;//2 bits - isStreetLight low bit, unk high bit
Trying to generate hash for LOD lights
2019-01-26 18:00:13 +08:00
uint t = la.TimeFlags | (type << 26) | (unk << 24);
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
var maxext = (byte)Math.Max(Math.Max(la.ExtentX, la.ExtentY), la.ExtentZ);
Generate LOD Lights making random hashes, now sorting by streetLight and hash
2019-01-26 07:24:20 +08:00
var light = new Light();
light.position = new MetaVECTOR3(epos);
light.colour = c;
light.direction = new MetaVECTOR3(edir);
light.falloff = la.Falloff;
light.falloffExponent = la.FalloffExponent;
light.timeAndStateFlags = t;
light.hash = h;
light.coneInnerAngle = (byte)la.ConeInnerAngle;
light.coneOuterAngleOrCapExt = Math.Max((byte)la.ConeOuterAngle, maxext);
light.coronaIntensity = (byte)(la.CoronaIntensity * 6);
light.isStreetLight = isStreetLight;
lights.Add(light);
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
}
}
}
}
}
Generate LOD Lights making random hashes, now sorting by streetLight and hash
2019-01-26 07:24:20 +08:00
if (lights.Count == 0)
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
{
MessageBox.Show("No lights found in project!");
return;
}
Generate LOD Lights making random hashes, now sorting by streetLight and hash
2019-01-26 07:24:20 +08:00
//final lights should be sorted by isStreetLight (1 first!) and then hash
lights.Sort((a, b) =>
{
if (a.isStreetLight != b.isStreetLight) return b.isStreetLight.CompareTo(a.isStreetLight);
return a.hash.CompareTo(b.hash);
});
var position = new List<MetaVECTOR3>();
var colour = new List<uint>();
var direction = new List<MetaVECTOR3>();
var falloff = new List<float>();
var falloffExponent = new List<float>();
var timeAndStateFlags = new List<uint>();
var hash = new List<uint>();
var coneInnerAngle = new List<byte>();
var coneOuterAngleOrCapExt = new List<byte>();
var coronaIntensity = new List<byte>();
ushort numStreetLights = 0;
foreach (var light in lights)
{
position.Add(light.position);
colour.Add(light.colour);
direction.Add(light.direction);
falloff.Add(light.falloff);
falloffExponent.Add(light.falloffExponent);
timeAndStateFlags.Add(light.timeAndStateFlags);
hash.Add(light.hash);
coneInnerAngle.Add(light.coneInnerAngle);
coneOuterAngleOrCapExt.Add(light.coneOuterAngleOrCapExt);
coronaIntensity.Add(light.coronaIntensity);
if (light.isStreetLight) numStreetLights++;
}
Fixed bug in Generate LOD Lights when ymaps had no entities
2019-01-22 07:03:28 +08:00
UpdateStatus("Creating new ymap files...");
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
var lodymap = new YmapFile();
var distymap = new YmapFile();
var ll = new YmapLODLights();
var dl = new YmapDistantLODLights();
var cdl = new CDistantLODLight();
Generate LOD Lights streetLight research, fix for MenyooXML import static objects
2019-01-26 06:00:38 +08:00
cdl.category = 1;//0=small, 1=med, 2=large
Generate LOD Lights making random hashes, now sorting by streetLight and hash
2019-01-26 07:24:20 +08:00
cdl.numStreetLights = numStreetLights;
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
dl.CDistantLODLight = cdl;
dl.positions = position.ToArray();
dl.colours = colour.ToArray();
ll.direction = direction.ToArray();
ll.falloff = falloff.ToArray();
ll.falloffExponent = falloffExponent.ToArray();
ll.timeAndStateFlags = timeAndStateFlags.ToArray();
ll.hash = hash.ToArray();
ll.coneInnerAngle = coneInnerAngle.ToArray();
ll.coneOuterAngleOrCapExt = coneOuterAngleOrCapExt.ToArray();
ll.coronaIntensity = coronaIntensity.ToArray();
lodymap._CMapData.flags = 0;
distymap._CMapData.flags = 2;
lodymap._CMapData.contentFlags = 128;
distymap._CMapData.contentFlags = 256;
lodymap._CMapData.entitiesExtentsMin = eemin;
lodymap._CMapData.entitiesExtentsMax = eemax;
lodymap._CMapData.streamingExtentsMin = semin - 1000f;
Fixed bug in Generate LOD Lights when ymaps had no entities
2019-01-22 07:03:28 +08:00
lodymap._CMapData.streamingExtentsMax = semax + 1000f; //vanilla = ~1km
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
distymap._CMapData.entitiesExtentsMin = eemin;
distymap._CMapData.entitiesExtentsMax = eemax;
distymap._CMapData.streamingExtentsMin = semin - 5000f; //make it huge
Fixed bug in Generate LOD Lights when ymaps had no entities
2019-01-22 07:03:28 +08:00
distymap._CMapData.streamingExtentsMax = semax + 5000f; //vanilla = ~3km
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
lodymap.LODLights = ll;
distymap.DistantLODLights = dl;
var lodname = pname + "_lodlights";
var distname = pname + "_distantlights";
lodymap.Name = lodname;
lodymap._CMapData.name = JenkHash.GenHash(lodname);
lodymap.RpfFileEntry = new RpfResourceFileEntry();
lodymap.RpfFileEntry.Name = lodname + ".ymap";
lodymap.RpfFileEntry.NameLower = lodname + ".ymap";
distymap.Name = distname;
distymap._CMapData.name = JenkHash.GenHash(distname);
distymap.RpfFileEntry = new RpfResourceFileEntry();
distymap.RpfFileEntry.Name = distname + ".ymap";
distymap.RpfFileEntry.NameLower = distname + ".ymap";
lodymap._CMapData.parent = distymap._CMapData.name;
Fixed bug in Generate LOD Lights when ymaps had no entities
2019-01-22 07:03:28 +08:00
UpdateStatus("Adding new ymap files to project...");
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
ProjectForm.Invoke((MethodInvoker)delegate
{
ProjectForm.AddYmapToProject(lodymap);
ProjectForm.AddYmapToProject(distymap);
});
var stats = "";
UpdateStatus("Process complete. " + stats);
GenerateComplete();
});
}
Generate LOD Lights making random hashes, now sorting by streetLight and hash
2019-01-26 07:24:20 +08:00
Trying to generate hash for LOD lights
2019-01-26 18:00:13 +08:00
private uint GetLightHash(YmapEntityDef ent, int lightIndex)
{
unchecked
{
//var aabb1 = GetAABB(ent);
var aabb = GetAABB2(ent);
var hashData = new int[7];
hashData[0] = (int)(aabb.Min.X * 10.0f);
hashData[1] = (int)(aabb.Min.Y * 10.0f);
hashData[2] = (int)(aabb.Min.Z * 10.0f);
hashData[3] = (int)(aabb.Max.X * 10.0f);
hashData[4] = (int)(aabb.Max.Y * 10.0f);
hashData[5] = (int)(aabb.Max.Z * 10.0f);
hashData[6] = lightIndex;
int v3 = 7;
int v4 = 0;//=hashData index
int v5 = (int)0xDEADBEEF + 28;// -559038709;
int v6 = (int)0xDEADBEEF + 28;
int v7 = (int)0xDEADBEEF + 28;
uint v8 = 2;
do
{
int v9 = hashData[v4 + 2] + v5;
int v10 = hashData[v4 + 1] + v6;
int v11 = hashData[v4 + 0] - v9;
int v13 = v10 + v9;
int v14 = (v7 + v11) ^ RotateLeft(v9, 4);
int v17 = v13 + v14;
int v18 = (v10 - v14) ^ RotateLeft(v14, 6);
int v21 = v17 + v18;
int v22 = (v13 - v18) ^ RotateLeft(v18, 8);
int v25 = v21 + v22;
int v26 = (v17 - v22) ^ RotateLeft(v22, 16);
int v29 = (v21 - v26) ^ RotateRight(v26, 13);
int v30 = v25 - v29;
v7 = v25 + v26;
v6 = v7 + v29;
v5 = v30 ^ RotateLeft(v29, 4);
v4 += 3;
v3 -= 3;
--v8;
}
while (v8 > 0);
int v32 = v3 - 1; //should always be 0
if (v32 != 0)
{ }
int v50 = v7 + hashData[v4];
int v34 = (v6 ^ v5) - RotateLeft(v6, 14);
int v35 = (v34 ^ v50) - RotateLeft(v34, 11);
int v36 = (v35 ^ v6) - RotateRight(v35, 7);
int v37 = (v36 ^ v34) - RotateLeft(v36, 16);
int v51 = (v35 ^ v37) - RotateLeft(v37, 4);
int v38 = (v51 ^ v36) - RotateLeft(v51, 14);
int v53 = (v38 ^ v37) - RotateRight(v38, 8);
return (uint)v53;
}
}
private AABB_s GetAABB(YmapEntityDef ent)
{
var arch = ent.Archetype;
var ori = ent.Orientation;
Vector3 bbmin = ent.Position - ent.BSRadius; //sphere
Vector3 bbmax = ent.Position + ent.BSRadius;
if (arch != null)
{
Vector3[] c = new Vector3[8];
Vector3 abmin = arch.BBMin * ent.Scale; //entity box
Vector3 abmax = arch.BBMax * ent.Scale;
c[0] = abmin;
c[1] = new Vector3(abmin.X, abmin.Y, abmax.Z);
c[2] = new Vector3(abmin.X, abmax.Y, abmin.Z);
c[3] = new Vector3(abmin.X, abmax.Y, abmax.Z);
c[4] = new Vector3(abmax.X, abmin.Y, abmin.Z);
c[5] = new Vector3(abmax.X, abmin.Y, abmax.Z);
c[6] = new Vector3(abmax.X, abmax.Y, abmin.Z);
c[7] = abmax;
bbmin = new Vector3(float.MaxValue);
bbmax = new Vector3(float.MinValue);
for (int j = 0; j < 8; j++)
{
Vector3 corn = ori.Multiply(c[j]) + ent.Position;
bbmin = Vector3.Min(bbmin, corn);
bbmax = Vector3.Max(bbmax, corn);
}
}
AABB_s b = new AABB_s();
b.Min = new Vector4(bbmin, 0f);
b.Max = new Vector4(bbmax, 0f);
return b;
}
private AABB_s GetAABB2(YmapEntityDef ent)
{
var arch = ent.Archetype;
var ori = ent.Orientation;
var pos = ent.Position;
var sca = ent.Scale;
var mat = Matrix.Transformation(Vector3.Zero, Quaternion.Identity, sca, Vector3.Zero, ori, pos);
var matabs = mat;
matabs.Column1 = mat.Column1.Abs();
matabs.Column2 = mat.Column2.Abs();
matabs.Column3 = mat.Column3.Abs();
matabs.Column4 = mat.Column4.Abs();
Vector3 bbmin = pos - ent.BSRadius; //sphere
Vector3 bbmax = pos + ent.BSRadius;
if (arch != null)
{
var bbcenter = (arch.BBMax + arch.BBMin) * 0.5f;
var bbextent = (arch.BBMax - arch.BBMin) * 0.5f;
var ncenter = Vector3.TransformCoordinate(bbcenter, mat);
var nextent = Vector3.TransformNormal(bbextent, matabs);
bbmin = ncenter - nextent;
bbmax = ncenter + nextent;
}
AABB_s b = new AABB_s();
b.Min = new Vector4(bbmin, 0f);
b.Max = new Vector4(bbmax, 0f);
return b;
}
private static uint RotateLeft(uint value, int count)
{
return (value << count) | (value >> (32 - count));
}
private static uint RotateRight(uint value, int count)
{
return (value >> count) | (value << (32 - count));
}
private static int RotateLeft(int value, int count)
{
return (int)RotateLeft((uint)value, count);
}
private static int RotateRight(int value, int count)
{
return (int)RotateRight((uint)value, count);
}
Generate LOD Lights making random hashes, now sorting by streetLight and hash
2019-01-26 07:24:20 +08:00
public class Light
{
public MetaVECTOR3 position { get; set; }
public uint colour { get; set; }
public MetaVECTOR3 direction { get; set; }
public float falloff { get; set; }
public float falloffExponent { get; set; }
public uint timeAndStateFlags { get; set; }
public uint hash { get; set; }
public byte coneInnerAngle { get; set; }
public byte coneOuterAngleOrCapExt { get; set; }
public byte coronaIntensity { get; set; }
public bool isStreetLight { get; set; }
}
Generate LOD Lights tool (WIP)
2019-01-21 14:30:43 +08:00
}
}
Reference in New Issue Copy Permalink