//============================================================
public void LoadResource()
{
// 创建数据
FByteStream vertexs = new FByteStream();
float[] vertexData = new float[] {
-1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f,
1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 0.0f,
-1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
};
foreach (float value in vertexData)
{
vertexs.WriteFloat(value);
}
// 输出索引数据
FByteStream faces = new FByteStream();
int[] faceData = new int[] {
0, 1, 2,
0, 2, 3,
};
foreach (int value in faceData)
{
faces.WriteInt32(value);
}
// 创建顶点流
_vertexBuffer = new FDxVertexBuffer();
_vertexBuffer.Device = _device;
_vertexBuffer.UploadNormal(6, vertexs.Memory, 0, vertexs.Length);
// 创建索引流
_faceBuffer = new FDxFaceBuffer();
_faceBuffer.Device = _device;
_faceBuffer.Upload32(faces.Memory, 0, faces.Length);
}
//============================================================
public void Setup()
{
//------------------------------------------------------------
float[] vertexData = new float[] {
-1, 1, 0, 1, 0, 0,
1, 1, 0, 1, 1, 0,
1, -1, 0, 1, 1, 1,
-1, -1, 0, 1, 0, 1
};
FByteStream vertexStream = new FByteStream();
foreach (float value in vertexData)
{
vertexStream.WriteFloat(value);
}
// 创建顶点缓冲
_vertexBuffer = new FDxVertexBuffer();
_vertexBuffer.Device = _device;
_vertexBuffer.Upload5(6, vertexStream.Memory, 0, vertexStream.Length);
//------------------------------------------------------------
int[] faceData = new int[] { 0, 1, 2, 0, 2, 3 };
FByteStream faceStream = new FByteStream();
foreach (int value in faceData)
{
faceStream.WriteInt32(value);
}
// 创建面缓冲
_faceBuffer = new FDxFaceBuffer();
_faceBuffer.Device = _device;
_faceBuffer.Upload(faceStream.Memory, 0, faceStream.Length);
}
//============================================================
// <T>序列化资源信息。</T>
//
// @param output 流信息
//============================================================
public virtual void SerializeCompress(IOutput output, FXmlNode xconfig)
{
// 写入编号
output.WriteString(_code);
//............................................................
output.WriteInt16((short)_resources.Count);
foreach (FDrResource resource in _resources)
{
resource.Open();
// 序列化资源
FByteStream data = new FByteStream();
FCompressFile stream = new FCompressFile();
resource.Serialize(stream);
stream.Compress(data);
// 输出资源
output.WriteInt32(data.Length);
output.WriteBytes(data.Memory, 0, data.Length);
//// 创建资源设置
//if (null != xconfig) {
// FXmlNode xresources = xconfig.Sync("Resources");
// FXmlNode xresource = xresources.CreateNode("Resource");
// xresource.Set("code", resource.Code);
// xresource.Set("label", resource.Label);
// xresource.Set("type_name", resource.TypeName);
// xresource.Set("size", stream.Length);
// xresource.Set("size_compress", data.Length);
//}
}
}
//============================================================
public bool DataUnserialize(FByteStream input)
{
int count = input.ReadInt32();
for (int n = 0; n < count; n++)
{
string name = input.ReadStringA16();
if (_geometryDictionary.Contains(name))
{
FDrGeometry geometry = _geometryDictionary.Get(name);
if (!geometry.DataUnserialize(input))
{
return(false);
}
}
else
{
FDrGeometry geometry = new FDrGeometry(_model);
if (!geometry.DataUnserialize(input))
{
return(false);
}
RMoCore.TrackConsole.Write(this, "DataUnserialize", "Can't find geometry config in model. (model={0}, geometry={1})", _model.Code, name);
}
}
return(true);
}
//============================================================
// <T>序列化资源信息。</T>
//
// @param output 流信息
//============================================================
public virtual void Serialize(IOutput output, FXmlNode config)
{
// 写入编号
output.WriteString(_code);
//............................................................
output.WriteInt16((short)_resources.Count);
foreach (FDrResource resource in _resources)
{
resource.Open();
// 序列化资源
FByteStream stream = new FByteStream();
resource.Serialize(stream);
// 输出资源
output.WriteInt32(stream.Length);
output.WriteBytes(stream.Memory, 0, stream.Length);
// 创建资源设置
if (null != config)
{
FXmlNode xresource = config.CreateNode("Resource");
xresource.Set("code", resource.Code);
xresource.Set("label", resource.Label);
xresource.Set("length", stream.Length);
}
}
}
//============================================================
// <T>存储压缩文件。</T>
//
// @param fileName 文件名称
// @param widthCount 横向分割个数
// @param hightCount 纵向分割个数
//============================================================
public void StoreCompress(IOutput output, Bitmap bitmap, int colorCount, int widthCount, int hightCount)
{
// 输出图片尺寸
int width = bitmap.Width;
int height = bitmap.Height;
output.WriteUint16((ushort)width);
output.WriteUint16((ushort)height);
// 输出分割尺寸
int splitWidth = width / widthCount;
int splitHeight = height / hightCount;
int splitCount = widthCount * hightCount;
output.WriteUint16((ushort)splitCount);
// 分割图片
for (int y = 0; y < hightCount; y++)
{
for (int x = 0; x < widthCount; x++)
{
FByteStream bs = new FByteStream();
bs.WriteUint16((ushort)splitWidth);
bs.WriteUint16((ushort)splitHeight);
// 绘制局部图形
FBitmap image = new FBitmap(splitWidth, splitHeight);
image.CopyFrom(bitmap, splitWidth * x, splitHeight * y);
// 存储索引图片
StoreIndexedColor(bs, image.Native, colorCount, x, y);
// 输出数据
output.WriteInt32(bs.Length);
output.WriteBytes(bs.Memory, 0, bs.Length);
}
}
}
//============================================================
// <T>分块压缩保存为字节数组。</T>
//
// @param blockSize 分块大小
// @return 字节数组
//============================================================
public byte[] BlockCompressNative(int blockSize)
{
byte[] data = null;
using (FByteStream stream = new FByteStream()) {
BlockCompressNative(stream, blockSize);
data = stream.ToArray();
}
return(data);
}
//============================================================
// <T>序列化内部数据到输出流中。</T>
//
// @param output 输出流
//============================================================
public byte[] CompressBytes()
{
Open();
FByteStream stream = new FByteStream();
FCompressFile compress = new FCompressFile();
Serialize(compress);
compress.Compress(stream);
return(stream.ToArray());
}
//============================================================
public void LoadResource(FDrGeometry geometry)
{
// 创建数据
int faceCount = geometry.FaceList.Count;
FByteStream vertexs = new FByteStream(4 * 10 * 3 * faceCount);
FByteStream faces = new FByteStream(3 * faceCount);
for (int f = 0; f < faceCount; f++)
{
FDrFace face = geometry.FaceList[f];
for (int n = 0; n < 3; n++)
{
// 输出顶点数据
FDrVertex vertex = geometry.VertexList[face.VertexIndex[n]];
FDrCoord coord = geometry.CoordList[face.CoordIndex[n]];
float coordX = coord.Coord.X;
float coordY = coord.Coord.Y + 1.0f;
if (geometry.Channels.Count > 1)
{
FDrChannelFace channelFace = geometry.Channels[2].Indexs[face.Index];
SFloatPoint3 channelPoint = channelFace.Points[n];
coordX = channelPoint.X;
coordY = channelPoint.Y;
}
FDrColor color = geometry.ColorList[face.ColorIndex[n]];
vertexs.WriteFloat(vertex.Position.X);
vertexs.WriteFloat(vertex.Position.Y);
vertexs.WriteFloat(vertex.Position.Z);
vertexs.WriteFloat(1.0f);
vertexs.WriteFloat(coordX);
vertexs.WriteFloat(coordY);
vertexs.WriteFloat(color.Color.R);
vertexs.WriteFloat(color.Color.G);
vertexs.WriteFloat(color.Color.B);
vertexs.WriteFloat(1.0f);
// 输出索引数据
faces.WriteInt32(3 * f + n);
}
}
// 创建顶点流
_vertexBuffer = new FDxVertexBuffer();
_vertexBuffer.Device = _device;
_vertexBuffer.UploadNormal(10, vertexs.Memory, 0, vertexs.Length);
// 创建索引流
_faceBuffer = new FDxFaceBuffer();
_faceBuffer.Device = _device;
_faceBuffer.Upload32(faces.Memory, 0, faces.Length);
}
//============================================================
// <T>序列化内容到输出流。</T>
//
// @param output 输出流
//============================================================
public override void OnSerialize(IOutput output)
{
base.OnSerialize(output);
// 序列化属性
output.WriteUint8((byte)_spreadCd);
output.WriteUint8((byte)_horizontalCount);
output.WriteUint8((byte)_horizontalSpace);
output.WriteUint8((byte)_verticalCount);
output.WriteUint8((byte)_verticalSpace);
output.WriteUint8((byte)_initialCount);
// 获得项目数量
int itemCount = 0;
int total = ComponmentCount;
for (int n = 0; n < total; n++)
{
FRcComponent component = _components[n];
if (!component.OptionValid)
{
continue;
}
if (component is FRcScrollItem)
{
itemCount++;
}
}
// 写入模版集合
output.WriteInt16((short)itemCount);
for (int n = 0; n < total; n++)
{
FRcComponent component = _components[n];
if (!component.OptionValid)
{
continue;
}
if (component is FRcScrollItem)
{
FByteStream stream = new FByteStream();
component.Serialize(stream);
output.WriteString(component.Name);
//output.WriteInt16((short)REnumUiComponent.Parse(_typeName));
output.WriteString(component.ClassName);
output.WriteInt32(stream.Length);
output.WriteBytes(stream.Memory, 0, stream.Length);
}
}
}
//============================================================
// <T>序列化资源信息。</T>
//
// @param output 流信息
//============================================================
public virtual void Serialize(IOutput output)
{
// 写入编号
output.WriteString(_code);
//............................................................
output.WriteInt16((short)_resources.Count);
foreach (FRsResource resource in _resources)
{
resource.Open();
// 序列化资源
FCompressFile file = new FCompressFile();
resource.Serialize(file);
FByteStream stream = new FByteStream();
file.Compress(stream);
// 输出资源
output.WriteInt32(stream.Length);
output.WriteBytes(stream.Memory, 0, stream.Length);
}
}
//============================================================
// <T>序列化位图数据。</T>
//
// @params output 输出流
// @params colorCount 调色板颜色数量
// @params pixelCount 分块的像素个数
//============================================================
public bool Compress(IOutput output, int compressCd, int colorCount, int pixelCount)
{
// 保存数据
using (FByteStream stream = new FByteStream()) {
Serialize(stream, colorCount, pixelCount);
// 压缩数据
byte[] data = null;
if (compressCd == ERsCompress.NoneValue)
{
data = stream.ToArray();
}
else if (compressCd == ERsCompress.DeflateValue)
{
//using(FRsCompressFile compress = new FRsCompressFile(ERsCompress.Deflate, stream, RResourceManager.CompressBlockSplit)) {
using (FCompressFile compress = new FCompressFile(stream)) {
data = compress.Compress();
}
if (data.Length > stream.Length)
{
compressCd = ERsCompress.NoneValue;
data = stream.ToArray();
}
}
else if (compressCd == ERsCompress.LzmaValue)
{
using (FLzmaFile compress = new FLzmaFile(stream)) {
data = compress.CompressNative();
}
if (data.Length > stream.Length)
{
compressCd = ERsCompress.NoneValue;
data = stream.ToArray();
}
}
output.WriteInt32(compressCd);
output.WriteInt32(data.Length);
output.WriteBytes(data, 0, data.Length);
}
return(true);
}
//============================================================
public void LoadResource(FDrGeometry geometry)
{
// 创建数据
int faceCount = geometry.FaceList.Count;
FByteStream vertexs = new FByteStream(4 * 10 * 3 * faceCount);
FByteStream faces = new FByteStream(3 * faceCount);
for (int f = 0; f < faceCount; f++)
{
FDrFace face = geometry.FaceList[f];
for (int n = 0; n < 3; n++)
{
// 输出顶点数据
FDrVertex vertex = geometry.VertexList[face.VertexIndex[n]];
FDrCoord coord = geometry.CoordList[face.CoordIndex[n]];
FDrNormal normal = geometry.NormalList[face.NormalIndex[n]];
vertexs.WriteFloat(vertex.Position.X);
vertexs.WriteFloat(vertex.Position.Y);
vertexs.WriteFloat(vertex.Position.Z);
vertexs.WriteFloat(1.0f);
vertexs.WriteFloat(coord.Coord.X);
vertexs.WriteFloat(coord.Coord.Y + 1);
vertexs.WriteFloat(normal.Direction.X);
vertexs.WriteFloat(normal.Direction.Y);
vertexs.WriteFloat(normal.Direction.Z);
vertexs.WriteFloat(1.0f);
// 输出索引数据
faces.WriteInt32(3 * f + n);
}
}
// 创建顶点流
_vertexBuffer = new FDxVertexBuffer();
_vertexBuffer.Device = _device;
_vertexBuffer.UploadNormal(10, vertexs.Memory, 0, vertexs.Length);
// 创建索引流
_faceBuffer = new FDxFaceBuffer();
_faceBuffer.Device = _device;
_faceBuffer.Upload32(faces.Memory, 0, faces.Length);
}
//============================================================
// <T>根据指定模式导出数据。</T>
//
// @param modeCd 导出模式
//============================================================
public override void Export(ERsExportMode modeCd)
{
// 打开资源
Open();
//............................................................
// 序列化数据
FByteStream stream = new FByteStream();
Serialize(stream);
//............................................................
//// 保存数据
//using (FRsCompressFile file = new FRsCompressFile(ERsCompress.Lzma, stream, RContent2dManager.CompressBlockSplit)) {
// byte[] data = file.CompressBytes();
// string fileName1 = RContent3dManager.TemplateConsole.ExportDirectory + "/tp_" + Code + ".swf";
// File.WriteAllBytes(fileName1, data);
// string fileName2 = RContent3dManager.ResourceConsole.ExportResourceDirectory + "/tp_" + Code + ".stg";
// File.WriteAllBytes(fileName2, data);
// _logger.Debug(this, "Export", "Export template success. (file_name={0})", fileName1);
//}
//............................................................
// 释放资源
Dispose();
}
//============================================================
// <T>序列化位图数据。</T>
//
// @params output 输出流
// @params colorCount 调色板颜色数量
// @params pixelCount 分块的像素个数
//============================================================
public bool Serialize(IOutput output, SIntRectangle rect, int colorCount)
{
// 写入设置
output.WriteBool(_optionAlpha);
// 写入属性
output.WriteUint16((ushort)_size.Width);
output.WriteUint16((ushort)_size.Height);
output.WriteUint16((ushort)rect.Left);
output.WriteUint16((ushort)rect.Top);
output.WriteUint16((ushort)rect.Width);
output.WriteUint16((ushort)rect.Height);
// 若不支持半透明，去掉一个颜色，添加一个透明色
//if (!_optionAlpha) {
// colorCount--;
//}
// 写入头信息
FPictureQuantizer pictureQuantizer = null;
IColorQuantizer colorQuantizer = null;
if (_optionAlpha)
{
pictureQuantizer = new FPictureQuantizer(EColorQuantizer.Octree);
colorQuantizer = pictureQuantizer.LoadQuantizerColors(_bitmap, rect, FPictureQuantizer.EQuantizedMode.Rgb);
}
else
{
pictureQuantizer = new FPictureQuantizer(EColorQuantizer.Octree16);
colorQuantizer = pictureQuantizer.LoadQuantizerColors(_bitmap, rect, FPictureQuantizer.EQuantizedMode.Color);
}
using (FByteStream stream = new FByteStream()) {
SerializeUnpack(stream, colorQuantizer, rect, colorCount);
output.WriteInt32(stream.Length);
output.WriteBytes(stream.Memory, 0, stream.Length);
}
return(true);
}
//============================================================
// <T>序列化位图的一个区块。</T>
//
// @params output 输出流
// @params colorQuantizer 颜色优化器
// @params rect 序列化的矩形区域
// @params colorCount 颜色数量
//============================================================
protected bool SerializeBlock(IOutput output, IColorQuantizer colorQuantizer, SIntRectangle rect, int colorCount)
{
FByteStream stream = new FByteStream();
int blockWidth = rect.Width;
int blockHeight = rect.Height;
// 写入设置
stream.WriteBool(_optionAlpha);
stream.WriteUint16((ushort)blockWidth);
stream.WriteUint16((ushort)blockHeight);
// 构造调色板
Color[] palette = null;
if (_optionAlpha)
{
palette = colorQuantizer.MakePalette(colorCount).ToArray();
if (0 == palette.Length)
{
RMoCore.TrackConsole.Write(this, "SerializeBlock", "Palette color is empty.");
return(false);
}
}
else
{
List <Color> colorList = colorQuantizer.MakePalette(colorCount);
if (0 == colorList.Count)
{
RMoCore.TrackConsole.Write(this, "SerializeBlock", "Palette color is empty.");
return(false);
}
colorList.Add(Color.FromArgb(0, 0, 0, 0));
palette = colorList.ToArray();
}
// 输出调色板
int paletteCount = palette.Length;
stream.WriteUint16((ushort)paletteCount);
//if(RResourceManager.IsColoPremultiplied) {
// foreach (Color color in palette) {
// if (_optionAlpha) {
// stream.WriteInt32(color.ToArgb() & 0x00FFFFFF);
// } else {
// byte a = color.A;
// byte r = (byte)(((float)color.R * (float)a) / 255.0f);
// byte g = (byte)(((float)color.G * (float)a) / 255.0f);
// byte b = (byte)(((float)color.B * (float)a) / 255.0f);
// stream.WriteInt32(Color.FromArgb(a, r, g, b).ToArgb());
// }
// }
//} else if(RResourceManager.IsColoSkipProcess) {
// int skipAlpha = RResourceManager.ColoSkipAlpha;
// foreach(Color color in palette) {
// if(_optionAlpha) {
// stream.WriteInt32(color.ToArgb() & 0x00FFFFFF);
// } else {
// if(color.A < skipAlpha) {
// stream.WriteInt32(0);
// } else {
// stream.WriteInt32(color.ToArgb());
// }
// }
// }
//} else {
// foreach(Color color in palette) {
// if(_optionAlpha) {
// stream.WriteInt32(color.ToArgb() & 0x00FFFFFF);
// } else {
// stream.WriteInt32(color.ToArgb());
// }
// }
//}
// _logger.Debug(this, "SerializeIndexed", "block_size={0}x{1}, color={2}, alpha={3}", blockWidth, blockHeight, paletteCount, _optionAlpha);
// 输出颜色数组
int x = rect.Left;
int y = rect.Top;
// 透明色索引
int transparentIndex = palette.Length - 1;
int size = blockWidth * blockHeight;
// 写入数组
int postion = 0;
byte[] bytes = null;
if (_optionAlpha)
{
// 写入索引颜色和透明度
bytes = new byte[size * 2];
for (int h = 0; h < blockHeight; h++)
{
for (int w = 0; w < blockWidth; w++)
{
Color color = _bitmap.GetPixel(x + w, y + h);
int index = colorQuantizer.FindPaletteIndex(Color.FromArgb(255, color));
bytes[postion++] = (byte)index;
bytes[postion++] = color.A;
}
}
}
else
{
// 写入带透明的索引颜色
bytes = new byte[size];
for (int h = 0; h < blockHeight; h++)
{
for (int w = 0; w < blockWidth; w++)
{
Color color = _bitmap.GetPixel(x + w, y + h);
int index = colorQuantizer.FindPaletteIndex(color);
bytes[postion++] = (byte)index;
}
}
}
stream.WriteBytes(bytes, 0, postion);
// 写入数据
output.WriteInt32(stream.Length);
output.WriteBytes(stream.Memory, 0, stream.Length);
return(true);
}
//============================================================
// <T>序列化位图数据。</T>
//
// @params output 输出流
// @params colorCount 调色板颜色数量
// @params pixelCount 分块的像素个数
//============================================================
public bool Serialize(IOutput output, int colorCount, int pixelCount)
{
// 计算分割信息
int width = _validSize.Width;
int height = _validSize.Height;
int totalPixel = width * height;
int splitWidth = width;
int splitCount = totalPixel / pixelCount;
int splitHeight = height;
if (0 == splitCount)
{
splitHeight = height;
splitCount = 1;
}
else
{
splitHeight = height / splitCount;
splitCount = height / splitHeight;
if (0 != (height % splitHeight))
{
splitCount++;
}
}
// 写入头信息
output.WriteBool(_optionAlpha);
output.WriteUint16((ushort)_size.Width);
output.WriteUint16((ushort)_size.Height);
output.WriteUint16((ushort)_validLocation.X);
output.WriteUint16((ushort)_validLocation.Y);
output.WriteUint16((ushort)_validSize.Width);
output.WriteUint16((ushort)_validSize.Height);
output.WriteUint16((ushort)splitCount);
// 若不支持半透明，去掉一个颜色，添加一个透明色
//if (!_optionAlpha) {
// colorCount--;
//}
// 要序列化的源矩形区域
SIntRectangle subrect = new SIntRectangle();
subrect.Left = _validLocation.X;
subrect.Top = _validLocation.Y;
subrect.Width = splitWidth;
subrect.Height = splitHeight;
// 源矩形数据
FByteStream data = new FByteStream();
for (int n = 0; n < splitCount; n++)
{
subrect.Bottom = Math.Min(subrect.Top + splitHeight, _validLocation.Y + height);
// 创建图片优化器
FPictureQuantizer pictureQuantizer = null;
IColorQuantizer colorQuantizer = null;
if (_optionAlpha)
{
pictureQuantizer = new FPictureQuantizer(EColorQuantizer.Octree);
colorQuantizer = pictureQuantizer.LoadQuantizerColors(_bitmap, subrect, FPictureQuantizer.EQuantizedMode.Rgb);
}
else
{
pictureQuantizer = new FPictureQuantizer(EColorQuantizer.Octree16);
colorQuantizer = pictureQuantizer.LoadQuantizerColors(_bitmap, subrect, FPictureQuantizer.EQuantizedMode.Color);
}
// 存储图片优化数据
if (SerializeBlock(data, colorQuantizer, subrect, colorCount))
{
// _logger.Debug(this, "SerializeIndexed", "index={0}/{1}, rect={2}, size={3}", n, splitCount, rect.ToString(), bs.Length);
subrect.Top += splitHeight;
}
else
{
RMoCore.TrackConsole.Write(this, "Serialize", "Picture is all transparent.");
return(false);
}
}
output.WriteInt32(data.Length);
output.WriteBytes(data.Memory, 0, data.Length);
return(true);
}
//============================================================
// <T>压缩字节数据。</T>
//
// @return 字节数据
//============================================================
public byte[] CompressBytes()
{
byte[] data = null;
// Deflate压缩
string compressCd = _compressCd;
switch (compressCd)
{
case ERsCompress.Deflate:
using (FCompressFile file = new FCompressFile()) {
file.Append(_memory, 0, _length);
if (_blockSize > 0)
{
data = file.BlockCompress(_blockSize);
}
else
{
data = file.Compress();
}
}
break;
case ERsCompress.Lzma:
using (FLzmaFile file = new FLzmaFile()) {
file.Append(_memory, 0, _length);
if (_blockSize > 0)
{
data = file.BlockCompress(_blockSize);
}
else
{
data = file.Compress();
}
}
break;
case ERsCompress.LzmaAlchemy:
using (FLzmaFile file = new FLzmaFile()) {
file.Append(_memory, 0, _length);
if (_blockSize > 0)
{
data = file.BlockCompressNative(_blockSize);
}
else
{
data = file.CompressNative();
}
}
break;
}
// 检查大小，如果压缩后更大，则不压缩数据
if (data.Length > _length)
{
data = ToArray();
compressCd = ERsCompress.None;
}
// 计算效验码
_vertifyCode = RByte.ComputeHash32(data, 0, data.Length);
// 写入文件
byte[] result = null;
using (FByteStream stream = new FByteStream()) {
// 写入信息
stream.WriteUint8((byte)ERsCompress.Parse(compressCd));
stream.WriteInt32(_length);
stream.WriteInt32(_vertifyCode);
stream.WriteInt32(_blockSize);
// 写入数据
if ((ERsCompress.None != compressCd) && (_blockSize > 0))
{
stream.WriteBytes(data, 0, data.Length);
}
else
{
stream.WriteInt32(1);
stream.WriteInt32(data.Length);
stream.WriteBytes(data, 0, data.Length);
}
result = stream.ToArray();
}
return(result);
}
//============================================================
// <T>序列化位图数据。</T>
//
// @params output 输出流
// @params colorCount 调色板颜色数量
// @params pixelCount 分块的像素个数
//============================================================
public bool SerializeUnpackIndexed(IOutput output, int colorCount, int pixelCount)
{
// 若不支持半透明，去掉一个颜色，添加一个透明色
SIntRectangle rect = new SIntRectangle();
rect.Left = 0;
rect.Top = 0;
rect.Width = _native.Width;
rect.Height = _native.Height;
// 计算分割信息
int width = rect.Width;
int height = rect.Height;
int totalPixel = width * height;
int splitWidth = width;
int splitCount = totalPixel / pixelCount;
int splitHeight = height;
if (0 == splitCount)
{
splitHeight = height;
splitCount = 1;
}
else
{
splitHeight = height / splitCount;
splitCount = height / splitHeight;
if (0 != (height % splitHeight))
{
splitCount++;
}
}
// 写入头信息
ushort option = 0;
if (_optionAlpha)
{
option |= (ushort)EBitmapOption.Alpha;
}
output.WriteUint16(option);
output.WriteUint16((ushort)width);
output.WriteUint16((ushort)height);
output.WriteUint16((ushort)splitCount);
// 要序列化的源矩形区域
SIntRectangle subrect = new SIntRectangle();
subrect.Left = rect.Left;
subrect.Top = rect.Top;
subrect.Width = splitWidth;
subrect.Height = splitHeight;
// 源矩形数据
FByteStream bs = new FByteStream();
for (int n = 0; n < splitCount; n++)
{
bs.Clear();
subrect.Bottom = Math.Min(subrect.Top + splitHeight, rect.Top + height);
// 创建图片优化器
FPictureQuantizer pictureQuantizer = null;
IColorQuantizer colorQuantizer = null;
if (_optionAlpha)
{
pictureQuantizer = new FPictureQuantizer(EColorQuantizer.Octree);
colorQuantizer = pictureQuantizer.LoadQuantizerColors(_native, subrect, FPictureQuantizer.EQuantizedMode.Rgb);
}
else
{
pictureQuantizer = new FPictureQuantizer(EColorQuantizer.Octree16);
colorQuantizer = pictureQuantizer.LoadQuantizerColors(_native, subrect, FPictureQuantizer.EQuantizedMode.Color);
}
// 存储图片优化数据
if (SerializeUnpackBlock(bs, colorQuantizer, subrect, colorCount))
{
output.WriteUint32((uint)bs.Length);
output.WriteBytes(bs.Memory, 0, bs.Length);
// _logger.Debug(this, "SerializeIndexed", "index={0}/{1}, rect={2}, size={3}", n, splitCount, rect.ToString(), bs.Length);
subrect.Top += splitHeight;
}
else
{
RMoCore.TrackConsole.Write(this, "SerializeIndexed", "Picture is all transparent.");
return(false);
}
}
return(true);
}
//============================================================
// <T>序列化多层数据。</T>
//
// @param output 输出流
//============================================================
public void Serialize2(IOutput output)
{
base.Serialize(output);
// 输出位图列表
output.WriteInt16((short)_bitmaps.Count);
foreach (FDrTextureBitmap bitmap in _bitmaps)
{
bitmap.Serialize(output);
}
// 压缩颜色
int bitmapCount = 0;
string path = RContent3dManager.TextureConsole.ResourceDirectory;
FByteStream bytes = new FByteStream();
// 合并漫反射和透明纹理
FDrTextureBitmap bitmapDiffuse = FindByTypeCd(EDrTexture.Diffuse);
FDrTextureBitmap bitmapAlpha = FindByTypeCd(EDrTexture.Alpha);
if ((null != bitmapDiffuse) || (null != bitmapAlpha))
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.PackDiffuse);
bytes.WriteInt16(0);
using (FRsBitmapTexture merger = new FRsBitmapTexture()) {
if (null != bitmapDiffuse)
{
merger.LoadFile(path + bitmapDiffuse.Source, EBitmapChannels.RGB);
}
if (null != bitmapAlpha)
{
merger.LoadFileChannel(path + bitmapAlpha.Source, EBitmapChannel.R, EBitmapChannels.A);
}
merger.Serialize(bytes);
}
}
// 合并法线和高光级别纹理
FDrTextureBitmap bitmapNormal = FindByTypeCd(EDrTexture.Normal);
FDrTextureBitmap bitmapSpecularLevel = FindByTypeCd(EDrTexture.SpecularLevel);
if ((null != bitmapNormal) || (null != bitmapSpecularLevel))
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.PackNormal);
bytes.WriteInt16(0);
using (FRsBitmapTexture merger = new FRsBitmapTexture()) {
if (null != bitmapNormal)
{
merger.LoadFile(path + bitmapNormal.Source, EBitmapChannels.RGB);
}
if (null != bitmapSpecularLevel)
{
merger.LoadFileChannel(path + bitmapSpecularLevel.Source, EBitmapChannel.R, EBitmapChannels.A);
}
merger.Serialize(bytes);
}
}
// 合并高光和高度纹理
FDrTextureBitmap bitmapSpecular = FindByTypeCd(EDrTexture.Specular);
FDrTextureBitmap bitmapHeight = FindByTypeCd(EDrTexture.Height);
if ((null != bitmapSpecular) || (null != bitmapHeight))
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.PackSpecular);
bytes.WriteInt16(0);
using (FRsBitmapTexture merger = new FRsBitmapTexture()) {
if (null != bitmapSpecular)
{
merger.LoadFile(path + bitmapSpecular.Source, EBitmapChannels.RGB);
}
if (null != bitmapHeight)
{
merger.LoadFileChannel(path + bitmapHeight.Source, EBitmapChannel.R, EBitmapChannels.A);
}
merger.Serialize(bytes);
}
}
// 合并透射和透射级别纹理
FDrTextureBitmap bitmapTransmittanceColor = FindByTypeCd(EDrTexture.TransmittanceColor);
FDrTextureBitmap bitmapTransmittanceLevel = FindByTypeCd(EDrTexture.TransmittanceLevel);
if ((null != bitmapTransmittanceColor) || (null != bitmapTransmittanceLevel))
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.PackTransmittance);
bytes.WriteInt16(0);
using (FRsBitmapTexture merger = new FRsBitmapTexture()) {
if (null != bitmapTransmittanceColor)
{
merger.LoadFile(path + bitmapTransmittanceColor.Source, EBitmapChannels.RGB);
}
if (null != bitmapTransmittanceLevel)
{
merger.LoadFileChannel(path + bitmapTransmittanceLevel.Source, EBitmapChannel.R, EBitmapChannels.A);
}
merger.Serialize(bytes);
}
}
// 合并其他纹理
FDrTextureBitmap bitmapLight = FindByTypeCd(EDrTexture.Light);
FDrTextureBitmap bitmapReflect = FindByTypeCd(EDrTexture.Reflect);
FDrTextureBitmap bitmapRefract = FindByTypeCd(EDrTexture.Refract);
FDrTextureBitmap bitmapEmissive = FindByTypeCd(EDrTexture.Emissive);
if ((null != bitmapLight) || (null != bitmapReflect) || (null != bitmapRefract) || (null != bitmapEmissive))
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.PackLight);
bytes.WriteInt16(0);
using (FRsBitmapTexture merger = new FRsBitmapTexture()) {
if (null != bitmapLight)
{
merger.LoadFileChannel(path + bitmapLight.Source, EBitmapChannel.R, EBitmapChannels.R);
}
if (null != bitmapReflect)
{
merger.LoadFileChannel(path + bitmapReflect.Source, EBitmapChannel.R, EBitmapChannels.G);
}
if (null != bitmapRefract)
{
merger.LoadFileChannel(path + bitmapRefract.Source, EBitmapChannel.R, EBitmapChannels.B);
}
if (null != bitmapEmissive)
{
merger.LoadFileChannel(path + bitmapEmissive.Source, EBitmapChannel.R, EBitmapChannels.A);
}
merger.Serialize(bytes);
}
}
// 输出环境纹理
FDrTextureBitmap bitmapEnvironment = FindByTypeCd(EDrTexture.Environment);
if (null != bitmapEnvironment)
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.Environment);
bytes.WriteInt16(0);
Bitmap bitmap = new Bitmap(path + bitmapEnvironment.Source);
int size = bitmap.Height;
int block = bitmap.Width / bitmap.Height;
using (Bitmap cubeBitmap = new Bitmap(bitmap.Height, bitmap.Width, PixelFormat.Format32bppArgb)) {
cubeBitmap.SetResolution(bitmap.HorizontalResolution, bitmap.VerticalResolution);
using (Graphics g = Graphics.FromImage(cubeBitmap)) {
for (int n = 0; n < 6; n++)
{
g.DrawImage(bitmap,
new Rectangle(0, size * n, size, size),
new Rectangle(size * n, 0, size, size),
GraphicsUnit.Pixel);
}
}
using (FRsBitmapTexture merger = new FRsBitmapTexture(cubeBitmap)) {
merger.Serialize(bytes);
}
}
}
// 输出纹理列表
output.WriteInt16((sbyte)bitmapCount);
output.WriteBytes(bytes.Memory, 0, bytes.Length);
}
//============================================================
// <T>序列化多层数据。</T>
//
// @param output 输出流
//============================================================
public override void SerializeIndex(IOutput output)
{
base.Serialize(output);
// 输出位图列表
output.WriteInt16((short)_bitmaps.Count);
foreach (FDrTextureBitmap bitmap in _bitmaps)
{
bitmap.Serialize(output);
}
// 压缩颜色
int bitmapCount = 0;
string path = RContent3dManager.TextureConsole.ResourceDirectory;
FByteStream bytes = new FByteStream();
// 合并漫反射和透明纹理
FDrTextureBitmap bitmapDiffuse = FindByTypeCd(EDrTexture.Diffuse);
FDrTextureBitmap bitmapAlpha = FindByTypeCd(EDrTexture.Alpha);
if ((null != bitmapDiffuse) || (null != bitmapAlpha))
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.PackDiffuse);
bytes.WriteInt16(0);
using (FPngMerger merger = new FPngMerger()) {
if (null != bitmapDiffuse)
{
merger.LoadColorFile(path + bitmapDiffuse.Source);
}
if (null != bitmapAlpha)
{
merger.LoadAlphaFile(path + bitmapAlpha.Source);
}
Bitmap bitmap = merger.Merge();
using (FIndexBitmap resource = new FIndexBitmap(bitmap)) {
resource.OptionAlpha = true;
resource.SerializeIndexed(bytes, EDrTexture.SplitColorCount, EDrTexture.SplitPixelCount);
}
}
}
// 合并法线和高光级别纹理
FDrTextureBitmap bitmapNormal = FindByTypeCd(EDrTexture.Normal);
FDrTextureBitmap bitmapSpecularLevel = FindByTypeCd(EDrTexture.SpecularLevel);
if ((null != bitmapNormal) || (null != bitmapSpecularLevel))
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.PackNormal);
bytes.WriteInt16(0);
using (FPngMerger merger = new FPngMerger()) {
if (null != bitmapNormal)
{
merger.LoadColorFile(path + bitmapNormal.Source);
}
if (null != bitmapSpecularLevel)
{
merger.LoadAlphaFile(path + bitmapSpecularLevel.Source);
}
Bitmap bitmap = merger.Merge();
using (FIndexBitmap resource = new FIndexBitmap(bitmap)) {
resource.OptionAlpha = true;
resource.SerializeIndexed(bytes, EDrTexture.SplitColorCount, EDrTexture.SplitPixelCount);
}
}
}
// 合并高光和高度纹理
FDrTextureBitmap bitmapSpecular = FindByTypeCd(EDrTexture.Specular);
FDrTextureBitmap bitmapHeight = FindByTypeCd(EDrTexture.Height);
if ((null != bitmapSpecular) || (null != bitmapHeight))
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.PackSpecular);
bytes.WriteInt16(0);
using (FPngMerger merger = new FPngMerger()) {
if (null != bitmapSpecular)
{
merger.LoadColorFile(path + bitmapSpecular.Source);
}
if (null != bitmapHeight)
{
merger.LoadAlphaFile(path + bitmapHeight.Source);
}
Bitmap bitmap = merger.Merge();
using (FIndexBitmap resource = new FIndexBitmap(bitmap)) {
resource.OptionAlpha = true;
resource.SerializeIndexed(bytes, EDrTexture.SplitColorCount, EDrTexture.SplitPixelCount);
}
}
}
// 合并透射和透射级别纹理
FDrTextureBitmap bitmapTransmittanceColor = FindByTypeCd(EDrTexture.TransmittanceColor);
FDrTextureBitmap bitmapTransmittanceLevel = FindByTypeCd(EDrTexture.TransmittanceLevel);
if ((null != bitmapTransmittanceColor) || (null != bitmapTransmittanceLevel))
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.PackTransmittance);
bytes.WriteInt16(0);
using (FPngMerger merger = new FPngMerger()) {
if (null != bitmapTransmittanceColor)
{
merger.LoadColorFile(path + bitmapTransmittanceColor.Source);
}
if (null != bitmapTransmittanceLevel)
{
merger.LoadAlphaFile(path + bitmapTransmittanceLevel.Source);
}
Bitmap bitmap = merger.Merge();
using (FIndexBitmap resource = new FIndexBitmap(bitmap)) {
resource.OptionAlpha = true;
resource.SerializeIndexed(bytes, EDrTexture.SplitColorCount, EDrTexture.SplitPixelCount);
}
}
}
// 合并其他纹理
FDrTextureBitmap bitmapLight = FindByTypeCd(EDrTexture.Light);
FDrTextureBitmap bitmapReflect = FindByTypeCd(EDrTexture.Reflect);
FDrTextureBitmap bitmapRefract = FindByTypeCd(EDrTexture.Refract);
FDrTextureBitmap bitmapEmissive = FindByTypeCd(EDrTexture.Emissive);
if ((null != bitmapLight) || (null != bitmapReflect) || (null != bitmapRefract) || (null != bitmapEmissive))
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.PackLight);
bytes.WriteInt16(0);
using (FPngMerger merger = new FPngMerger()) {
if (null != bitmapLight)
{
merger.LoadRFile(path + bitmapLight.Source);
}
if (null != bitmapReflect)
{
merger.LoadGFile(path + bitmapReflect.Source);
}
if (null != bitmapRefract)
{
merger.LoadBFile(path + bitmapRefract.Source);
}
if (null != bitmapEmissive)
{
merger.LoadAlphaFile(path + bitmapEmissive.Source);
}
Bitmap bitmap = merger.MergeAll();
using (FIndexBitmap resource = new FIndexBitmap(bitmap)) {
resource.OptionAlpha = true;
resource.SerializeIndexed(bytes, EDrTexture.SplitColorCount, EDrTexture.SplitPixelCount);
}
}
}
// 输出环境纹理
FDrTextureBitmap bitmapEnvironment = FindByTypeCd(EDrTexture.Environment);
if (null != bitmapEnvironment)
{
bitmapCount++;
bytes.WriteInt8(EDrTexture.Environment);
bytes.WriteInt16(0);
Bitmap bitmap = new Bitmap(path + bitmapEnvironment.Source);
int size = bitmap.Height;
int block = bitmap.Width / bitmap.Height;
Bitmap cubeBitmap = new Bitmap(bitmap.Height, bitmap.Width, PixelFormat.Format32bppArgb);
using (Graphics g = Graphics.FromImage(cubeBitmap)) {
for (int n = 0; n < 6; n++)
{
g.DrawImage(bitmap,
new Rectangle(0, size * n, size, size),
new Rectangle(size * n, 0, size, size),
GraphicsUnit.Pixel);
}
}
using (FIndexBitmap resource = new FIndexBitmap(cubeBitmap)) {
resource.OptionAlpha = true;
resource.SerializeIndexed(bytes, EDrTexture.SplitColorCount, EDrTexture.SplitPixelCount);
}
cubeBitmap.Dispose();
}
// 输出纹理列表
output.WriteInt16((sbyte)bitmapCount);
output.WriteBytes(bytes.Memory, 0, bytes.Length);
}