//============================================================
// <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);
}
//============================================================
// <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>
//
// @params output 输出流
// @params colorQuantizer 颜色优化器
// @params rect 序列化的矩形区域
// @params colorCount 颜色数量
//============================================================
protected bool SerializeUnpack(IOutput output, IColorQuantizer colorQuantizer, SIntRectangle rect, int colorCount)
{
FByteStream stream = new FByteStream();
int blockWidth = rect.Width;
int blockHeight = rect.Height;
// 输入属性
stream.WriteBool(_optionAlpha);
stream.WriteInt16((short)blockWidth);
stream.WriteInt16((short)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.");
colorList = colorQuantizer.MakePalette(colorCount);
return(false);
}
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);
}