private static void SaveTile(StyleData styleData, ZipStorer zip, ref int id)
{
using (var bmp = new Bitmap(64, 64))
{
var bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
var stride = bmData.Stride;
var scan0 = bmData.Scan0;
unsafe
{
var p = (byte *)(void *)scan0;
var nOffset = stride - bmp.Width * 4;
for (var y = 0; y < bmp.Height; ++y)
{
for (var x = 0; x < bmp.Width; ++x)
{
uint tileColor = styleData.TileData[(y + (id / 4) * 64) * 256 + (x + (id % 4) * 64)];
var palId = (styleData.PaletteIndexes[id] / 64) * 256 * 64 + (styleData.PaletteIndexes[id] % 64) + tileColor * 64;
var paletteIndex = palId % 64;
p[0] = styleData.Palettes[paletteIndex].Colors[tileColor].B;
p[1] = styleData.Palettes[paletteIndex].Colors[tileColor].G;
p[2] = styleData.Palettes[paletteIndex].Colors[tileColor].R;
p[3] = tileColor > 0 ? (byte)255 : (byte)0;
p += 4;
}
p += nOffset;
}
}
bmp.UnlockBits(bmData);
var memoryStream = new MemoryStream();
bmp.Save(memoryStream, ImageFormat.Png);
memoryStream.Position = 0;
zip.AddStream(ZipStorer.Compression.Deflate, id + Globals.TextureImageFormat, memoryStream, styleData.OriginalDateTime, string.Empty);
memoryStream.Close();
}
}
public void Parse(string text, StyleData expected)
{
var result = StyleData.Parse(text);
Check.That(result).IsEqualTo(expected);
}
private void UpdateData()
{
TextData textData = MultiLanguageSystem.Instance.GetTextData(ID);
if (textData.Equals(default(TextData)))
{
Debug.LogError("未获取到正确数据id为：" + ID);
return;
}
_text.text = textData.Content;
StyleData styleData = MultiLanguageSystem.Instance.GetStyleData(textData.Style);
if (styleData.Equals(default(StyleData)))
{
Debug.LogError("未获取到正确风格数据，风格名称为：" + textData.Style);
return;
}
_text.font = LoadFont(styleData.Font);
_text.fontStyle = GetFontStyle(styleData.FontStyle);
_text.fontSize = styleData.Size;
_text.supportRichText = styleData.RichText;
_text.color = new Color32(styleData.r, styleData.g, styleData.b, styleData.a);
}
/// <summary>
/// 读取字体样式数据
/// </summary>
/// <param name="path"></param>
void ReadStyleConfit(string path)
{
using (var steam = new FileStream(path, FileMode.Open, FileAccess.Read))
{
using (var reader = new BinaryReader(steam))
{
int count = int.Parse(reader.ReadString());
StyleData data = new StyleData();
string styleName = "";
for (int i = 0; i < count; i++)
{
styleName = reader.ReadString();
data.Font = reader.ReadString();
data.FontStyle = reader.ReadString();
data.Size = int.Parse(reader.ReadString());
data.RichText = reader.ReadString().Contains("True");
data.r = byte.Parse(reader.ReadString());
data.g = byte.Parse(reader.ReadString());
data.b = byte.Parse(reader.ReadString());
data.a = byte.Parse(reader.ReadString());
_styleData.Add(styleName, data);
}
}
}
}
private static void SaveSprites(StyleData styleData, ZipStorer zip, CancellableContext context)
{
//cars
for (var i = styleData.SpriteBase.Car; i < styleData.SpriteBase.Ped; i++)
{
if (context.IsCancelling)
{
return;
}
SaveCarSprite(styleData, zip, i);
}
for (var i = styleData.SpriteBase.Ped; i < styleData.SpriteBase.CodeObj; i++)
{
var basePalette = styleData.PaletteIndexes[styleData.PaletteBase.Tile + i];
SaveSpriteRemap(styleData, styleData.SpriteEntries[i], basePalette, zip, "Peds/" + i);
//var pedRemaps = new List<Remap>(53); //Ped Remaps are still broken...
//for (var j = 0; j < 53; j++)
//{
// var remapPalette = styleData.PaletteIndexes[styleData.PaletteBase.Tile + styleData.PaletteBase.Sprite + styleData.PaletteBase.CarRemap + j]; //...probably the bug lays here
// pedRemaps.Add(new PedestrianRemap(j, remapPalette));
//}
//styleData.Sprites.Add(i, new SpriteItem(SpriteType.Pedestrian, basePalette, pedRemaps));
styleData.Sprites.Add(i, new SpriteItem(SpriteType.Pedestrian, basePalette));
}
//Code Obj
for (var i = styleData.SpriteBase.CodeObj; i < styleData.SpriteBase.MapObj; i++)
{
var basePalette = styleData.PaletteIndexes[styleData.PaletteBase.Tile + i];
SaveSpriteRemap(styleData, styleData.SpriteEntries[i], basePalette, zip, "CodeObj/" + i);
styleData.Sprites.Add(i, new SpriteItem(SpriteType.CodeObject, basePalette));
}
//Map obj
for (var i = styleData.SpriteBase.MapObj; i < styleData.SpriteBase.User; i++)
{
var basePalette = styleData.PaletteIndexes[styleData.PaletteBase.Tile + i];
SaveSpriteRemap(styleData, styleData.SpriteEntries[i], basePalette, zip, "MapObj/" + i);
styleData.Sprites.Add(i, new SpriteItem(SpriteType.MapObject, basePalette));
}
//User
for (var i = styleData.SpriteBase.User; i < styleData.SpriteBase.Font; i++)
{
var basePalette = styleData.PaletteIndexes[styleData.PaletteBase.Tile + i];
SaveSpriteRemap(styleData, styleData.SpriteEntries[i], basePalette, zip, "User/" + i);
styleData.Sprites.Add(i, new SpriteItem(SpriteType.User, basePalette));
}
//Font //Some fonts looks wrong...
for (var i = styleData.SpriteBase.Font; i < styleData.SpriteEntries.Length; i++)
{
var basePalette = styleData.PaletteIndexes[styleData.PaletteBase.Tile + i];
SaveSpriteRemap(styleData, styleData.SpriteEntries[i], basePalette, zip, "Font/" + i);
styleData.Sprites.Add(i, new SpriteItem(SpriteType.Font, basePalette));
}
}
void OnEnable()
{
for (int i = 0; i < styleSheet.Count; i++)
{
StyleData data = styleSheet[i];
if (!string.IsNullOrEmpty(data.name))
{
_map.Add(data.name, data);
}
}
}
private static void SaveDelta(StyleData styleData, int spriteId, uint palette, uint deltaId, ZipStorer zip, string fileName)
{
var offset = 0;
foreach (var deltaIndex in styleData.DeltaIndexes)
{
if (deltaIndex.Sprite == spriteId)
{
var spriteEntry = styleData.SpriteEntries[spriteId];
if (deltaIndex.DeltaSize.Count > 0)
{
for (var i = 0; i < deltaId; i++)
{
offset += deltaIndex.DeltaSize[i];
}
using (var bmp = new Bitmap(spriteEntry.Width, spriteEntry.Height))
{
var pos = 0;
var recordLen = 0;
var deltaLen = offset + deltaIndex.DeltaSize[(int)deltaId];
while (offset < deltaLen)
{
pos = BitConverter.ToUInt16(styleData.DeltaData, offset) + pos + recordLen;
var x = pos % 256;
var y = pos / 256;
offset += 2;
recordLen = styleData.DeltaData[offset];
offset++;
for (var i = 0; i < recordLen; i++)
{
var color = styleData.Palettes[palette].Colors[styleData.DeltaData[offset]];
var imagePosX = x + i;
var imagePosY = y;
bmp.SetPixel(imagePosX, imagePosY, Color.FromArgb(255, color.R, color.G, color.B));
offset++;
}
}
var memoryStream = new MemoryStream();
bmp.Save(memoryStream, ImageFormat.Png);
memoryStream.Position = 0;
zip.AddStream(ZipStorer.Compression.Deflate, fileName + Globals.TextureImageFormat, memoryStream, styleData.OriginalDateTime, string.Empty);
memoryStream.Close();
}
}
}
else
{
offset += deltaIndex.DeltaSize.Sum();
}
}
}
private static void SaveTiles(StyleData styleData, ZipStorer zip, CancellableContext context)
{
var tilesCount = styleData.TileData.Length / (64 * 64);
for (var i = 0; i < tilesCount; i++)
{
if (context.IsCancelling)
{
return;
}
SaveTile(styleData, zip, ref i);
}
}
public bool ApplyStyleDataToTarget(BaseStyleElement p_target, StyleData p_styleData)
{
if (p_target != null)
{
var v_template = p_styleData != null ? p_styleData.Asset : null;
if (v_template != null)
{
var v_excludedElementsList = new List <string>(p_target.DisabledFieldStyles);
v_excludedElementsList.AddRange(v_template.DisabledFieldStyles);
return(ApplyTemplateToTarget(p_target, v_template, v_excludedElementsList));
}
}
return(false);
}
private static void SaveCarSprite(StyleData styleData, ZipStorer zip, int spriteId)
{
var basePalette = styleData.PaletteIndexes[styleData.PaletteBase.Tile + spriteId];
var spriteEntry = styleData.SpriteEntries[spriteId];
SaveSpriteRemap(styleData, spriteEntry, basePalette, zip, "Cars/" + spriteId);
var reMaplist = new List <Remap>();
for (var i = 0; i < styleData.CarSprites[spriteId].Count; i++)
{
reMaplist.AddRange(styleData.CarInfo[styleData.CarSprites[spriteId][i]].RemapList.Select(remapKey => new Remap(remapKey, styleData.PaletteIndexes[styleData.PaletteBase.Tile + styleData.PaletteBase.Sprite + remapKey])));
}
styleData.Sprites.Add(spriteId, new SpriteItem(SpriteType.Car, basePalette, reMaplist));
}
//Save style data as asset
private void SaveStyleTransferDataAsAsset()
{
StyleData dst = ScriptableObject.CreateInstance <StyleData>();
for (int i = 0; i < predictionAlphasBetasData.Count; ++i)
{
var sData = new StyleDataLayer();
sData.data = (float[])predictionAlphasBetasData[i].Clone();
dst.layerData.Add(sData);
}
string fileName = GetStyleResourceName() + ".asset";
string dataPath = "Assets/BarracudaStyleTransfer/Resources/" + fileName;
if (AssetDatabase.FindAssets(fileName).Length == 0)
{
AssetDatabase.CreateAsset(dst, dataPath);
}
}
static void AddStyleData(AssembledStyles styles, ref int id, Dictionary <string, int> fonts,
Dictionary <Color, int> colors, Dictionary <Tuple <string, int>, StyleData> styleTable)
{
var ss = styles.Stylesheet;
if (ss == null)
{
return; // Can't do anything useful with styles.
}
var styleName = styles.StyleName;
if (string.IsNullOrEmpty(styleName))
{
return; // no style info.
}
var ws = styles.Ws;
var key = new Tuple <string, int>(styleName, ws);
if (styleTable.ContainsKey(key))
{
return; // already know all we need.
}
var data = new StyleData {
Name = styleName, Id = id++
};
styleTable[key] = data;
var style = ss.Style(styleName);
if (style == null)
{
data.StyleTableFormatting = ""; // Todo: some minimal definition with at least the name
data.DataFormatting = "";
}
// Todo: if style has any overrides for ws, make a distinct style name.
var rtfStyle = new RtfStyle(style, ws)
{
StyleNumber = data.Id, Fonts = fonts, Colors = colors
};
data.StyleTableFormatting = rtfStyle.ToString(styleName, true);
data.DataFormatting = rtfStyle.ToString(styleName, false);
}
private static void SaveDeltas(StyleData styleData, ZipStorer zip, CancellableContext context)
{
for (var i = 0; i < styleData.DeltaIndexes.Length; i++)
{
var basePalette = styleData.PaletteIndexes[styleData.PaletteBase.Tile + styleData.DeltaIndexes[i].Sprite];
var deltaItem = new DeltaItem();
styleData.Deltas.Add(styleData.DeltaIndexes[i].Sprite, deltaItem);
for (uint j = 0; j < styleData.DeltaIndexes[i].DeltaSize.Count; j++)
{
if (context.IsCancelling)
{
return;
}
SaveDelta(styleData, styleData.DeltaIndexes[i].Sprite, basePalette, j, zip, styleData.DeltaIndexes[i].Sprite + "_" + j);
var spriteEntry = styleData.SpriteEntries[i];
deltaItem.SubItems.Add(new DeltaSubItem((DeltaType)j, spriteEntry.Width, spriteEntry.Height));
}
}
}
private static void SaveSpriteRemap(StyleData styleData, SpriteEntry spriteEntry, uint palette, ZipStorer zip, string fileName)
{
using (var bmp = new Bitmap(spriteEntry.Width, spriteEntry.Height))
{
var baseX = (int)(spriteEntry.Ptr % 256);
var baseY = (int)(spriteEntry.Ptr / 256);
var bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
var stride = bmData.Stride;
var scan0 = bmData.Scan0;
unsafe
{
var p = (byte *)(void *)scan0;
var nOffset = stride - bmp.Width * 4;
for (var y = 0; y < bmp.Height; ++y)
{
for (var x = 0; x < bmp.Width; ++x)
{
uint spriteColor = styleData.SpriteData[(baseX + x) + (baseY + y) * 256];
//var palId = (palette / 64) * 256 * 64 + (palette % 64) + spriteColor * 64;
p[0] = styleData.Palettes[palette].Colors[spriteColor].B;
p[1] = styleData.Palettes[palette].Colors[spriteColor].G;
p[2] = styleData.Palettes[palette].Colors[spriteColor].R;
p[3] = spriteColor > 0 ? (byte)255 : (byte)0;
p += 4;
}
p += nOffset;
}
}
bmp.UnlockBits(bmData);
var memoryStream = new MemoryStream();
bmp.Save(memoryStream, ImageFormat.Png);
memoryStream.Position = 0;
zip.AddStream(ZipStorer.Compression.Deflate, fileName + Globals.TextureImageFormat, memoryStream, styleData.OriginalDateTime, string.Empty);
memoryStream.Close();
}
}
public void Parse(string text, StyleData expected)
{
var result = StyleData.Parse(text);
Check.That(result).IsEqualTo(expected);
}
private void PrepareStylePrediction()
{
//Try to load style tensors from disk first
StyleData loadedData = Resources.Load <StyleData>(GetStyleResourceName());
if (loadedData)
{
predictionAlphasBetasData = new List <float[]>();
for (int i = 0; i < loadedData.layerData.Count; i++)
{
predictionAlphasBetasData.Add(loadedData.layerData[i].data);
}
Resources.UnloadAsset(loadedData);
return;
}
//Tensors not found on disk, compute them (and eventually store them on disk)
Model tempModel = ModelLoader.Load(nnModel, verbose);
List <Layer> predictionAlphasBetas = new List <Layer>();
List <Layer> layerList = new List <Layer>(tempModel.layers);
// Remove Divide by 255, Unity textures are in [0, 1] already
int firstDivide = FindLayerIndexByName(layerList, "Style_Prediction_Network/normalized_image");
layerList[firstDivide + 1].inputs[0] = layerList[firstDivide].inputs[0];
layerList.RemoveAt(firstDivide);
// Pre-process network to get it to run and extract Style alpha/beta tensors
Layer lastConv = null;
for (int i = 0; i < layerList.Count; i++)
{
Layer layer = layerList[i];
// Remove Mirror padding layers (not supported, TODO)
if (layer.name.Contains("reflect_padding"))
{
layerList[i + 1].inputs = layer.inputs;
layerList[i + 1].pad = layer.pad.ToArray();
layerList.RemoveAt(i);
i--;
continue;
}
// Placeholder instance norm bias + scale tensors
if (layer.type == Layer.Type.Conv2D || layer.type == Layer.Type.Conv2DTrans)
{
lastConv = layer;
}
else if (layer.type == Layer.Type.Normalization)
{
int channels = lastConv.datasets[1].shape.channels;
layer.datasets = new Layer.DataSet[2];
layer.datasets[0].shape = new TensorShape(1, 1, 1, channels);
layer.datasets[0].offset = 0;
layer.datasets[0].length = channels;
layer.datasets[1].shape = new TensorShape(1, 1, 1, channels);
layer.datasets[1].offset = channels;
layer.datasets[1].length = channels;
float[] data = new float[channels * 2];
for (int j = 0; j < data.Length / 2; j++)
{
data[j] = 1.0f;
}
for (int j = data.Length / 2; j < data.Length; j++)
{
data[j] = 0.0f;
}
layer.weights = data;
}
if (layer.type != Layer.Type.StridedSlice && layer.name.Contains("StyleNetwork/"))
{
layerList.RemoveAt(i);
i--;
}
if (layer.type == Layer.Type.StridedSlice)
{
predictionAlphasBetas.Add(layer);
}
}
tempModel.layers = layerList;
// Run Style_Prediction_Network on given style
styleInput = new Tensor(StyleImage);
CustomPinTensorFromTexture(styleInput);
Dictionary <string, Tensor> temp = new Dictionary <string, Tensor>();
temp.Add("frame", styleInput);
temp.Add("style", styleInput);
IWorker tempWorker = WorkerFactory.CreateWorker(WorkerFactory.ValidateType(internalSetup.workerType), tempModel, verbose);
tempWorker.Execute(temp);
// Store alpha/beta tensors from Style_Prediction_Network to feed into the run-time network
predictionAlphasBetasData = new List <float[]>();
for (int i = 0; i < predictionAlphasBetas.Count; i++)
{
Tensor O = tempWorker.PeekOutput(predictionAlphasBetas[i].name);
predictionAlphasBetasData.Add(new float[O.length]);
for (int j = 0; j < O.length; j++)
{
predictionAlphasBetasData[i][j] = O[j];
}
O.Dispose();
}
tempWorker.Dispose();
#if UNITY_EDITOR
//Store to disk
if (internalSetup.shouldSaveStyleTransferDataAsAsset)
{
SaveStyleTransferDataAsAsset();
}
#endif
}
private static unsafe List<ArraySegment<byte>> GetStyledSegments(Scintilla scintilla, bool currentSelection, bool currentLine, int startBytePos, int endBytePos, out StyleData[] styles)
{
var segments = new List<ArraySegment<byte>>();
if (currentSelection)
{
// Get each selection as a segment.
// Rectangular selections are ordered top to bottom and have line breaks appended.
var ranges = new List<Tuple<int, int>>();
var selCount = scintilla.DirectMessage(NativeMethods.SCI_GETSELECTIONS).ToInt32();
for (int i = 0; i < selCount; i++)
{
var selStartBytePos = scintilla.DirectMessage(NativeMethods.SCI_GETSELECTIONNSTART, new IntPtr(i)).ToInt32();
var selEndBytePos = scintilla.DirectMessage(NativeMethods.SCI_GETSELECTIONNEND, new IntPtr(i)).ToInt32();
ranges.Add(Tuple.Create(selStartBytePos, selEndBytePos));
}
var selIsRect = scintilla.DirectMessage(NativeMethods.SCI_SELECTIONISRECTANGLE) != IntPtr.Zero;
if (selIsRect)
ranges.OrderBy(r => r.Item1); // Sort top to bottom
foreach (var range in ranges)
{
var styledText = GetStyledText(scintilla, range.Item1, range.Item2, selIsRect);
segments.Add(styledText);
}
}
else if (currentLine)
{
// Get the current line
var mainSelection = scintilla.DirectMessage(NativeMethods.SCI_GETMAINSELECTION).ToInt32();
var mainCaretPos = scintilla.DirectMessage(NativeMethods.SCI_GETSELECTIONNCARET, new IntPtr(mainSelection)).ToInt32();
var lineIndex = scintilla.DirectMessage(NativeMethods.SCI_LINEFROMPOSITION, new IntPtr(mainCaretPos)).ToInt32();
var lineStartBytePos = scintilla.DirectMessage(NativeMethods.SCI_POSITIONFROMLINE, new IntPtr(lineIndex)).ToInt32();
var lineLength = scintilla.DirectMessage(NativeMethods.SCI_POSITIONFROMLINE, new IntPtr(lineIndex)).ToInt32();
var styledText = GetStyledText(scintilla, lineStartBytePos, (lineStartBytePos + lineLength), false);
segments.Add(styledText);
}
else // User-specified range
{
Debug.Assert(startBytePos != endBytePos);
var styledText = GetStyledText(scintilla, startBytePos, endBytePos, false);
segments.Add(styledText);
}
// Build a list of (used) styles
styles = new StyleData[NativeMethods.STYLE_MAX + 1];
styles[Style.Default].Used = true;
styles[Style.Default].FontName = scintilla.Styles[Style.Default].Font;
styles[Style.Default].SizeF = scintilla.Styles[Style.Default].SizeF;
styles[Style.Default].Weight = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETWEIGHT, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].Italic = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETITALIC, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].Underline = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETUNDERLINE, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].BackColor = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETBACK, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].ForeColor = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETFORE, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].Case = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETCASE, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].Visible = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETVISIBLE, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
foreach (var seg in segments)
{
for (int i = 0; i < seg.Count; i += 2)
{
var style = seg.Array[i + 1];
if (!styles[style].Used)
{
styles[style].Used = true;
styles[style].FontName = scintilla.Styles[style].Font;
styles[style].SizeF = scintilla.Styles[style].SizeF;
styles[style].Weight = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETWEIGHT, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].Italic = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETITALIC, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].Underline = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETUNDERLINE, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].BackColor = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETBACK, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].ForeColor = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETFORE, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].Case = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETCASE, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].Visible = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETVISIBLE, new IntPtr(style), IntPtr.Zero).ToInt32();
}
}
}
return segments;
}
private static unsafe void CopyRtf(Scintilla scintilla, StyleData[] styles, List<ArraySegment<byte>> styledSegments)
{
// NppExport -> NppExport.cpp
// NppExport -> RTFExporter.cpp
// http://en.wikipedia.org/wiki/Rich_Text_Format
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms649013.aspx
// http://forums.codeguru.com/showthread.php?242982-Converting-pixels-to-twips
// http://en.wikipedia.org/wiki/UTF-8
try
{
// Calculate twips per space
int twips;
var fontStyle = FontStyle.Regular;
if (styles[Style.Default].Weight >= 700)
fontStyle |= FontStyle.Bold;
if (styles[Style.Default].Italic != 0)
fontStyle |= FontStyle.Italic;
if (styles[Style.Default].Underline != 0)
fontStyle |= FontStyle.Underline;
using (var graphics = scintilla.CreateGraphics())
using (var font = new Font(styles[Style.Default].FontName, styles[Style.Default].SizeF, fontStyle))
{
var width = graphics.MeasureString(" ", font).Width;
twips = (int)((width / graphics.DpiX) * 1440);
// TODO The twips value calculated seems too small on my computer
}
// Write RTF
using (var ms = new NativeMemoryStream(styledSegments.Sum(s => s.Count)))
using (var tw = new StreamWriter(ms, Encoding.ASCII))
{
var tabWidth = scintilla.DirectMessage(NativeMethods.SCI_GETTABWIDTH).ToInt32();
var deftab = tabWidth * twips;
tw.WriteLine(@"{{\rtf1\ansi\deff0\deftab{0}", deftab);
tw.Flush();
// Build the font table
tw.Write(@"{\fonttbl");
tw.Write(@"{{\f0 {0};}}", styles[Style.Default].FontName);
var fontIndex = 1;
for (int i = 0; i < styles.Length; i++)
{
if (!styles[i].Used)
continue;
if (i == Style.Default)
continue;
// Not a completely unique list, but close enough
if (styles[i].FontName != styles[Style.Default].FontName)
{
styles[i].FontIndex = fontIndex++;
tw.Write(@"{{\f{0} {1};}}", styles[i].FontIndex, styles[i].FontName);
}
}
tw.WriteLine("}"); // fonttbl
tw.Flush();
// Build the color table
tw.Write(@"{\colortbl");
tw.Write(@"\red{0}\green{1}\blue{2};", (styles[Style.Default].ForeColor >> 0) & 0xFF, (styles[Style.Default].ForeColor >> 8) & 0xFF, (styles[Style.Default].ForeColor >> 16) & 0xFF);
tw.Write(@"\red{0}\green{1}\blue{2};", (styles[Style.Default].BackColor >> 0) & 0xFF, (styles[Style.Default].BackColor >> 8) & 0xFF, (styles[Style.Default].BackColor >> 16) & 0xFF);
styles[Style.Default].ForeColorIndex = 0;
styles[Style.Default].BackColorIndex = 1;
var colorIndex = 2;
for (int i = 0; i < styles.Length; i++)
{
if (!styles[i].Used)
continue;
if (i == Style.Default)
continue;
// Not a completely unique list, but close enough
if (styles[i].ForeColor != styles[Style.Default].ForeColor)
{
styles[i].ForeColorIndex = colorIndex++;
tw.Write(@"\red{0}\green{1}\blue{2};", (styles[i].ForeColor >> 0) & 0xFF, (styles[i].ForeColor >> 8) & 0xFF, (styles[i].ForeColor >> 16) & 0xFF);
}
else
{
styles[i].ForeColorIndex = styles[Style.Default].ForeColorIndex;
}
if (styles[i].BackColor != styles[Style.Default].BackColor)
{
styles[i].BackColorIndex = colorIndex++;
tw.Write(@"\red{0}\green{1}\blue{2};", (styles[i].BackColor >> 0) & 0xFF, (styles[i].BackColor >> 8) & 0xFF, (styles[i].BackColor >> 16) & 0xFF);
}
else
{
styles[i].BackColorIndex = styles[Style.Default].BackColorIndex;
}
}
tw.WriteLine("}"); // colortbl
tw.Flush();
// Start with the default style
tw.Write(@"\f{0}\fs{1}\cf{2}\chshdng0\chcbpat{3}\cb{3} ", styles[Style.Default].FontIndex, (int)(styles[Style.Default].SizeF * 2), styles[Style.Default].ForeColorIndex, styles[Style.Default].BackColorIndex);
if (styles[Style.Default].Italic != 0)
tw.Write(@"\i");
if (styles[Style.Default].Underline != 0)
tw.Write(@"\ul");
if (styles[Style.Default].Weight >= 700)
tw.Write(@"\b");
tw.AutoFlush = true;
var lastStyle = Style.Default;
var unicodeLineEndings = ((scintilla.DirectMessage(NativeMethods.SCI_GETLINEENDTYPESACTIVE).ToInt32() & NativeMethods.SC_LINE_END_TYPE_UNICODE) > 0);
foreach (var seg in styledSegments)
{
var endOffset = seg.Offset + seg.Count;
for (int i = seg.Offset; i < endOffset; i += 2)
{
var ch = seg.Array[i];
var style = seg.Array[i + 1];
if (lastStyle != style)
{
// Change the style
if (styles[lastStyle].FontIndex != styles[style].FontIndex)
tw.Write(@"\f{0}", styles[style].FontIndex);
if (styles[lastStyle].SizeF != styles[style].SizeF)
tw.Write(@"\fs{0}", (int)(styles[style].SizeF * 2));
if (styles[lastStyle].ForeColorIndex != styles[style].ForeColorIndex)
tw.Write(@"\cf{0}", styles[style].ForeColorIndex);
if (styles[lastStyle].BackColorIndex != styles[style].BackColorIndex)
tw.Write(@"\chshdng0\chcbpat{0}\cb{0}", styles[style].BackColorIndex);
if (styles[lastStyle].Italic != styles[style].Italic)
tw.Write(@"\i{0}", styles[style].Italic != 0 ? "" : "0");
if (styles[lastStyle].Underline != styles[style].Underline)
tw.Write(@"\ul{0}", styles[style].Underline != 0 ? "" : "0");
if (styles[lastStyle].Weight != styles[style].Weight)
{
if (styles[style].Weight >= 700 && styles[lastStyle].Weight < 700)
tw.Write(@"\b");
else if (styles[style].Weight < 700 && styles[lastStyle].Weight >= 700)
tw.Write(@"\b0");
}
// NOTE: We don't support StyleData.Visible and StyleData.Case in RTF
lastStyle = style;
tw.Write(" "); // Delimiter
}
switch (ch)
{
case (byte)'{':
tw.Write(@"\{");
break;
case (byte)'}':
tw.Write(@"\}");
break;
case (byte)'\\':
tw.Write(@"\\");
break;
case (byte)'\t':
tw.Write(@"\tab ");
break;
case (byte)'\r':
if (i + 2 < endOffset)
{
if (seg.Array[i + 2] == (byte)'\n')
i += 2;
}
// Either way, this is a line break
goto case (byte)'\n';
case 0xC2:
if (unicodeLineEndings && i + 2 < endOffset)
{
if (seg.Array[i + 2] == 0x85) // NEL \u0085
{
i += 2;
goto case (byte)'\n';
}
}
// Not a Unicode line break
goto default;
case 0xE2:
if (unicodeLineEndings && i + 4 < endOffset)
{
if (seg.Array[i + 2] == 0x80 && seg.Array[i + 4] == 0xA8) // LS \u2028
{
i += 4;
goto case (byte)'\n';
}
else if (seg.Array[i + 2] == 0x80 && seg.Array[i + 4] == 0xA9) // PS \u2029
{
i += 4;
goto case (byte)'\n';
}
}
// Not a Unicode line break
goto default;
case (byte)'\n':
// All your line breaks are belong to us
tw.WriteLine(@"\par");
break;
default:
if (ch == 0)
{
// Scintilla behavior is to allow control characters except for
// NULL which will cause the Clipboard to truncate the string.
tw.Write(" "); // Replace with space
break;
}
if (ch > 0x7F)
{
// Treat as UTF-8 code point
int unicode = 0;
if (ch < 0xE0 && i + 2 < endOffset)
{
unicode |= ((0x1F & ch) << 6);
unicode |= (0x3F & seg.Array[i + 2]);
tw.Write(@"\u{0}?", unicode);
i += 2;
break;
}
else if (ch < 0xF0 && i + 4 < endOffset)
{
unicode |= ((0xF & ch) << 12);
unicode |= ((0x3F & seg.Array[i + 2]) << 6);
unicode |= (0x3F & seg.Array[i + 4]);
tw.Write(@"\u{0}?", unicode);
i += 4;
break;
}
else if (ch < 0xF8 && i + 6 < endOffset)
{
unicode |= ((0x7 & ch) << 18);
unicode |= ((0x3F & seg.Array[i + 2]) << 12);
unicode |= ((0x3F & seg.Array[i + 4]) << 6);
unicode |= (0x3F & seg.Array[i + 6]);
tw.Write(@"\u{0}?", unicode);
i += 6;
break;
}
}
// Regular ANSI char
ms.WriteByte(ch);
break;
}
}
}
tw.AutoFlush = false;
tw.WriteLine("}"); // rtf1
tw.Flush();
// Terminator
ms.WriteByte(0);
// var str = GetString(ms.Pointer, (int)ms.Length, Encoding.ASCII);
if (NativeMethods.SetClipboardData(CF_RTF, ms.Pointer) != IntPtr.Zero)
ms.FreeOnDispose = false; // Clipboard will free memory
}
}
catch (Exception ex)
{
// Yes, we swallow any exceptions. That may seem like code smell but this matches
// the behavior of the Clipboard class, Windows Forms controls, and native Scintilla.
Debug.Fail(ex.Message, ex.ToString());
}
}
private static unsafe void CopyHtml(Scintilla scintilla, StyleData[] styles, List<ArraySegment<byte>> styledSegments)
{
// NppExport -> NppExport.cpp
// NppExport -> HTMLExporter.cpp
// http://blogs.msdn.com/b/jmstall/archive/2007/01/21/html-clipboard.aspx
// http://blogs.msdn.com/b/jmstall/archive/2007/01/21/sample-code-html-clipboard.aspx
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms649015.aspx
try
{
long pos = 0;
byte[] bytes;
// Write HTML
using (var ms = new NativeMemoryStream(styledSegments.Sum(s => s.Count)))
using (var tw = new StreamWriter(ms, new UTF8Encoding(false)))
{
const int INDEX_START_HTML = 23;
const int INDEX_START_FRAGMENT = 65;
const int INDEX_END_FRAGMENT = 87;
const int INDEX_END_HTML = 41;
tw.WriteLine("Version:0.9");
tw.WriteLine("StartHTML:00000000");
tw.WriteLine("EndHTML:00000000");
tw.WriteLine("StartFragment:00000000");
tw.WriteLine("EndFragment:00000000");
tw.Flush();
// Patch header
pos = ms.Position;
ms.Seek(INDEX_START_HTML, SeekOrigin.Begin);
ms.Write((bytes = Encoding.ASCII.GetBytes(ms.Length.ToString("D8"))), 0, bytes.Length);
ms.Seek(pos, SeekOrigin.Begin);
tw.WriteLine("<html>");
tw.WriteLine("<head>");
tw.WriteLine(@"<meta charset=""utf-8"" />");
tw.WriteLine(@"<title>ScintillaNET v{0}</title>", scintilla.GetType().Assembly.GetName().Version.ToString(3));
tw.WriteLine("</head>");
tw.WriteLine("<body>");
tw.Flush();
// Patch header
pos = ms.Position;
ms.Seek(INDEX_START_FRAGMENT, SeekOrigin.Begin);
ms.Write((bytes = Encoding.ASCII.GetBytes(ms.Length.ToString("D8"))), 0, bytes.Length);
ms.Seek(pos, SeekOrigin.Begin);
tw.WriteLine("<!--StartFragment -->");
// Write the styles.
// We're doing the style tag in the body to include it in the "fragment".
tw.WriteLine(@"<style type=""text/css"" scoped="""">");
tw.Write("div#segments {");
tw.Write(" float: left;");
tw.Write(" white-space: pre;");
tw.Write(" line-height: {0}px;", scintilla.DirectMessage(NativeMethods.SCI_TEXTHEIGHT, new IntPtr(0)).ToInt32());
tw.Write(" background-color: #{0:X2}{1:X2}{2:X2};", (styles[Style.Default].BackColor >> 0) & 0xFF, (styles[Style.Default].BackColor >> 8) & 0xFF, (styles[Style.Default].BackColor >> 16) & 0xFF);
tw.WriteLine(" }");
for (int i = 0; i < styles.Length; i++)
{
if (!styles[i].Used)
continue;
tw.Write("span.s{0} {{", i);
tw.Write(@" font-family: ""{0}"";", styles[i].FontName);
tw.Write(" font-size: {0}pt;", styles[i].SizeF);
tw.Write(" font-weight: {0};", styles[i].Weight);
if (styles[i].Italic != 0)
tw.Write(" font-style: italic;");
if (styles[i].Underline != 0)
tw.Write(" text-decoration: underline;");
tw.Write(" background-color: #{0:X2}{1:X2}{2:X2};", (styles[i].BackColor >> 0) & 0xFF, (styles[i].BackColor >> 8) & 0xFF, (styles[i].BackColor >> 16) & 0xFF);
tw.Write(" color: #{0:X2}{1:X2}{2:X2};", (styles[i].ForeColor >> 0) & 0xFF, (styles[i].ForeColor >> 8) & 0xFF, (styles[i].ForeColor >> 16) & 0xFF);
switch ((StyleCase)styles[i].Case)
{
case StyleCase.Upper:
tw.Write(" text-transform: uppercase;");
break;
case StyleCase.Lower:
tw.Write(" text-transform: lowercase;");
break;
}
if (styles[i].Visible == 0)
tw.Write(" visibility: hidden;");
tw.WriteLine(" }");
}
tw.WriteLine("</style>");
tw.Write(@"<div id=""segments""><span class=""s{0}"">", Style.Default);
tw.Flush();
var tabSize = scintilla.DirectMessage(NativeMethods.SCI_GETTABWIDTH).ToInt32();
var tab = new string(' ', tabSize);
tw.AutoFlush = true;
var lastStyle = Style.Default;
var unicodeLineEndings = ((scintilla.DirectMessage(NativeMethods.SCI_GETLINEENDTYPESACTIVE).ToInt32() & NativeMethods.SC_LINE_END_TYPE_UNICODE) > 0);
foreach (var seg in styledSegments)
{
var endOffset = seg.Offset + seg.Count;
for (int i = seg.Offset; i < endOffset; i += 2)
{
var ch = seg.Array[i];
var style = seg.Array[i + 1];
if (lastStyle != style)
{
tw.Write(@"</span><span class=""s{0}"">", style);
lastStyle = style;
}
switch (ch)
{
case (byte)'<':
tw.Write("<");
break;
case (byte)'>':
tw.Write(">");
break;
case (byte)'&':
tw.Write("&");
break;
case (byte)'\t':
tw.Write(tab);
break;
case (byte)'\r':
if (i + 2 < endOffset)
{
if (seg.Array[i + 2] == (byte)'\n')
i += 2;
}
// Either way, this is a line break
goto case (byte)'\n';
case 0xC2:
if (unicodeLineEndings && i + 2 < endOffset)
{
if (seg.Array[i + 2] == 0x85) // NEL \u0085
{
i += 2;
goto case (byte)'\n';
}
}
// Not a Unicode line break
goto default;
case 0xE2:
if (unicodeLineEndings && i + 4 < endOffset)
{
if (seg.Array[i + 2] == 0x80 && seg.Array[i + 4] == 0xA8) // LS \u2028
{
i += 4;
goto case (byte)'\n';
}
else if (seg.Array[i + 2] == 0x80 && seg.Array[i + 4] == 0xA9) // PS \u2029
{
i += 4;
goto case (byte)'\n';
}
}
// Not a Unicode line break
goto default;
case (byte)'\n':
// All your line breaks are belong to us
tw.Write("\r\n");
break;
default:
if (ch == 0)
{
// Scintilla behavior is to allow control characters except for
// NULL which will cause the Clipboard to truncate the string.
tw.Write(" "); // Replace with space
break;
}
ms.WriteByte(ch);
break;
}
}
}
tw.AutoFlush = false;
tw.WriteLine("</span></div>");
tw.Flush();
// Patch header
pos = ms.Position;
ms.Seek(INDEX_END_FRAGMENT, SeekOrigin.Begin);
ms.Write((bytes = Encoding.ASCII.GetBytes(ms.Length.ToString("D8"))), 0, bytes.Length);
ms.Seek(pos, SeekOrigin.Begin);
tw.WriteLine("<!--EndFragment-->");
tw.WriteLine("</body>");
tw.WriteLine("</html>");
tw.Flush();
// Patch header
pos = ms.Position;
ms.Seek(INDEX_END_HTML, SeekOrigin.Begin);
ms.Write((bytes = Encoding.ASCII.GetBytes(ms.Length.ToString("D8"))), 0, bytes.Length);
ms.Seek(pos, SeekOrigin.Begin);
// Terminator
ms.WriteByte(0);
var str = GetString(ms.Pointer, (int)ms.Length, Encoding.UTF8);
if (NativeMethods.SetClipboardData(CF_HTML, ms.Pointer) != IntPtr.Zero)
ms.FreeOnDispose = false; // Clipboard will free memory
}
}
catch (Exception ex)
{
// Yes, we swallow any exceptions. That may seem like code smell but this matches
// the behavior of the Clipboard class, Windows Forms controls, and native Scintilla.
Debug.Fail(ex.Message, ex.ToString());
}
}
private static unsafe List <ArraySegment <byte> > GetStyledSegments(Scintilla scintilla, bool currentSelection, bool currentLine, int startBytePos, int endBytePos, out StyleData[] styles)
{
var segments = new List <ArraySegment <byte> >();
if (currentSelection)
{
// Get each selection as a segment.
// Rectangular selections are ordered top to bottom and have line breaks appended.
var ranges = new List <Tuple <int, int> >();
var selCount = scintilla.DirectMessage(NativeMethods.SCI_GETSELECTIONS).ToInt32();
for (int i = 0; i < selCount; i++)
{
var selStartBytePos = scintilla.DirectMessage(NativeMethods.SCI_GETSELECTIONNSTART, new IntPtr(i)).ToInt32();
var selEndBytePos = scintilla.DirectMessage(NativeMethods.SCI_GETSELECTIONNEND, new IntPtr(i)).ToInt32();
ranges.Add(Tuple.Create(selStartBytePos, selEndBytePos));
}
var selIsRect = scintilla.DirectMessage(NativeMethods.SCI_SELECTIONISRECTANGLE) != IntPtr.Zero;
if (selIsRect)
{
ranges.OrderBy(r => r.Item1); // Sort top to bottom
}
foreach (var range in ranges)
{
var styledText = GetStyledText(scintilla, range.Item1, range.Item2, selIsRect);
segments.Add(styledText);
}
}
else if (currentLine)
{
// Get the current line
var mainSelection = scintilla.DirectMessage(NativeMethods.SCI_GETMAINSELECTION).ToInt32();
var mainCaretPos = scintilla.DirectMessage(NativeMethods.SCI_GETSELECTIONNCARET, new IntPtr(mainSelection)).ToInt32();
var lineIndex = scintilla.DirectMessage(NativeMethods.SCI_LINEFROMPOSITION, new IntPtr(mainCaretPos)).ToInt32();
var lineStartBytePos = scintilla.DirectMessage(NativeMethods.SCI_POSITIONFROMLINE, new IntPtr(lineIndex)).ToInt32();
var lineLength = scintilla.DirectMessage(NativeMethods.SCI_POSITIONFROMLINE, new IntPtr(lineIndex)).ToInt32();
var styledText = GetStyledText(scintilla, lineStartBytePos, (lineStartBytePos + lineLength), false);
segments.Add(styledText);
}
else // User-specified range
{
Debug.Assert(startBytePos != endBytePos);
var styledText = GetStyledText(scintilla, startBytePos, endBytePos, false);
segments.Add(styledText);
}
// Build a list of (used) styles
styles = new StyleData[NativeMethods.STYLE_MAX + 1];
styles[Style.Default].Used = true;
styles[Style.Default].FontName = scintilla.Styles[Style.Default].Font;
styles[Style.Default].SizeF = scintilla.Styles[Style.Default].SizeF;
styles[Style.Default].Weight = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETWEIGHT, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].Italic = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETITALIC, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].Underline = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETUNDERLINE, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].BackColor = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETBACK, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].ForeColor = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETFORE, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].Case = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETCASE, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
styles[Style.Default].Visible = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETVISIBLE, new IntPtr(Style.Default), IntPtr.Zero).ToInt32();
foreach (var seg in segments)
{
for (int i = 0; i < seg.Count; i += 2)
{
var style = seg.Array[i + 1];
if (!styles[style].Used)
{
styles[style].Used = true;
styles[style].FontName = scintilla.Styles[style].Font;
styles[style].SizeF = scintilla.Styles[style].SizeF;
styles[style].Weight = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETWEIGHT, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].Italic = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETITALIC, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].Underline = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETUNDERLINE, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].BackColor = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETBACK, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].ForeColor = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETFORE, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].Case = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETCASE, new IntPtr(style), IntPtr.Zero).ToInt32();
styles[style].Visible = scintilla.DirectMessage(NativeMethods.SCI_STYLEGETVISIBLE, new IntPtr(style), IntPtr.Zero).ToInt32();
}
}
}
return(segments);
}
private void ReadFromFile(string stylePath, bool saveSprites, CancellableContext context, out bool cancelled)
{
cancelled = false;
var styleData = new StyleData
{
PaletteIndexes = new ushort[] {},
Palettes = new Palette[] {},
PaletteBase = new PaletteBase(),
TileData = new byte[] {},
SpriteData = new byte[] {},
SpriteEntries = new SpriteEntry[] {},
SpriteBase = new SpriteBase(),
FontBases = new int[] {},
DeltaData = new byte[] {},
DeltaIndexes = new DeltaIndex[] {},
Sprites = new SerializableDictionary <int, SpriteItem>(),
Deltas = new SerializableDictionary <int, DeltaItem>(),
CarInfo = new SerializableDictionary <int, CarInfo>(),
CarSprites = new Dictionary <int, List <int> >()
};
BinaryReader reader = null;
try
{
if (!File.Exists(stylePath))
{
throw new FileNotFoundException("Style File not found!", stylePath);
}
StylePath = stylePath;
System.Diagnostics.Debug.WriteLine("Reading style file " + stylePath);
var stream = new FileStream(stylePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
styleData.OriginalDateTime = File.GetLastWriteTime(stylePath);
reader = new BinaryReader(stream);
var encoder = System.Text.Encoding.ASCII;
var magicNumber = encoder.GetString(reader.ReadBytes(4)); //GBMP
if (magicNumber != "GBST")
{
throw new FormatException("Wrong style format!");
}
int version = reader.ReadUInt16();
System.Diagnostics.Debug.WriteLine("Style version: " + version);
while (stream.Position < stream.Length)
{
var chunkType = encoder.GetString(reader.ReadBytes(4));
var chunkSize = (int)reader.ReadUInt32();
System.Diagnostics.Debug.WriteLine("Found chunk '" + chunkType + "' with size " + chunkSize.ToString(CultureInfo.InvariantCulture) + ".");
if (context.IsCancelling)
{
cancelled = true;
return;
}
switch (chunkType)
{
case "TILE": //Tiles
styleData.TileData = ReadTiles(reader, chunkSize);
break;
case "PPAL": //Physical Palette
styleData.Palettes = ReadPhysicalPalette(reader, chunkSize);
break;
case "SPRB": //Sprite Bases
styleData.SpriteBase = ReadSpriteBases(reader);
break;
case "PALX": //Palette Index
styleData.PaletteIndexes = ReadPaletteIndexes(reader, chunkSize);
break;
case "OBJI": //Map Objects
ReadMapObjects(reader, chunkSize);
break;
case "FONB": //Font Base
styleData.FontBases = ReadFonts(reader, styleData.SpriteBase.Font);
break;
case "DELX": //Delta Index
styleData.DeltaIndexes = ReadDeltaIndex(reader, chunkSize);
break;
case "DELS": //Delta Store
styleData.DeltaData = ReadDeltaStore(reader, chunkSize);
break;
case "CARI": //Car Info
styleData.CarInfo = ReadCars(reader, chunkSize, styleData.CarSprites);
break;
case "SPRG": //Sprite Graphics
styleData.SpriteData = ReadSpritesGraphics(reader, chunkSize);
break;
case "SPRX": //Sprite Index
styleData.SpriteEntries = ReadSpriteIndex(reader, chunkSize);
break;
case "PALB": //Palette Base
styleData.PaletteBase = ReadPaletteBase(reader);
break;
case "SPEC": //Undocumented
//Shows how tiles behave, for example in a physical way or what kind of sounds they make when somone walks on them
ReadSurfaces(reader, chunkSize);
break;
case "RECY":
ReadRecyclingInfo(reader, chunkSize);
break;
default:
System.Diagnostics.Debug.WriteLine("Skipping chunk '" + chunkType + "'...");
reader.ReadBytes(chunkSize);
break;
}
}
}
catch (Exception e)
{
throw;
}
finally
{
if (reader != null)
{
reader.Close();
}
}
SaveData(styleData, saveSprites, context, out cancelled);
}
private void SaveData(StyleData styleData, bool saveSprites, CancellableContext context, out bool cancelled)
{
var styleFile = Path.GetFileNameWithoutExtension(StylePath);
if (saveSprites)
{
CarInfo.Serialize(styleData.CarInfo, Globals.MiscSubDir + Path.DirectorySeparatorChar + Globals.CarStyleSuffix + Globals.XmlFormat);
Palette.SavePalettes(styleData.Palettes, Globals.GraphicsSubDir + Path.DirectorySeparatorChar + Globals.PaletteSuffix + Globals.TextureImageFormat);
}
_threadCount = saveSprites ? 3 : 1;
var memoryStreamTiles = new MemoryStream();
using (var zip = ZipStorer.Create(memoryStreamTiles, string.Empty))
{
if (context.IsCancelling)
{
cancelled = true;
return;
}
SaveTiles(styleData, zip, context);
if (context.IsCancelling)
{
cancelled = true;
return;
}
}
memoryStreamTiles.Position = 0;
if (Globals.SaveZipFiles)
{
using (var stream = new FileStream(Globals.GraphicsSubDir + Path.DirectorySeparatorChar + styleFile + Globals.TilesSuffix + Globals.ZipFormat, FileMode.Create, FileAccess.Write))
{
var bytes = new byte[memoryStreamTiles.Length];
memoryStreamTiles.Read(bytes, 0, (int)memoryStreamTiles.Length);
stream.Write(bytes, 0, bytes.Length);
}
if (context.IsCancelling)
{
cancelled = true;
return;
}
memoryStreamTiles.Position = 0;
}
TextureAtlas atlas = CreateTextureAtlas <TextureAtlasTiles>(ZipStorer.Open(memoryStreamTiles, FileAccess.Read), styleFile + Globals.TilesSuffix);
_memoryStreams.Add(atlas, memoryStreamTiles);
_runningAtlas.Add(atlas);
if (context.IsCancelling)
{
cancelled = true;
return;
}
if (saveSprites)
{
var memoryStreamSprites = new MemoryStream();
using (var zip = ZipStorer.Create(memoryStreamSprites, string.Empty))
{
if (context.IsCancelling)
{
cancelled = true;
return;
}
SaveSprites(styleData, zip, context);
if (context.IsCancelling)
{
cancelled = true;
return;
}
}
memoryStreamSprites.Position = 0;
if (Globals.SaveZipFiles)
{
using (var stream = new FileStream(Globals.GraphicsSubDir + Path.DirectorySeparatorChar + Globals.SpritesSuffix + Globals.ZipFormat, FileMode.Create, FileAccess.Write))
{
var bytes = new byte[memoryStreamSprites.Length];
memoryStreamSprites.Read(bytes, 0, (int)memoryStreamSprites.Length);
stream.Write(bytes, 0, bytes.Length);
}
if (context.IsCancelling)
{
cancelled = true;
return;
}
memoryStreamSprites.Position = 0;
}
atlas = CreateTextureAtlas <TextureAtlasSprites>(ZipStorer.Open(memoryStreamSprites, FileAccess.Read), Globals.SpritesSuffix, styleData.Sprites);
_memoryStreams.Add(atlas, memoryStreamSprites);
_runningAtlas.Add(atlas);
if (context.IsCancelling)
{
cancelled = true;
return;
}
var memoryStreamDeltas = new MemoryStream();
using (var zip = ZipStorer.Create(memoryStreamDeltas, string.Empty))
{
if (context.IsCancelling)
{
cancelled = true;
return;
}
SaveDeltas(styleData, zip, context);
if (context.IsCancelling)
{
cancelled = true;
return;
}
}
memoryStreamDeltas.Position = 0;
if (Globals.SaveZipFiles)
{
using (var stream = new FileStream(Globals.GraphicsSubDir + Path.DirectorySeparatorChar + Globals.DeltasSuffix + Globals.ZipFormat, FileMode.Create, FileAccess.Write))
{
var bytes = new byte[memoryStreamDeltas.Length];
memoryStreamDeltas.Read(bytes, 0, (int)memoryStreamDeltas.Length);
stream.Write(bytes, 0, bytes.Length);
}
memoryStreamDeltas.Position = 0;
}
atlas = CreateTextureAtlas <TextureAtlasDeltas>(ZipStorer.Open(memoryStreamDeltas, FileAccess.Read), Globals.DeltasSuffix, styleData.Deltas);
_memoryStreams.Add(atlas, memoryStreamDeltas);
_runningAtlas.Add(atlas);
}
WaitHandle.WaitOne();
cancelled = WaitHandle.Value;
GC.Collect();
}
public TubeStyleStruct FindStyleStruct(int cid)
{
return(StyleData.Find(t => t.cid == cid));
}
