//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using Newtonsoft.Json.Linq;
using Pfim;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Runtime.InteropServices;
using TGASharpLib;
namespace MobiusEditor.Utility
{
public class TextureManager
{
#if false
private class ImageData
{
public TGA TGA;
public JObject Metadata;
}
#endif
private readonly MegafileManager megafileManager;
private Dictionary<string, Bitmap> cachedTextures = new Dictionary<string, Bitmap>();
private Dictionary<(string, TeamColor), (Bitmap, Rectangle)> teamColorTextures = new Dictionary<(string, TeamColor), (Bitmap, Rectangle)>();
public TextureManager(MegafileManager megafileManager)
{
this.megafileManager = megafileManager;
}
public void Reset()
{
cachedTextures.Clear();
teamColorTextures.Clear();
}
public (Bitmap, Rectangle) GetTexture(string filename, TeamColor teamColor)
{
if (teamColorTextures.TryGetValue((filename, teamColor), out (Bitmap bitmap, Rectangle opaqueBounds) result))
{
return result;
}
if (!cachedTextures.TryGetValue(filename, out result.bitmap))
{
if (Path.GetExtension(filename).ToLower() == ".tga")
{
TGA tga = null;
JObject metadata = null;
// First attempt to find the texture in an archive
var name = Path.GetFileNameWithoutExtension(filename);
var archiveDir = Path.GetDirectoryName(filename);
var archivePath = archiveDir + ".ZIP";
using (var fileStream = megafileManager.Open(archivePath))
{
if (fileStream != null)
{
using (var archive = new ZipArchive(fileStream, ZipArchiveMode.Read))
{
foreach (var entry in archive.Entries)
{
if (name == Path.GetFileNameWithoutExtension(entry.Name))
{
if ((tga == null) && (Path.GetExtension(entry.Name).ToLower() == ".tga"))
{
using (var stream = entry.Open())
using (var memStream = new MemoryStream())
{
stream.CopyTo(memStream);
tga = new TGA(memStream);
}
}
else if ((metadata == null) && (Path.GetExtension(entry.Name).ToLower() == ".meta"))
{
using (var stream = entry.Open())
using (var reader = new StreamReader(stream))
{
metadata = JObject.Parse(reader.ReadToEnd());
}
}
if ((tga != null) && (metadata != null))
{
break;
}
}
}
}
}
}
// Next attempt to load a standalone file
if (tga == null)
{
using (var fileStream = megafileManager.Open(filename))
{
if (fileStream != null)
{
tga = new TGA(fileStream);
}
}
}
if (tga != null)
{
var bitmap = tga.ToBitmap(true);
if (metadata != null)
{
var size = new Size(metadata["size"][0].ToObject<int>(), metadata["size"][1].ToObject<int>());
var crop = Rectangle.FromLTRB(
metadata["crop"][0].ToObject<int>(),
metadata["crop"][1].ToObject<int>(),
metadata["crop"][2].ToObject<int>(),
metadata["crop"][3].ToObject<int>()
);
var uncroppedBitmap = new Bitmap(size.Width, size.Height, bitmap.PixelFormat);
using (var g = Graphics.FromImage(uncroppedBitmap))
{
g.DrawImage(bitmap, crop, new Rectangle(Point.Empty, bitmap.Size), GraphicsUnit.Pixel);
}
cachedTextures[filename] = uncroppedBitmap;
}
else
{
cachedTextures[filename] = bitmap;
}
}
#if false
// Attempt to load parent directory as archive
var archiveDir = Path.GetDirectoryName(filename);
var archivePath = archiveDir + ".ZIP";
using (var fileStream = megafileManager.Open(archivePath))
{
if (fileStream != null)
{
using (var archive = new ZipArchive(fileStream, ZipArchiveMode.Read))
{
var images = new Dictionary<string, ImageData>();
foreach (var entry in archive.Entries)
{
var name = Path.GetFileNameWithoutExtension(entry.Name);
if (!images.TryGetValue(name, out ImageData imageData))
{
imageData = images[name] = new ImageData { TGA = null, Metadata = null };
}
if ((imageData.TGA == null) && (Path.GetExtension(entry.Name).ToLower() == ".tga"))
{
using (var stream = entry.Open())
using (var memStream = new MemoryStream())
{
stream.CopyTo(memStream);
imageData.TGA = new TGA(memStream);
}
}
else if ((imageData.Metadata == null) && (Path.GetExtension(entry.Name).ToLower() == ".meta"))
{
using (var stream = entry.Open())
using (var reader = new StreamReader(stream))
{
imageData.Metadata = JObject.Parse(reader.ReadToEnd());
}
}
if ((imageData.TGA != null) && (imageData.Metadata != null))
{
var bitmap = imageData.TGA.ToBitmap(true);
var size = new Size(imageData.Metadata["size"][0].ToObject<int>(), imageData.Metadata["size"][1].ToObject<int>());
var crop = Rectangle.FromLTRB(
imageData.Metadata["crop"][0].ToObject<int>(),
imageData.Metadata["crop"][1].ToObject<int>(),
imageData.Metadata["crop"][2].ToObject<int>(),
imageData.Metadata["crop"][3].ToObject<int>()
);
var uncroppedBitmap = new Bitmap(size.Width, size.Height, bitmap.PixelFormat);
using (var g = Graphics.FromImage(uncroppedBitmap))
{
g.DrawImage(bitmap, crop, new Rectangle(Point.Empty, bitmap.Size), GraphicsUnit.Pixel);
}
cachedTextures[Path.Combine(archiveDir, name) + ".tga"] = uncroppedBitmap;
images.Remove(name);
}
}
foreach (var item in images.Where(x => x.Value.TGA != null))
{
cachedTextures[Path.Combine(archiveDir, item.Key) + ".tga"] = item.Value.TGA.ToBitmap(true);
}
}
}
}
#endif
}
if (!cachedTextures.TryGetValue(filename, out result.bitmap))
{
// Try loading as a DDS
var ddsFilename = Path.ChangeExtension(filename, ".DDS");
using (var fileStream = megafileManager.Open(ddsFilename))
{
if (fileStream != null)
{
var bytes = new byte[fileStream.Length];
fileStream.Read(bytes, 0, bytes.Length);
using (var image = Dds.Create(bytes, new PfimConfig()))
{
PixelFormat format;
switch (image.Format)
{
case Pfim.ImageFormat.Rgb24:
format = PixelFormat.Format24bppRgb;
break;
case Pfim.ImageFormat.Rgba32:
format = PixelFormat.Format32bppArgb;
break;
case Pfim.ImageFormat.R5g5b5:
format = PixelFormat.Format16bppRgb555;
break;
case Pfim.ImageFormat.R5g6b5:
format = PixelFormat.Format16bppRgb565;
break;
case Pfim.ImageFormat.R5g5b5a1:
format = PixelFormat.Format16bppArgb1555;
break;
case Pfim.ImageFormat.Rgb8:
format = PixelFormat.Format8bppIndexed;
break;
default:
format = PixelFormat.DontCare;
break;
}
var bitmap = new Bitmap(image.Width, image.Height, format);
var bitmapData = bitmap.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.WriteOnly, bitmap.PixelFormat);
Marshal.Copy(image.Data, 0, bitmapData.Scan0, image.Stride * image.Height);
bitmap.UnlockBits(bitmapData);
cachedTextures[filename] = bitmap;
}
}
}
}
}
if (!cachedTextures.TryGetValue(filename, out result.bitmap))
{
return result;
}
result.bitmap = new Bitmap(result.bitmap);
result.opaqueBounds = new Rectangle(0, 0, result.bitmap.Width, result.bitmap.Height);
if (teamColor != null)
{
float frac(float x) => x - (int)x;
float lerp(float x, float y, float t) => (x * (1.0f - t)) + (y * t);
float saturate(float x) => Math.Max(0.0f, Math.Min(1.0f, x));
BitmapData data = null;
try
{
data = result.bitmap.LockBits(new Rectangle(0, 0, result.bitmap.Width, result.bitmap.Height), ImageLockMode.ReadWrite, result.bitmap.PixelFormat);
var bpp = Image.GetPixelFormatSize(data.PixelFormat) / 8;
var bytes = new byte[data.Stride * data.Height];
Marshal.Copy(data.Scan0, bytes, 0, bytes.Length);
result.opaqueBounds = CalculateOpaqueBounds(bytes, data.Width, data.Height, bpp, data.Stride);
for (int j = 0; j < bytes.Length; j += bpp)
{
var pixel = Color.FromArgb(bytes[j + 2], bytes[j + 1], bytes[j + 0]);
(float r, float g, float b) = (pixel.R.ToLinear(), pixel.G.ToLinear(), pixel.B.ToLinear());
(float x, float y, float z, float w) K = (0.0f, -1.0f / 3.0f, 2.0f / 3.0f, -1.0f);
(float x, float y, float z, float w) p = (g >= b) ? (g, b, K.x, K.y) : (b, g, K.w, K.z);
(float x, float y, float z, float w) q = (r >= p.x) ? (r, p.y, p.z, p.x) : (p.x, p.y, p.w, r);
(float d, float e) = (q.x - Math.Min(q.w, q.y), 1e-10f);
(float hue, float saturation, float value) = (Math.Abs(q.z + (q.w - q.y) / (6.0f * d + e)), d / (q.x + e), q.x);
var lowerHue = teamColor.LowerBounds.GetHue() / 360.0f;
var upperHue = teamColor.UpperBounds.GetHue() / 360.0f;
if ((hue >= lowerHue) && (upperHue >= hue))
{
hue = (hue / (upperHue - lowerHue)) * ((upperHue + teamColor.Fudge) - (lowerHue - teamColor.Fudge));
hue += teamColor.HSVShift.X;
saturation += teamColor.HSVShift.Y;
value += teamColor.HSVShift.Z;
(float x, float y, float z, float w) L = (1.0f, 2.0f / 3.0f, 1.0f / 3.0f, 3.0f);
(float x, float y, float z) m = (
Math.Abs(frac(hue + L.x) * 6.0f - L.w),
Math.Abs(frac(hue + L.y) * 6.0f - L.w),
Math.Abs(frac(hue + L.z) * 6.0f - L.w)
);
r = value * lerp(L.x, saturate(m.x - L.x), saturation);
g = value * lerp(L.x, saturate(m.y - L.x), saturation);
b = value * lerp(L.x, saturate(m.z - L.x), saturation);
(float x, float y, float z) n = (
Math.Min(1.0f, Math.Max(0.0f, r - teamColor.InputLevels.X) / (teamColor.InputLevels.Z - teamColor.InputLevels.X)),
Math.Min(1.0f, Math.Max(0.0f, g - teamColor.InputLevels.X) / (teamColor.InputLevels.Z - teamColor.InputLevels.X)),
Math.Min(1.0f, Math.Max(0.0f, b - teamColor.InputLevels.X) / (teamColor.InputLevels.Z - teamColor.InputLevels.X))
);
n.x = (float)Math.Pow(n.x, teamColor.InputLevels.Y);
n.y = (float)Math.Pow(n.y, teamColor.InputLevels.Y);
n.z = (float)Math.Pow(n.z, teamColor.InputLevels.Y);
r = lerp(teamColor.OutputLevels.X, teamColor.OutputLevels.Y, n.x);
g = lerp(teamColor.OutputLevels.X, teamColor.OutputLevels.Y, n.y);
b = lerp(teamColor.OutputLevels.X, teamColor.OutputLevels.Y, n.z);
}
(float x, float y, float z) n2 = (
Math.Min(1.0f, Math.Max(0.0f, r - teamColor.OverallInputLevels.X) / (teamColor.OverallInputLevels.Z - teamColor.OverallInputLevels.X)),
Math.Min(1.0f, Math.Max(0.0f, g - teamColor.OverallInputLevels.X) / (teamColor.OverallInputLevels.Z - teamColor.OverallInputLevels.X)),
Math.Min(1.0f, Math.Max(0.0f, b - teamColor.OverallInputLevels.X) / (teamColor.OverallInputLevels.Z - teamColor.OverallInputLevels.X))
);
n2.x = (float)Math.Pow(n2.x, teamColor.OverallInputLevels.Y);
n2.y = (float)Math.Pow(n2.y, teamColor.OverallInputLevels.Y);
n2.z = (float)Math.Pow(n2.z, teamColor.OverallInputLevels.Y);
r = lerp(teamColor.OverallOutputLevels.X, teamColor.OverallOutputLevels.Y, n2.x);
g = lerp(teamColor.OverallOutputLevels.X, teamColor.OverallOutputLevels.Y, n2.y);
b = lerp(teamColor.OverallOutputLevels.X, teamColor.OverallOutputLevels.Y, n2.z);
bytes[j + 2] = (byte)(r.ToSRGB() * 255.0f);
bytes[j + 1] = (byte)(g.ToSRGB() * 255.0f);
bytes[j + 0] = (byte)(b.ToSRGB() * 255.0f);
}
Marshal.Copy(bytes, 0, data.Scan0, bytes.Length);
}
finally
{
if (data != null)
{
result.bitmap.UnlockBits(data);
}
}
}
else
{
result.opaqueBounds = CalculateOpaqueBounds(result.bitmap);
}
teamColorTextures[(filename, teamColor)] = result;
return result;
}
private static Rectangle CalculateOpaqueBounds(byte[] data, int width, int height, int bpp, int stride)
{
bool isTransparentRow(int y)
{
var start = y * stride;
for (var i = bpp - 1; i < stride; i += bpp)
{
if (data[start + i] != 0)
{
return false;
}
}
return true;
}
var opaqueBounds = new Rectangle(0, 0, width, height);
for (int y = 0; y < height; ++y)
{
if (!isTransparentRow(y))
{
opaqueBounds.Offset(0, y);
break;
}
}
for (int y = height; y > 0; --y)
{
if (!isTransparentRow(y - 1))
{
opaqueBounds.Height = y - opaqueBounds.Top;
break;
}
}
bool isTransparentColumn(int x)
{
var start = (x * bpp) + (bpp - 1);
for (var y = opaqueBounds.Top; y < opaqueBounds.Bottom; ++y)
{
if (data[start + (y * stride)] != 0)
{
return false;
}
}
return true;
}
for (int x = 0; x < width; ++x)
{
if (!isTransparentColumn(x))
{
opaqueBounds.Offset(x, 0);
break;
}
}
for (int x = width; x > 0; --x)
{
if (!isTransparentColumn(x - 1))
{
opaqueBounds.Width = x - opaqueBounds.Left;
break;
}
}
return opaqueBounds;
}
private static Rectangle CalculateOpaqueBounds(Bitmap bitmap)
{
BitmapData data = null;
try
{
data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmap.PixelFormat);
var bpp = Image.GetPixelFormatSize(data.PixelFormat) / 8;
var bytes = new byte[data.Stride * data.Height];
Marshal.Copy(data.Scan0, bytes, 0, bytes.Length);
return CalculateOpaqueBounds(bytes, data.Width, data.Height, bpp, data.Stride);
}
finally
{
if (data != null)
{
bitmap.UnlockBits(data);
}
}
}
}
}