public ArtworkPopup()
: base(Gtk.WindowType.Popup)
{
VBox vbox = new VBox();
Add(vbox);
Decorated = false;
BorderWidth = 6;
SetPosition(WindowPosition.CenterAlways);
image = new Gtk.Image();
label = new Label(String.Empty);
label.CanFocus = false;
label.Wrap = true;
var bg_color = new RGBA ();
bg_color.Red = bg_color.Green = bg_color.Blue = 0;
var fg_color = new RGBA ();
fg_color.Red = bg_color.Green = bg_color.Blue = 160.0 / 255;
label.OverrideBackgroundColor (StateFlags.Normal, bg_color);
label.OverrideColor (StateFlags.Normal, fg_color);
OverrideBackgroundColor (StateFlags.Normal, bg_color);
OverrideColor (StateFlags.Normal, fg_color);
vbox.PackStart(image, true, true, 0);
vbox.PackStart(label, false, false, 0);
vbox.Spacing = 6;
vbox.ShowAll();
}
public void Text(RGBA color, Utilities.Point topleft, string text, float fontsize = 16, string fontname = "Arial")
{
Graphics.DrawString(text, GetCachedFont(fontname, fontsize), GetCachedSolidBrush(color), topleft.X, topleft.Y);
}
private void Update(EvaluationContext context)
{
Output.Value = RGBA.GetValue(context);
}
private void WriteRGBA(BinaryWriter Writer, RGBA Color)
{
Writer.Write(Color.ToVector4());
}
public static void Write
(
Color[] pixels,
int width,
int height,
int bitDepth,
bool alpha,
bool greyscale,
string filePath
)
{
var info = new ImageInfo(
width,
height,
bitDepth,
alpha,
greyscale,
false//not implemented here yet//bitDepth==4
);
// open image for writing:
PngWriter writer = FileHelper.CreatePngWriter(filePath, info, true);
// add some optional metadata (chunks)
var meta = writer.GetMetadata();
int numRows = info.Rows;
int numCols = info.Cols;
ImageLine imageline = new ImageLine(info);
for (int row = 0; row < numRows; row++)
{
//fill line:
if (greyscale == false)
{
if (alpha)
{
for (int col = 0; col < numCols; col++)
{
RGBA rgba = ToRGBA(pixels[IndexPngToTexture(row, col, numRows, numCols)], bitDepth);
ImageLineHelper.SetPixel(imageline, col, rgba.r, rgba.g, rgba.b, rgba.a);
}
}
else
{
for (int col = 0; col < numCols; col++)
{
RGB rgb = ToRGB(pixels[IndexPngToTexture(row, col, numRows, numCols)], bitDepth);
ImageLineHelper.SetPixel(imageline, col, rgb.r, rgb.g, rgb.b);
}
}
}
else
{
if (alpha == false)
{
for (int col = 0; col < numCols; col++)
{
int r = ToInt(pixels[IndexPngToTexture(row, col, numRows, numCols)].r, bitDepth);
ImageLineHelper.SetPixel(imageline, col, r);
}
}
else
{
for (int col = 0; col < numCols; col++)
{
int a = ToInt(pixels[IndexPngToTexture(row, col, numRows, numCols)].a, bitDepth);
ImageLineHelper.SetPixel(imageline, col, a);
}
}
}
//write line:
writer.WriteRow(imageline, row);
}
writer.End();
}
public static string Color(this string str, RGBA color) => $"<color=#{color:X}>{str}</color>";
/// <summary>
/// Initializes the channel equalization filter.
/// </summary>
/// <param name="channel">Channel of RGBA model</param>
public EqualizeChannel(RGBA channel)
{
Channel = channel;
}
public HashCode GenerateHashCodeForEnhance( RGBA rgba, Long zoom, HashCode parent ){
}
public static void Write
(
Color[] pixels,
int width,
int height,
int bitDepth,
bool alpha,
bool greyscale,
string filePath
)
{
var imageInfo = new ImageInfo(
width,
height,
bitDepth,
alpha,
greyscale,
false //not implemented here yet//bitDepth==4
);
// open image for writing:
PngWriter writer = FileHelper.CreatePngWriter(filePath, imageInfo, true);
// add some optional metadata (chunks)
var meta = writer.GetMetadata();
meta.SetTimeNow(0); // 0 seconds fron now = now
int numRows = imageInfo.Rows;
int numCols = imageInfo.Cols;
int channels = imageInfo.Channels;
for (int row = 0; row < numRows; row++)
{
int[] ints = new int[imageInfo.SamplesPerRow];
//fill line:
if (greyscale == false)
{
if (alpha)
{
for (int col = 0; col < numCols; col++)
{
RGBA <int> rgba = ToRGBA(pixels[IndexPngToTexture(row, col, numRows, numCols)], bitDepth);
ImageLineHelper.SetPixel(ints, rgba, col, channels);
}
}
else
{
for (int col = 0; col < numCols; col++)
{
RGB <int> rgb = ToRGB(pixels[IndexPngToTexture(row, col, numRows, numCols)], bitDepth);
ImageLineHelper.SetPixel(ints, rgb, col, channels);
}
}
}
else
{
if (alpha == false)
{
for (int col = 0; col < numCols; col++)
{
int R = ToInt(pixels[IndexPngToTexture(row, col, numRows, numCols)].r, bitDepth);
ImageLineHelper.SetPixel(ints, R, col, channels);
}
}
else
{
for (int col = 0; col < numCols; col++)
{
int A = ToInt(pixels[IndexPngToTexture(row, col, numRows, numCols)].a, bitDepth);
ImageLineHelper.SetPixel(ints, A, col, channels);
}
}
}
//write line:
ImageLine imageline = new ImageLine(imageInfo, ImageLine.ESampleType.INT, false, ints, null, row);
writer.WriteRow(imageline, row);
}
writer.End();
}
public extern static void gtk_color_chooser_get_rgba(IntPtr chooser, out RGBA color);
/// <summary>
/// Initializes the channel hide filter.
/// </summary>
/// <param name="channel">Channel of RGBA model</param>
public HideChannel(RGBA channel)
{
Channel = channel;
}
public static string ToHtmlString(this RGBA color)
{
return($"{color:X}");
}
public HashCode GenerateHashCodeForEnhance(RGBA rgba, Long zoom, HashCode parent)
{
}
public void Text(RGBA color, float x, float y, string text, float fontsize = 16)
{
}
/// <summary>
/// Reads the windowstyle from a filestream.
/// </summary>
/// <param name="binread">The System.IO.BinaryReader to use.</param>
public void Open(BinaryReader binread)
{
_sig = new string(binread.ReadChars(4));
_version = binread.ReadInt16();
_edgeWidth = binread.ReadByte();
_backgroundMode = binread.ReadByte();
for (int i = 0; i < _edgeColors.Length; ++i)
{
_edgeColors[i] = new RGBA();
_edgeColors[i].ReadData(binread);
}
for (int i = 0; i < _edgeOffset.Length; ++i) _edgeOffset[1] = binread.ReadByte();
binread.ReadBytes(36); // reserved
switch (_version)
{
case 2:
for (int i = 0; i < _images.Length; ++i)
{
short width = binread.ReadInt16();
short height = binread.ReadInt16();
BitmapLoader loader = new BitmapLoader(width, height);
_images[i] = loader.LoadFromStream(binread, width * height * 4);
loader.Close();
}
break;
}
}
/// <summary>
/// Construct a new DefineBitsLossLess2Tag object
/// from an image object.
/// </summary>
/// <param name="characterId">Character id.</param>
/// <param name="image">Image.</param>
/// <returns></returns>
public static DefineBitsLossLess2Tag FromImage(ushort characterId, Image image)
{
if (image.RawFormat.Equals(ImageFormat.Bmp) == false &&
image.RawFormat.Equals(ImageFormat.MemoryBmp) == false)
{
throw new InvalidImageFormatException();
}
Bitmap bitmap = (Bitmap)image;
byte format = 0;
PixelFormat pxFormat = image.PixelFormat;
if (pxFormat == PixelFormat.Format8bppIndexed)
{
format = 3;
}
else if (pxFormat == PixelFormat.Format16bppRgb555 ||
pxFormat == PixelFormat.Format16bppRgb565)
{
format = 4;
}
else if (pxFormat == PixelFormat.Format24bppRgb)
{
format = 5;
}
else
{
throw new InvalidPixelFormatException();
}
DefineBitsLossLess2Tag bmp = new DefineBitsLossLess2Tag();
bmp.CharacterId = characterId;
bmp.BitmapFormat = format;
bmp.BitmapWidth = (ushort)image.Width;
bmp.BitmapHeight = (ushort)image.Height;
int imageSize = bitmap.Width * bitmap.Height;
if (bmp.BitmapFormat == 3)
{
//TODO
}
else if (bmp.BitmapFormat == 4 ||
bmp.BitmapFormat == 5)
{
RGBA[] bitmapPixelData = new RGBA[imageSize];
int k = 0;
for (int i = 0; i < bitmap.Height; i++)
{
for (int j = 0; j < bitmap.Width; j++)
{
Color color = bitmap.GetPixel(j, i);
bitmapPixelData[k] = new RGBA((byte)color.R, (byte)color.G, (byte)color.B, (byte)color.A);
k++;
}
}
bmp.AlphaBitmapData = new AlphaBitmapData(bitmapPixelData);
}
return(bmp);
}
static void ProcessNByteRow(ImageLine imageLine, Color[] pixels)
{
int row = imageLine.ImageRow;
ImageInfo imgInfo = imageLine.ImgInfo;
int numRows = imgInfo.Rows;
int numCols = imgInfo.Cols;
int bitDepth = imgInfo.BitDepth;
int channels = imgInfo.Channels;
float max = GetBitDepthMaxValue(bitDepth);
var scanline = imageLine.Scanline;
for (int col = 0; col < numCols; col++)
{
int i = col * channels;
RGBA <int> rgba;
if (channels == 4)
{
rgba = new RGBA <int> {
R = scanline[i],
G = scanline[i + 1],
B = scanline[i + 2],
A = scanline[i + 3]
};
}
else if (channels == 3)
{
rgba = new RGBA <int> {
R = scanline[i],
G = scanline[i + 1],
B = scanline[i + 2],
A = int.MaxValue
};
}
else if (channels == 2)
{
int val = scanline[i + 1];
int a = scanline[i];
rgba = new RGBA <int> {
R = val, G = val, B = val,
A = a
};
}
else if (channels == 1)
{
int val = scanline[i];
rgba = new RGBA <int> {
R = val, G = val, B = val, A = val
};
}
else
{
Debug.LogError($"{channels} channels not implemented");
return;
}
Color color = new Color {
r = (float)rgba.R / max,
g = (float)rgba.G / max,
b = (float)rgba.B / max,
a = (float)rgba.A / max
};
pixels[IndexPngToTexture(row, col, numRows, numCols)] = color;
}
}
public void Rectangle(RGBA color, float x, float y, float width, float height, bool fill = true)
{
}
private void ParseTag(ISwfTag tag)
{
switch (tag.TagType)
{
case TagType.DefineSprite:
ParseDefineSpriteTag((DefineSpriteTag)tag);
break;
case TagType.DefineShape:
ParseDefineShapeTag((DefineShapeTag)tag);
break;
case TagType.DefineShape2:
ParseDefineShape2Tag((DefineShape2Tag)tag);
break;
case TagType.DefineShape3:
ParseDefineShape3Tag((DefineShape3Tag)tag);
break;
case TagType.DefineShape4:
ParseDefineShape4Tag((DefineShape4Tag)tag);
break;
case TagType.JPEGTables:
// not retained
break;
case TagType.DefineBits:
ParseDefineBits((DefineBitsTag)tag);
break;
case TagType.DefineBitsJPEG2:
ParseDefineBits((DefineBitsTag)tag);
break;
case TagType.DefineBitsJPEG3:
ParseDefineBits((DefineBitsTag)tag);
break;
case TagType.DefineBitsLossless:
ParseDefineBitsLossless((DefineBitsLosslessTag)tag);
break;
case TagType.DefineBitsLossless2:
if (!addedFullBitmap)
{
addedFullBitmap = true;
DefineBitsLosslessTag t = (DefineBitsLosslessTag)tag;
fullBitmapId = t.CharacterId;
//DefineBitsLosslessTag t = new DefineBitsLosslessTag(true);
//t.CharacterId = ot.CharacterId;
//t.BitmapFormat = ot.BitmapFormat;
t.Width = (uint)fullBitmap.Bitmap.Width;
t.Height = (uint)fullBitmap.Bitmap.Height;
t.OrgBitmapData = null;
uint pxCount = t.Width * t.Height;
RGBA[] pxs = new RGBA[pxCount];
fullBitmap.LockBitmap();
for (int i = 0; i < pxCount; i++)
{
int x = (int)(i % t.Width);
int y = (int)(Math.Floor((double)(i / t.Width)));
PixelData pd = fullBitmap.GetPixel(x, y);
pxs[i] = new RGBA(pd.red, pd.green, pd.blue, pd.alpha);
}
t.BitmapData = pxs;
fullBitmap.UnlockBitmap();
}
break;
case TagType.UnsupportedDefinition:
break;
}
}
public static string ToHtmlString(this RGBA color) => $"{color:X}";
private void UpdateCell(int row, int col)
{
var cell = Cells[row][col];
var elem = BdtBoard.GetAt(row, col);
Board.UpdateCell(row, col, (img) =>
{
img.Graphics.Clear(RGBA.White);
img.MakeTransparent(RGBA.White);
var color = RGBA.White;
switch (elem.Type)
{
case TrenElementType.City: color = RGBA.Black; break;
case TrenElementType.Track:
if (elem.InUse)
{
switch (elem.Color)
{
case TrenColor.Black: color = RGBA.Black; break;
case TrenColor.Blue: color = new RGBA()
{
B = 255, A = 255
}; break;
case TrenColor.Green: color = new RGBA()
{
G = 255, A = 255
}; break;
case TrenColor.Orange: color = new RGBA()
{
R = 255, G = 150, A = 255
}; break;
case TrenColor.Pink: color = new RGBA()
{
R = 200, G = 50, B = 50, A = 255
}; break;
case TrenColor.Red: color = new RGBA()
{
R = 255, A = 255
}; break;
case TrenColor.White: color = RGBA.White; break;
case TrenColor.Yellow: color = new RGBA()
{
R = 255, G = 255, A = 255
}; break;
default: throw new Exception("Unknown track color : " + elem.Color);
}
}
else
{
color = new RGBA()
{
R = 150, G = 150, B = 150, A = 255
}
};
break;
case TrenElementType.Button: color = RGBA.Black; break;
case TrenElementType.Destination: break;
default: throw new Exception("Unknow tren type : " + elem.Type);
}
img.Graphics.Polygon(color, cell.NormalizedPoints, fill: true, border: true);
});
}
public static unsafe UnmanagedImage GetChannelAsImage(this UnmanagedImage image, RGBA channel)
{
var c = (short)channel;
var pb = image.GetPixelFormatSizeInBytes();
if (c < 0 ||
c >= pb)
{
throw new ArgumentOutOfRangeException(nameof(c));
}
var wb = pb * image.Width;
var pad = image.Stride - wb;
var result = UnmanagedImage.Create(image.Width, image.Height, PixelFormat.Format8bppIndexed);
var d = (byte *)image.ImageData + c;
var e = (byte *)result.ImageData;
for (var dT0 = d + (image.Stride * image.Height); d < dT0; d += pad)
{
for (var dToLine = d + wb; d < dToLine; d += pb, e++)
{
*e = *d;
}
}
return(result);
}
private string GetMaxColorString(RGBA color)
{
return($"color {color.R} {color.G} {color.B} {color.A}");
}
public void Deserialize(string input)
{
string[] vals = input.Split(',');
Family = vals [0];
FontSlant slant;
if (vals.Length > 1 && Enum.TryParse <FontSlant> (vals [1], out slant))
{
Slant = slant;
}
else
{
Slant = FontSlant.Normal;
}
FontWeight weight;
if (vals.Length > 2 && Enum.TryParse <FontWeight> (vals [2], out weight))
{
Weight = weight;
}
else
{
Weight = FontWeight.Normal;
}
double scale;
if (vals.Length > 3 && double.TryParse(vals [3], out scale))
{
Scale = scale;
}
else
{
Scale = 12.0;
}
double lineSpacing;
if (vals.Length > 4 && double.TryParse(vals [4], out lineSpacing))
{
LineSpacing = lineSpacing;
}
else
{
LineSpacing = Scale / 2;
}
Color = new RGBA();
if (vals.Length > 5)
{
string[] colors = vals [5].Split('|');
byte red, green, blue;
if (byte.TryParse(colors [0], out red) &&
byte.TryParse(colors [1], out green) &&
byte.TryParse(colors [2], out blue))
{
Color = new RGBA(red, green, blue);//red, green, blue);
}
}
if (vals.Length > 6)
{
Underline = Convert.ToBoolean(vals [6]);
}
}
//public MaterialScript() { }
public MaterialScript(H3D Scene, int MdlIndex, int AnimIndex = -1) //TODO: Needs more object-oriented-ness?
{
if (MdlIndex != -1)
{
H3DModel Mdl = Scene.Models[MdlIndex];
if (Mdl.Materials.Count < 1)
{
return; //if model has no materials, abort
}
//
int stageN;
PICATexEnvStage stage;
//Initialize script Stringbuilder
script = new StringBuilder("vtxColor = VertexColor()\n");
script.Append("scriptPath = getThisScriptFilename()\nscriptPath = getFilenamePath scriptPath\n\n");
//TODO: add script path get, append it to texture files
foreach (H3DMaterial Mtl in Mdl.Materials)
{
#region >=============(Basic Material Setup)=============<
//Assign basic properties
script.Append(
$"{Mtl.Name}_mat = standardMaterial()\n"
+ $"{Mtl.Name}_mat.name = \"{Mtl.Name}_mat\"\n"
+ $"{Mtl.Name}_mat.shaderByName = \"phong\"\n"
+ $"{Mtl.Name}_mat.showInViewport = true\n"
+ $"{Mtl.Name}_mat.ambient = {GetMaxColorString(Mtl.MaterialParams.AmbientColor)}\n"
+ $"{Mtl.Name}_mat.diffuse = {GetMaxColorString(Mtl.MaterialParams.DiffuseColor)}\n" //TODO: should these colors include the alpha value?
+ $"{Mtl.Name}_mat.specular = {GetMaxColorString(Mtl.MaterialParams.Specular0Color)}\n"
+ $"{Mtl.Name}_mat.specularLevel = {Mtl.MaterialParams.Specular0Color.A/2.55d}\n"
//TODO: set 2-sidedness
+ '\n');
//create bitmap maps for textures
if (Mtl.Texture0Name != null && Mtl.Texture0Name.Length > 0)
{
script.Append(GetTextureString(Mtl, 0));
}
if (Mtl.Texture1Name != null && Mtl.Texture1Name.Length > 0)
{
script.Append(GetTextureString(Mtl, 1));
}
if (Mtl.Texture2Name != null && Mtl.Texture2Name.Length > 0)
{
script.Append(GetTextureString(Mtl, 2));
}
script.Append('\n');
//find the greatest used map channel (may be unreliable, assumes all map channels on the mesh are used by at least one texture)
maxMapChannel = 0;
for (int i = 0; i < Mtl.MaterialParams.TextureCoords.Length; i++)
{//TODO: is scale != <0,0> the best way to tell if the texture coord is used?
if (Mtl.MaterialParams.TextureSources[i] + 1 > maxMapChannel && Mtl.MaterialParams.TextureCoords[i].MappingType == H3DTextureMappingType.UvCoordinateMap && Mtl.MaterialParams.TextureCoords[i].Scale != Vector2.Zero)
{
maxMapChannel = (int)Mtl.MaterialParams.TextureSources[i] + 1;
}
}
#endregion
#region >=============(Diffuse Map Creation)=============<
//create diffuse composite map
script.Append("comp = compositeMap()\n");
//Setup diffuse map stages
stageN = 1;
for (int j = 0; j < Mtl.MaterialParams.TexEnvStages.Length; j++)
{
stage = Mtl.MaterialParams.TexEnvStages[j];
if (stage.IsColorPassThrough)
{
continue; //if passthrough stage, skip
}
if (stage.UpdateColorBuffer) //if this stage updates the color Buffer
{
script.Append("buffer = copy(comp)\n"); // store copy of composite map as "buffer"
if (stage.Source.Color[0] != PICATextureCombinerSource.Previous) // if current stage is not using previous //TODO: Check for "Previous" in 1 or 2?
{
script.Append("comp = compositeMap()\n"); // start a new composite map
stageN = 1;
}
}
//assign the stage's const color
stageColor = GetConstColor(Mtl, j);
//create layers based on combiner type //TODO: put more comments here
for (int i = 0; i < combinerTxtCount[(int)(stage.Combiner.Color)]; i++)
{
//if operand is "Previous" don't add a layer for it
if (stage.Source.Color[i] == PICATextureCombinerSource.Previous)
{
continue; //TODO: Throw exception if 1 or 2 is "Previous"?
}
if (i == 2 && stage.Combiner.Color == PICATextureCombinerMode.Interpolate) //if combiner mode is "Interpolate", assign the last source as a mask to the previous layer
{
script.Append($"comp.mask[{stageN-1}] = {GetSourceStringColor(stage, i)}\n");
}
else //otherwise add a layer for the source and set the layer's blend mode based on the stage's combiner mode
{
script.Append($"comp.mapList[{stageN}] = {GetSourceStringColor(stage, i)}\n");
script.Append($"comp.blendMode[{stageN}] = {combinerOps[(int)(stage.Combiner.Color), i]}\n");
stageN++;
}
}
}
//assign composite map to main material
script.Append($"{Mtl.Name}_mat.diffuseMap = comp\n");
#endregion
#region >=============(Alpha Map Creation)=============<
//only create/assign alpha if it's used
if (!Mtl.MaterialParams.AlphaTest.Enabled && Mtl.MaterialParams.BlendFunction.ColorDstFunc == PICABlendFunc.Zero && Mtl.MaterialParams.BlendFunction.AlphaDstFunc == PICABlendFunc.Zero)
{
//Alpha source of "DestinationColor" is a special exception
if (Mtl.MaterialParams.BlendFunction.AlphaSrcFunc == PICABlendFunc.DestinationColor)//if alpha src = DestinationColor, use vtx alpha
{
script.Append("vtxAlpha = VertexColor()\n"
+ $"vtxAlpha.map = {maxMapChannel + 1}\n"
+ "vtxAlpha.subid = 1\n");
script.Append($"{Mtl.Name}_mat.opacityMap = vtxAlpha\n");
}
script.Append("\n\n");
continue; //skip to next material
}
//reenable texture alpha if alpha test is enabled
if (Mtl.MaterialParams.AlphaTest.Enabled) //TODO: this could be better somehow
{
if (Mtl.Texture0Name != null && Mtl.Texture0Name.Length > 0)
{
script.AppendLine($"txt{0}.alphasource = 0");
}
if (Mtl.Texture1Name != null && Mtl.Texture1Name.Length > 0)
{
script.AppendLine($"txt{1}.alphasource = 0");
}
if (Mtl.Texture2Name != null && Mtl.Texture2Name.Length > 0)
{
script.AppendLine($"txt{2}.alphasource = 0");
}
script.Append('\n');
}
//create alpha composite map
script.Append("comp = compositeMap()\n");
//Setup alpha map stages
stageN = 1;
for (int j = 0; j < Mtl.MaterialParams.TexEnvStages.Length; j++)
{
stage = Mtl.MaterialParams.TexEnvStages[j];
if (stage.IsAlphaPassThrough)
{
continue; //if passthrough stage, skip
}
if (stage.UpdateAlphaBuffer) //if this stage updates the alpha Buffer
{
script.Append("buffer = copy(comp)\n"); // store copy of composite map as "buffer"
if (stage.Source.Alpha[0] != PICATextureCombinerSource.Previous) // if current stage is not using previous //TODO: Check for "Previous" in 1 or 2
{
script.Append("comp = compositeMap()\n"); // start a new composite map
stageN = 1;
}
}
//assign the stage's const color
stageColor = GetConstColor(Mtl, j);
//create layers based on combiner type
for (int i = 0; i < combinerTxtCount[(int)(stage.Combiner.Alpha)]; i++)
{
//if operand is "Previous" don't add a layer for it
if (stage.Source.Alpha[i] == PICATextureCombinerSource.Previous)
{
continue; //TODO: Throw exception if 1 or 2 is "Previous"?
}
if (i == 2 && stage.Combiner.Alpha == PICATextureCombinerMode.Interpolate) //if combiner mode is "Interpolate", assign the last source as a mask to the previous layer
{
script.Append($"comp.mask[{stageN - 1}] = {GetSourceStringAlpha(stage, i)}\n");
}
else //otherwise add a layer for the source and set the layer's blend mode based on the stage's combiner mode
{
script.Append($"comp.mapList[{stageN}] = {GetSourceStringAlpha(stage, i)}\n");
script.Append($"comp.blendMode[{stageN}] = {combinerOps[(int)(stage.Combiner.Alpha), i]}\n");
stageN++;
}
}
}
//assign composite map to main material
script.Append($"{Mtl.Name}_mat.opacityMap = comp\n");
#endregion
script.Append("\n\n");
}
//create material assignment loop
script.Append("for OBJ in Geometry do\n(\n if OBJ.material != undefined then\n (\n");
foreach (H3DMaterial Mtl in Mdl.Materials)
{
script.Append($" if OBJ.material.name == \"{Mtl.Name}_mat\" then OBJ.material = {Mtl.Name}_mat\n");
}
script.Append(" )\n)\n");
} //MdlIndex != -1
}
public void LoadBinaryData(byte[] inData)
{
using (MemoryStream ms = new MemoryStream(inData))
{
using (BinaryReader br = new BinaryReader(ms))
{
this.TextureCount = br.ReadUInt32();
this.GroupCount = br.ReadUInt32();
this.PortalCount = br.ReadUInt32();
this.LightCount = br.ReadUInt32();
this.DoodadNameCount = br.ReadUInt32();
this.DoodadDefinitionCount = br.ReadUInt32();
this.DoodadSetCount = br.ReadUInt32();
this.BaseAmbientColour = br.ReadRGBA();
this.AreaTableID = new UInt32ForeignKey("WMOAreaTable", "WMOID", br.ReadUInt32());
this.BoundingBox = br.ReadBox();
this.Flags = (RootFlags) br.ReadUInt32();
}
}
}
private void tsmiCopyRGB_Click(object sender, EventArgs e)
{
RGBA rgba = colorPicker.SelectedColor.RGBA;
ClipboardHelpers.CopyText($"{rgba.Red}, {rgba.Green}, {rgba.Blue}");
}
public static string Color(this string str, RGBA color)
{
return($"<color=#{color:X}>{str}</color>");
}
/// <summary>
/// Initializes the channel show filter.
/// </summary>
/// <param name="channel">Channel of RGBA model</param>
public ShowChannel(RGBA channel)
{
Channel = channel;
}
public void Clear(RGBA color)
{
Graphics.FillRectangle(GetCachedSolidBrush(color), 0, 0, Width, Height);
}
/// <summary>
/// Load materials in stream.
/// </summary>
/// <param name="stream">Stream to use.</param>
/// <returns>Material definitions.</returns>
public static IEnumerable <NsbmdMaterial> ReadTex0(Stream stream, int blockoffset, out int ptexnum, out int ppalnum, out List <NSBMDTexture> texs, out List <NSBMDPalette> pals)
{
EndianBinaryReader reader = new EndianBinaryReader(stream, Endianness.LittleEndian);
UInt32 blocksize, blockptr, blocklimit;
int texnum;
UInt32 texdataoffset;
int texdatasize;
UInt32 sptexoffset; // for 4x4 compressed texels only
int sptexsize; // for 4x4 compressed texels only
UInt32 spdataoffset; // for 4x4 compressed texels only
int palnum;
UInt32 paldefoffset;
UInt32 paldataoffset;
int paldatasize;
NsbmdMaterial[] material = null;
int i, j;
texs = new List <NSBMDTexture>();
pals = new List <NSBMDPalette>();
blockptr = (uint)(blockoffset + 4); // already read the block ID, so skip 4 bytes
blocksize = reader.ReadUInt32(); // block size
blocklimit = (uint)(blocksize + blockoffset);
Console.WriteLine("DEBUG: blockoffset = {0}, blocksize = {1}", blockoffset, blocksize);
stream.Skip(4); // skip 4 padding 0s
texdatasize = reader.ReadUInt16() << 3; // total texture data size div8
stream.Skip(6); // skip 6 bytes
texdataoffset = (uint)(reader.ReadUInt32() + blockoffset);
stream.Skip(4); // skip 4 padding 0s
sptexsize = reader.ReadUInt16() << 3; // for format 5 4x4-texel, data size div8
stream.Skip(6); // skip 6 bytesmhm
sptexoffset = (uint)(reader.ReadUInt32() + blockoffset); // for format 5 4x4-texel, data offset
spdataoffset = (uint)(reader.ReadUInt32() + blockoffset); // for format 5 4x4-texel, palette info
stream.Skip(4); // skip 4 bytes
paldatasize = reader.ReadUInt16() << 3; // total palette data size div8
stream.Skip(2); // skip 2 bytes
paldefoffset = (uint)(reader.ReadUInt32() + blockoffset);
paldataoffset = (uint)(reader.ReadUInt32() + blockoffset);
// printf( "texdataoffset = %08x texdatasize = %08x\n", texdataoffset, texdatasize );
// printf( "sptexoffset = %08x sptexsize = %08x spdataoffset = %08x\n", sptexoffset, sptexsize, spdataoffset );
// printf( "paldataoffset = %08x paldatasize = %08x\n", paldataoffset, paldatasize );
////////////////////////////////////////////////
// texture definition
stream.Skip(1); // skip dummy '0'
texnum = reader.ReadByte(); // no of texture
blockptr = (uint)stream.Position;
stream.Seek(paldefoffset, SeekOrigin.Begin);
stream.Skip(1); // skip dummy '0'
palnum = reader.ReadByte(); // no of palette
stream.Seek(blockptr, SeekOrigin.Begin);
Console.WriteLine("texnum = {0}, palnum = {1}", texnum, palnum);
// allocate memory for material, great enough to hold all texture and palette
material = new NsbmdMaterial[(texnum > palnum ? texnum : palnum)];
for (i = 0; i < material.Length; i++)
{
material[i] = new NsbmdMaterial();
}
stream.Skip(14 + (texnum * 4)); // go straight to texture info
for (i = 0; i < texnum; i++)
{
UInt32 offset;
int param;
int format;
int width;
int height;
var mat = material[i];
offset = (uint)(reader.ReadUInt16() << 3);
param = reader.ReadUInt16(); // texture parameter
stream.Skip(4); // skip 4 bytes
format = (param >> 10) & 7; // format 0..7, see DSTek
width = 8 << ((param >> 4) & 7);
height = 8 << ((param >> 7) & 7);
mat.color0 = (param >> 13) & 1;
if (format == 5)
{
mat.texoffset = offset + sptexoffset; // 4x4-Texel Compressed Texture
}
else
{
mat.texoffset = offset + texdataoffset;
}
mat.format = format;
mat.width = width;
mat.height = height;
NSBMDTexture t = new NSBMDTexture();
t.format = format;
t.width = width;
t.height = height;
t.color0 = (param >> 13) & 1;
texs.Add(t);
}
////////////////////////////////////////////
// copy texture names
for (i = 0; i < texnum; i++)
{
material[i].texname = Utils.ReadNSBMDString(reader);
reader.BaseStream.Position -= 16;
texs[i].texname = Utils.ReadNSBMDString(reader);
}
////////////////////////////////////////////////
// calculate each texture's size
for (i = 0; i < texnum; i++)
{
int[] bpp = { 0, 8, 2, 4, 8, 2, 8, 16 };
var mat = material[i];
mat.texsize = (uint)(mat.width * mat.height * bpp[mat.format] / 8);
Console.WriteLine("tex {0} '{1}': offset = {2} size = {3} [W,H] = [{4}, {5}]",
i, mat.texname, mat.texoffset, mat.texsize, mat.width, mat.height);
texs[i].texsize = (uint)(mat.width * mat.height * bpp[mat.format] / 8);
}
////////////////////////////////////////////////
// palette definition
stream.Seek(paldefoffset + 2, SeekOrigin.Begin); // skip palnum, already read
stream.Seek(14 + (palnum * 4), SeekOrigin.Current); // go straight to palette info
for (i = 0; i < palnum; i++)
{
uint curOffset = (uint)((reader.ReadUInt16() << 3) + paldataoffset);
stream.Seek(2, SeekOrigin.Current); // skip 2 bytes
material[i].paloffset = curOffset;
NSBMDPalette t = new NSBMDPalette();
t.paloffset = curOffset;
pals.Add(t);
}
////////////////////////////////////////////////
// copy palette names
for (i = 0; i < palnum; i++)
{
var mat = material[i];
mat.palname = Utils.ReadNSBMDString(reader);
reader.BaseStream.Position -= 16;
pals[i].palname = Utils.ReadNSBMDString(reader);
}
////////////////////////////////////////////////
// calculate each palette's size
// assume the palettes are stored sequentially
/*for (i = 0; i < palnum - 1; i++)
* {
* int r;
* var mat = material[i];
* r = i;
* try { while (material[r].paloffset == mat.paloffset) r++; }
* catch { }
* // below is RotA stupid way to calculate the size of palette: next's offset - current's offset
* // it works most of the time
* if (r != palnum)
* {
* mat.palsize = material[r].paloffset - mat.paloffset;
* pals[i].palsize = material[r].paloffset - mat.paloffset;
* }
* else
* {
* mat.palsize = blocklimit - mat.paloffset;
* pals[i].palsize = blocklimit - mat.paloffset;
* }
* //printf("pal '%s' size = %d\n", mat->palname, mat->palsize);
* }
* material[i].palsize = blocklimit - material[i].paloffset;
* pals[i].palsize = blocklimit - material[i].paloffset;*/
List <int> offsets = new List <int>();
for (int k = 0; k < pals.Count; k++)
{
if (!offsets.Contains((int)pals[k].paloffset))
{
offsets.Add((int)pals[k].paloffset);
}
}
offsets.Add((int)blocklimit);
offsets.Sort();
for (int k = 0; k < pals.Count; k++)
{
int pallength;
int l = -1;
do
{
l++;
}while (offsets[l] - pals[k].paloffset <= 0);//nsbtx.PalInfo.infoBlock.PalInfo[i + j].Palette_Offset - nsbtx.PalInfo.infoBlock.PalInfo[i].Palette_Offset == 0)
pallength = offsets[l] - (int)pals[k].paloffset;
//RGBA[] c_ = pals[k].paldata;
//List<RGBA> c = new List<RGBA>();
//c.AddRange(pals[k].paldata.Take(pallength / 2));
//pals[k].paldata = c.ToArray();
pals[k].palsize = (uint)pallength;
material[k].palsize = (uint)pallength;
}
////////////////////////////////////////////////
// traverse each texture
for (i = 0; i < texnum; i++)
{
var mat = material[i];
stream.Seek(mat.texoffset, SeekOrigin.Begin);
////////////////////////////////////////////////
// read texture into memory
byte[] by = reader.ReadBytes((int)mat.texsize);
mat.texdata = by;
texs[i].texdata = by;
Console.WriteLine("DEBUG: texoffset = {0}, texsize = {1}", mat.texoffset, mat.texsize);
////////////////////////////////////////////////
// additional data for format 5 4x4 compressed texels
if (mat.format == 5)
{
UInt32 r = mat.texsize / 2;//>> 1;
stream.Seek(spdataoffset + (mat.texoffset - sptexoffset) / 2, SeekOrigin.Begin);
by = reader.ReadBytes((int)r);
mat.spdata = by;
texs[i].spdata = by;
Console.WriteLine("DEBUG: 4x4-texel spdataoffset = {0}, spdatasize = {1}", spdataoffset, r);
//spdataoffset += r;
}
}
////////////////////////////////////////////////
// traverse each palette
for (i = 0; i < palnum; i++)
{
try
{
NsbmdMaterial mat = material[i];
var palentry = mat.palsize >> 1;
RGBA[] rgbq = new RGBA[palentry];
Console.WriteLine("DEBUG: converting pal '{0}', palentry = {1}", mat.palname, palentry);
stream.Seek(mat.paloffset, SeekOrigin.Begin);
for (j = 0; j < palentry; j++)
{
UInt16 p = reader.ReadUInt16();
rgbq[j].R = (byte)(((p >> 0) & 0x1f) << 3); // red
rgbq[j].G = (byte)(((p >> 5) & 0x1f) << 3); // green
rgbq[j].B = (byte)(((p >> 10) & 0x1f) << 3); // blue
//rgbq[j].RotA = (p&0x8000) ? 0xff : 0;
rgbq[j].A = (p & 0x8000) == 0 ? (byte)0xff : (byte)0; //0xff; // alpha
}
mat.paldata = rgbq;
pals[i].paldata = rgbq;
}
catch
{
}
}
ptexnum = texnum;
ppalnum = palnum;
return(material);
}
/// <summary>
/// Instantitates a blank window for your use.
/// </summary>
public Windowstyle()
{
_version = 2;
for (int i = 0; i < _edgeColors.Length; ++i) _edgeColors[i] = new RGBA();
for (int i = 0; i < _images.Length; ++i) _images[i] = new Bitmap(16, 16, PixelFormat.Format32bppPArgb);
}
public override string ToString()
{
return(RGBA.ToString("X8"));
}
public async void Clear(RGBA color)
{
await Surface.SetFillStyleAsync(ColorCache(color));
await Surface.FillRectAsync(x : 0, y : 0, Width, Height);
}
private SPICA.Math3D.RGBA ConvertRGBA(RGBA color)
{
return(new SPICA.Math3D.RGBA(color.R, color.G, color.B, color.A));
}
public ModelMaterial(byte[] inData)
{
using (MemoryStream ms = new MemoryStream(inData))
{
using (BinaryReader br = new BinaryReader(ms))
{
this.Flags = (MaterialFlags) br.ReadUInt32();
this.Shader = (ShaderTypes) br.ReadUInt32();
this.BlendMode = (BlendingMode) br.ReadUInt32();
this.FirstTextureOffset = br.ReadUInt32();
this.FirstColour = br.ReadRGBA();
this.FirstFlags = (MaterialFlags)br.ReadUInt32();
this.SecondTextureOffset = br.ReadUInt32();
this.SecondColour = br.ReadRGBA();
this.GroundType = new UInt32ForeignKey("TerrainType", "ID", br.ReadUInt32());
this.ThirdTextureOffset = br.ReadUInt32();
this.BaseDiffuseColour = br.ReadRGBA();
this.ThirdFlags = (MaterialFlags)br.ReadUInt32();
this.RuntimeData1 = br.ReadUInt32();
this.RuntimeData2 = br.ReadUInt32();
this.RuntimeData3 = br.ReadUInt32();
this.RuntimeData4 = br.ReadUInt32();
}
}
}
private void ReadFromFile(string filename)
{
if (!File.Exists(filename))
throw new FileNotFoundException();
using (BinaryReader reader = new BinaryReader(File.OpenRead(filename)))
{
if (!new String(reader.ReadChars(4)).Equals(".rws"))
throw new WindowStyleException(filename, "Invalid file header.");
_version = reader.ReadInt16();
_edgeWidth = reader.ReadByte();
_backgroundMode = reader.ReadByte();
for (int i = 0; i < _edgeColors.Length; ++i) {
_edgeColors[i] = new RGBA(reader);
}
_edgeOffsets = reader.ReadBytes(4);
reader.ReadBytes(36); // reserved
switch (_version)
{
case 2:
Image[] images = new Image[4];
for (int i = 0; i < 9; ++i)
{
int width = reader.ReadInt16();
int height = reader.ReadInt16();
if (i < 7 && i % 2 == 0)
images[i / 2] = new Image((uint)width, (uint)height, reader.ReadBytes(width * height * 4));
else
{
int index = (i == 8 ? i : i - 1) / 2;
_textures[index] = new Texture((uint)width, (uint)height);
_textures[index].Update(reader.ReadBytes(width * height * 4));
_sprites[index] = new Sprite(_textures[index]);
_textures[index].Repeated = true;
}
}
_atlas.Update(images);
break;
}
}
}
