501 lines
17 KiB
C#
501 lines
17 KiB
C#
// Decompiled with JetBrains decompiler
|
||
// Type: SFXProductions.GradientTool.HDMA.Generator2
|
||
// Assembly: GradientTool, Version=0.8.2.1, Culture=neutral, PublicKeyToken=null
|
||
// MVID: 818AB9B3-796A-4A49-8B90-C00D066A321B
|
||
// Assembly location: C:\Users\aless\Downloads\gradient-tool-v0.8.2.1\GradientTool.exe
|
||
|
||
using System;
|
||
using System.Collections.Generic;
|
||
|
||
#nullable disable
|
||
namespace SFXProductions.GradientTool.HDMA;
|
||
|
||
internal static class Generator2
|
||
{
|
||
private const int c_col2 = 5;
|
||
private const int REG_43x0 = 17152;
|
||
private const int REG_43x2 = 17154;
|
||
private const int REG_43x4 = 17156;
|
||
private const string c_defaultName = "Gradient";
|
||
|
||
private static ushort ApplyChannelFlag(int n, ChannelType flag)
|
||
{
|
||
return (ushort) ((ChannelType) n | flag);
|
||
}
|
||
|
||
private static ushort GetNormalModeDataValue(double r, double g, double b, ChannelType channels)
|
||
{
|
||
int num1 = 0;
|
||
double num2 = 0.0;
|
||
bool flag;
|
||
if ((flag = channels == ChannelType.Brightness) || channels == ChannelType.Grey)
|
||
{
|
||
num2 = r + g + b;
|
||
num1 = 3;
|
||
}
|
||
else
|
||
{
|
||
if ((channels & ChannelType.Red) == ChannelType.Red)
|
||
{
|
||
num2 += r;
|
||
++num1;
|
||
}
|
||
if ((channels & ChannelType.Green) == ChannelType.Green)
|
||
{
|
||
num2 += g;
|
||
++num1;
|
||
}
|
||
if ((channels & ChannelType.Blue) == ChannelType.Blue)
|
||
{
|
||
num2 += b;
|
||
++num1;
|
||
}
|
||
}
|
||
return Generator2.ApplyChannelFlag(Generator2.GetV5(num2 / (double) num1, flag ? 15 : 31 /*0x1F*/), channels);
|
||
}
|
||
|
||
private static int GetV5(double v, int range = 31 /*0x1F*/)
|
||
{
|
||
return (int) (v.Clamp() * (double) range + 0.5);
|
||
}
|
||
|
||
private static ushort GetRGBChannelValue(double r, double g, double b)
|
||
{
|
||
return (ushort) (Generator2.GetV5(r) | Generator2.GetV5(g) << 5 | Generator2.GetV5(b) << 10);
|
||
}
|
||
|
||
internal static void CreateMode0Table(
|
||
double[] chR,
|
||
double[] chG,
|
||
double[] chB,
|
||
ChannelType channels,
|
||
DataPoint[] result)
|
||
{
|
||
for (int index = 0; index < result.Length; ++index)
|
||
result[index] = new DataPoint()
|
||
{
|
||
Data1 = Generator2.GetNormalModeDataValue(chR[index], chG[index], chB[index], channels)
|
||
};
|
||
}
|
||
|
||
internal static void CreateMode2Table(
|
||
double[] chR,
|
||
double[] chG,
|
||
double[] chB,
|
||
ChannelType ch1,
|
||
ChannelType ch2,
|
||
DataPoint[] result)
|
||
{
|
||
for (int index = 0; index < result.Length; ++index)
|
||
{
|
||
double r = chR[index];
|
||
double g = chG[index];
|
||
double b = chB[index];
|
||
result[index] = new DataPoint()
|
||
{
|
||
Data1 = Generator2.GetNormalModeDataValue(r, g, b, ch1),
|
||
Data2 = Generator2.GetNormalModeDataValue(r, g, b, ch2)
|
||
};
|
||
}
|
||
}
|
||
|
||
internal static void CreateScrollingTable(
|
||
double[] chR,
|
||
double[] chG,
|
||
double[] chB,
|
||
DataPoint[] result)
|
||
{
|
||
for (int index = 0; index < result.Length; ++index)
|
||
{
|
||
double v1 = chR[index];
|
||
double v2 = chG[index];
|
||
double v3 = chB[index];
|
||
result[index] = new DataPoint()
|
||
{
|
||
Data1 = Generator2.ApplyChannelFlag(Generator2.GetV5(v1), ChannelType.Red),
|
||
Data2 = Generator2.ApplyChannelFlag(Generator2.GetV5(v2), ChannelType.Green),
|
||
Data3 = Generator2.ApplyChannelFlag(Generator2.GetV5(v3), ChannelType.Blue)
|
||
};
|
||
}
|
||
}
|
||
|
||
internal static void CreateMode1Table(
|
||
double[] chR,
|
||
double[] chG,
|
||
double[] chB,
|
||
ushort paletteIndex,
|
||
DataPoint[] result)
|
||
{
|
||
for (int index = 0; index < result.Length; ++index)
|
||
{
|
||
double r = chR[index];
|
||
double g = chG[index];
|
||
double b = chB[index];
|
||
result[index] = new DataPoint()
|
||
{
|
||
Data1 = paletteIndex,
|
||
Data2 = Generator2.GetRGBChannelValue(r, g, b)
|
||
};
|
||
}
|
||
}
|
||
|
||
private static void DoNormalMode(
|
||
ref int srcI,
|
||
DataPoint[] src,
|
||
List<CompressedDataPoint> dst,
|
||
bool allowCountAbove128)
|
||
{
|
||
DataPoint dataPoint = src[srcI];
|
||
CompressedDataPoint compressedDataPoint = new CompressedDataPoint(dataPoint);
|
||
for (int index = srcI + 1; index < src.Length && src[index] == dataPoint && (allowCountAbove128 && compressedDataPoint.Count < (int) byte.MaxValue || compressedDataPoint.Count < 128 /*0x80*/); ++index)
|
||
++compressedDataPoint.Count;
|
||
dst.Add(compressedDataPoint);
|
||
srcI += compressedDataPoint.Count;
|
||
}
|
||
|
||
private static bool CheckForContinuousMode(
|
||
ref int srcI,
|
||
DataPoint[] src,
|
||
List<CompressedDataPoint> dst)
|
||
{
|
||
if (srcI + 2 >= src.Length || !(src[srcI] != src[srcI + 1]) || srcI + 3 >= src.Length || !(src[srcI + 1] != src[srcI + 2]))
|
||
return false;
|
||
CompressedDataPoint compressedDataPoint = new CompressedDataPoint(src[srcI]);
|
||
for (int index = srcI + 1; compressedDataPoint.Data.Count < (int) sbyte.MaxValue && index < src.Length; ++index)
|
||
{
|
||
DataPoint dataPoint = src[index];
|
||
if (index + 2 >= src.Length || dataPoint != src[index + 1])
|
||
compressedDataPoint.Data.Add(dataPoint);
|
||
else
|
||
break;
|
||
}
|
||
dst.Add(compressedDataPoint);
|
||
srcI += compressedDataPoint.Data.Count;
|
||
return true;
|
||
}
|
||
|
||
private static List<CompressedDataPoint> CompressTable(
|
||
DataPoint[] dataPoints,
|
||
bool canUseContinuousMode)
|
||
{
|
||
List<CompressedDataPoint> dst = new List<CompressedDataPoint>();
|
||
int srcI = 0;
|
||
while (srcI < dataPoints.Length)
|
||
{
|
||
if (!canUseContinuousMode || !Generator2.CheckForContinuousMode(ref srcI, dataPoints, dst))
|
||
Generator2.DoNormalMode(ref srcI, dataPoints, dst, false);
|
||
}
|
||
return dst;
|
||
}
|
||
|
||
internal static int GetNChannels(GradientChannels channels)
|
||
{
|
||
switch (channels)
|
||
{
|
||
case GradientChannels.RedGreenBlue:
|
||
return 3;
|
||
case GradientChannels.RedGreen:
|
||
case GradientChannels.GreenBlue:
|
||
case GradientChannels.RedBlue:
|
||
case GradientChannels.CyanRed:
|
||
case GradientChannels.YellowBlue:
|
||
case GradientChannels.MagentaGreen:
|
||
return 2;
|
||
case GradientChannels.Red:
|
||
case GradientChannels.Green:
|
||
case GradientChannels.Blue:
|
||
case GradientChannels.Cyan:
|
||
case GradientChannels.Yellow:
|
||
case GradientChannels.Magenta:
|
||
case GradientChannels.Grey:
|
||
case GradientChannels.Brightness:
|
||
return 1;
|
||
default:
|
||
throw new ArgumentException("Invalid channels.");
|
||
}
|
||
}
|
||
|
||
internal static ChannelType GetChannel(GradientChannels channels, int index)
|
||
{
|
||
switch (channels)
|
||
{
|
||
case GradientChannels.RedGreenBlue:
|
||
if (index == 0)
|
||
return ChannelType.Red;
|
||
return index != 1 ? ChannelType.Blue : ChannelType.Green;
|
||
case GradientChannels.RedGreen:
|
||
return index != 0 ? ChannelType.Green : ChannelType.Red;
|
||
case GradientChannels.GreenBlue:
|
||
return index != 0 ? ChannelType.Blue : ChannelType.Green;
|
||
case GradientChannels.RedBlue:
|
||
return index != 0 ? ChannelType.Blue : ChannelType.Red;
|
||
case GradientChannels.CyanRed:
|
||
return index != 0 ? ChannelType.Red : ChannelType.Cyan;
|
||
case GradientChannels.YellowBlue:
|
||
return index != 0 ? ChannelType.Blue : ChannelType.Yellow;
|
||
case GradientChannels.MagentaGreen:
|
||
return index != 0 ? ChannelType.Green : ChannelType.Magenta;
|
||
case GradientChannels.Red:
|
||
return ChannelType.Red;
|
||
case GradientChannels.Green:
|
||
return ChannelType.Green;
|
||
case GradientChannels.Blue:
|
||
return ChannelType.Blue;
|
||
case GradientChannels.Cyan:
|
||
return ChannelType.Cyan;
|
||
case GradientChannels.Yellow:
|
||
return ChannelType.Yellow;
|
||
case GradientChannels.Magenta:
|
||
return ChannelType.Magenta;
|
||
case GradientChannels.Grey:
|
||
return ChannelType.Grey;
|
||
case GradientChannels.Brightness:
|
||
return ChannelType.Brightness;
|
||
default:
|
||
throw new ArgumentException("Invalid channels.");
|
||
}
|
||
}
|
||
|
||
public static void GenerateCode(
|
||
double[] rBuffer,
|
||
double[] gBuffer,
|
||
double[] bBuffer,
|
||
Settings2 settings,
|
||
CodeGen code)
|
||
{
|
||
uint size = 0;
|
||
List<CompressedDataPoint> outTable1 = (List<CompressedDataPoint>) null;
|
||
List<CompressedDataPoint> outTable2 = (List<CompressedDataPoint>) null;
|
||
List<CompressedDataPoint> outTable3 = (List<CompressedDataPoint>) null;
|
||
DataPoint[] tmpBuffer = new DataPoint[rBuffer.Length];
|
||
Generator2.DoChan(settings.Channel1, rBuffer, gBuffer, bBuffer, tmpBuffer, ref size, ref outTable1);
|
||
Generator2.DoChan(settings.Channel2, rBuffer, gBuffer, bBuffer, tmpBuffer, ref size, ref outTable2);
|
||
Generator2.DoChan(settings.Channel3, rBuffer, gBuffer, bBuffer, tmpBuffer, ref size, ref outTable3);
|
||
code.WriteBanner();
|
||
code.WriteComment(settings.GetGradientTypeBanner());
|
||
code.WriteComment("Channels: " + GradientChannelsHelper.GetChannelString(settings.Channels));
|
||
code.WriteComment("Table Size: " + size.ToString("N0"));
|
||
code.WriteComment("No. of Writes: " + rBuffer.Length.ToString("N0"));
|
||
code.WriteComment();
|
||
code.WriteComment("Generated by GradientTool");
|
||
code.WriteBanner();
|
||
Generator2.WriteActivator(settings, code);
|
||
string gradientName = settings.Name ?? "Gradient";
|
||
Generator2.WriteChan(settings.Channel1, outTable1, code, gradientName);
|
||
Generator2.WriteChan(settings.Channel2, outTable2, code, gradientName);
|
||
Generator2.WriteChan(settings.Channel3, outTable3, code, gradientName);
|
||
}
|
||
|
||
private static void DoChan(
|
||
Channel chan,
|
||
double[] rBuffer,
|
||
double[] gBuffer,
|
||
double[] bBuffer,
|
||
DataPoint[] tmpBuffer,
|
||
ref uint size,
|
||
ref List<CompressedDataPoint> outTable)
|
||
{
|
||
if (chan == null)
|
||
return;
|
||
chan.GetRawData(rBuffer, gBuffer, bBuffer, tmpBuffer);
|
||
outTable = Generator2.CompressTable(tmpBuffer, chan.CanUseContinuousMode);
|
||
size += chan.CalculateTableSize((IList<CompressedDataPoint>) outTable) + 1U;
|
||
}
|
||
|
||
private static void WriteChan(
|
||
Channel chan,
|
||
List<CompressedDataPoint> table,
|
||
CodeGen code,
|
||
string gradientName)
|
||
{
|
||
if (chan == null)
|
||
return;
|
||
code.AppendLine();
|
||
chan.WriteData((IList<CompressedDataPoint>) table, code, gradientName);
|
||
}
|
||
|
||
private static void WriteActivator(Settings2 settings, CodeGen code)
|
||
{
|
||
if (!settings.GenerateInitializationCode)
|
||
return;
|
||
code.AppendLine();
|
||
if (settings.Channel1 is CombinedChannel)
|
||
{
|
||
code.WriteComment("GradientTool doesn’t generate the code");
|
||
code.WriteComment("to initialize scrolling gradients.");
|
||
code.WriteComment();
|
||
code.WriteComment("See the ASM files in the folder titled");
|
||
code.WriteComment("Example, located in the same folder as");
|
||
code.WriteComment("GradientTool.");
|
||
}
|
||
else if (settings.Channel1 is Mode3Channel)
|
||
Generator2.WriteActivatorInternal(settings, (ushort) 8451, (ushort) 8451, (ushort) 8451, code);
|
||
else if (settings.Channel1 is Mode0Channel)
|
||
{
|
||
ushort num = settings.Channels != GradientChannels.Brightness ? (ushort) 12800 : (ushort) 0;
|
||
Generator2.WriteActivatorInternal(settings, num, num, num, code);
|
||
}
|
||
else if (settings.Channel1 is Mode2Channel)
|
||
{
|
||
Generator2.WriteActivatorInternal(settings, (ushort) 12802, (ushort) 12800, (ushort) 12800, code);
|
||
}
|
||
else
|
||
{
|
||
code.WriteComment("Something went wrong and the type of");
|
||
code.WriteComment("HDMA gradient being generated couldn’t");
|
||
code.WriteComment("be determined.");
|
||
}
|
||
}
|
||
|
||
private static void WriteActivatorInternal(
|
||
Settings2 settings,
|
||
ushort transferMode0,
|
||
ushort transferMode1,
|
||
ushort transferMode2,
|
||
CodeGen code)
|
||
{
|
||
string chans = Generator2.GetChans(settings);
|
||
code.WriteComment("Set up the HDMA gradient.");
|
||
code.WriteComment($"Uses HDMA {chans}{(object) '.'}");
|
||
code.AppendLabel("Init" + (settings.Name ?? "Gradient"));
|
||
code.AppendPlainText(':');
|
||
code.AppendLine();
|
||
code.Write16BitMode(5);
|
||
code.AppendLine();
|
||
code.WriteComment("Set transfer modes.", (true ? 1 : 0) != 0);
|
||
code.WriteLDAIfNonzero(transferMode0, 5);
|
||
CodeGen codeGen1 = code;
|
||
int num1 = 5;
|
||
string chanStr1 = Generator2.GetChanStr(settings.Channel1);
|
||
int register1 = (int) Generator2.GetRegister(17152, settings.Channel1);
|
||
int num2 = (int) transferMode0;
|
||
int w1 = num1;
|
||
string comment1 = chanStr1;
|
||
codeGen1.WriteSTAIfNonzero((ushort) register1, (ushort) num2, w1, comment1);
|
||
if (settings.Channel2 != null)
|
||
{
|
||
if ((int) transferMode1 != (int) transferMode0)
|
||
{
|
||
CodeGen codeGen2 = code;
|
||
int num3 = 5;
|
||
int num4 = (int) transferMode1;
|
||
int w2 = num3;
|
||
codeGen2.WriteLDAIfNonzero((ushort) num4, w2);
|
||
}
|
||
CodeGen codeGen3 = code;
|
||
int num5 = 5;
|
||
string chanStr2 = Generator2.GetChanStr(settings.Channel2);
|
||
int register2 = (int) Generator2.GetRegister(17152, settings.Channel2);
|
||
int num6 = (int) transferMode1;
|
||
int w3 = num5;
|
||
string comment2 = chanStr2;
|
||
codeGen3.WriteSTAIfNonzero((ushort) register2, (ushort) num6, w3, comment2);
|
||
if (settings.Channel3 != null)
|
||
{
|
||
if ((int) transferMode2 != (int) transferMode1)
|
||
{
|
||
CodeGen codeGen4 = code;
|
||
int num7 = 5;
|
||
int num8 = (int) transferMode2;
|
||
int w4 = num7;
|
||
codeGen4.WriteLDAIfNonzero((ushort) num8, w4);
|
||
}
|
||
CodeGen codeGen5 = code;
|
||
int num9 = 5;
|
||
string chanStr3 = Generator2.GetChanStr(settings.Channel3);
|
||
int register3 = (int) Generator2.GetRegister(17152, settings.Channel3);
|
||
int num10 = (int) transferMode2;
|
||
int w5 = num9;
|
||
string comment3 = chanStr3;
|
||
codeGen5.WriteSTAIfNonzero((ushort) register3, (ushort) num10, w5, comment3);
|
||
}
|
||
}
|
||
code.AppendLine();
|
||
code.WriteComment("Point to HDMA tables.", (true ? 1 : 0) != 0);
|
||
Generator2.WriteChanSourceLoader(settings.Channel1, settings.Name, code);
|
||
Generator2.WriteChanSourceLoader(settings.Channel2, settings.Name, code);
|
||
Generator2.WriteChanSourceLoader(settings.Channel3, settings.Name, code);
|
||
code.AppendLine();
|
||
code.Write8BitMode(5);
|
||
code.AppendLine();
|
||
code.WriteComment("Store program bank to $43x4.", (true ? 1 : 0) != 0);
|
||
code.WriteKeywordLine("PHK");
|
||
code.WriteKeywordLine("PLA");
|
||
Generator2.WriteChanBankLoader(settings.Channel1, code);
|
||
Generator2.WriteChanBankLoader(settings.Channel2, code);
|
||
Generator2.WriteChanBankLoader(settings.Channel3, code);
|
||
code.AppendLine();
|
||
CodeGen codeGen6 = code;
|
||
bool flag = true;
|
||
string comment4 = $"Enable {chans}{(object) '.'}";
|
||
int num11 = flag ? 1 : 0;
|
||
codeGen6.WriteComment(comment4, num11 != 0);
|
||
code.WriteLDA_b_c_bin(Generator2.GetHDMAFlags(settings), 5);
|
||
code.WriteTSB((ushort) 3487, 5);
|
||
code.AppendLine();
|
||
code.AppendHardTab();
|
||
code.AppendKeyword("RTS");
|
||
code.WriteComment("<-- Can also be RTL.", space: (true ? 1 : 0) != 0);
|
||
code.AppendLine();
|
||
code.AppendComment("; --- HDMA Tables below this line ---");
|
||
}
|
||
|
||
private static string GetChans(Settings2 settings)
|
||
{
|
||
if (settings.Channel2 == null)
|
||
return "channel " + settings.Channel1.HDMAChannel.ToString();
|
||
return settings.Channel3 != null ? $"channels {settings.Channel1.HDMAChannel}, {settings.Channel2.HDMAChannel}, and {settings.Channel3.HDMAChannel}" : $"channels {settings.Channel1.HDMAChannel} and {settings.Channel2.HDMAChannel}";
|
||
}
|
||
|
||
private static string GetChanStr(Channel channel) => "Channel " + channel.HDMAChannel.ToString();
|
||
|
||
private static ushort GetRegister(int reg, int channel) => (ushort) (reg | (channel & 7) << 4);
|
||
|
||
private static ushort GetRegister(int reg, Channel channel)
|
||
{
|
||
return (ushort) (reg | (channel.HDMAChannel & 7) << 4);
|
||
}
|
||
|
||
private static byte GetHDMAFlags(Settings2 settings)
|
||
{
|
||
int hdmaFlags = 1 << (settings.Channel1.HDMAChannel & 7);
|
||
if (settings.Channel2 != null)
|
||
{
|
||
hdmaFlags |= 1 << (settings.Channel2.HDMAChannel & 7);
|
||
if (settings.Channel3 != null)
|
||
hdmaFlags |= 1 << (settings.Channel3.HDMAChannel & 7);
|
||
}
|
||
return (byte) hdmaFlags;
|
||
}
|
||
|
||
private static void WriteChanSourceLoader(Channel channel, string gradientName, CodeGen code)
|
||
{
|
||
if (channel == null)
|
||
return;
|
||
string channelLabel = channel.GetChannelLabel(gradientName ?? "Gradient");
|
||
CodeGen codeGen1 = code;
|
||
int num1 = 5;
|
||
string label = channelLabel;
|
||
int w1 = num1;
|
||
codeGen1.WriteLDA_Label(label, w1);
|
||
CodeGen codeGen2 = code;
|
||
int num2 = 5;
|
||
int register = (int) Generator2.GetRegister(17154, channel);
|
||
int w2 = num2;
|
||
codeGen2.WriteSTA((ushort) register, w2);
|
||
}
|
||
|
||
private static void WriteChanBankLoader(Channel channel, CodeGen code)
|
||
{
|
||
if (channel == null)
|
||
return;
|
||
CodeGen codeGen = code;
|
||
int num = 5;
|
||
string chanStr = Generator2.GetChanStr(channel);
|
||
int register = (int) Generator2.GetRegister(17156, channel);
|
||
int w = num;
|
||
string comment = chanStr;
|
||
codeGen.WriteSTA((ushort) register, w, comment);
|
||
}
|
||
}
|