mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-11-23 20:32:34 +00:00
292 lines
9.6 KiB
C#
Executable file
292 lines
9.6 KiB
C#
Executable file
|
|
#region ================== Copyright (c) 2007 Pascal vd Heiden
|
|
|
|
/*
|
|
* Copyright (c) 2007 Pascal vd Heiden, www.codeimp.com
|
|
* This program is released under GNU General Public License
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#endregion
|
|
|
|
#region ================== Namespaces
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using CodeImp.DoomBuilder.Rendering;
|
|
using System.IO;
|
|
using System.Linq;
|
|
|
|
#endregion
|
|
|
|
namespace CodeImp.DoomBuilder.Data
|
|
{
|
|
internal sealed unsafe class TextureImage : ImageData
|
|
{
|
|
#region ================== Variables
|
|
|
|
private List<TexturePatch> patches;
|
|
|
|
#endregion
|
|
|
|
#region ================== Constructor / Disposer
|
|
|
|
// Constructor
|
|
public TextureImage(string group, string name, int width, int height, float scalex, float scaley, bool worldpanning)
|
|
{
|
|
// Initialize
|
|
this.width = width;
|
|
this.height = height;
|
|
this.scale.x = scalex;
|
|
this.scale.y = scaley;
|
|
this.worldpanning = worldpanning; //mxd
|
|
this.patches = new List<TexturePatch>();
|
|
SetName(name);
|
|
virtualname = "[" + group + "]/" + this.name; //mxd
|
|
|
|
// We have no destructor
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Methods
|
|
|
|
// This adds a patch to the texture
|
|
public void AddPatch(TexturePatch patch)
|
|
{
|
|
// Add it
|
|
patches.Add(patch);
|
|
|
|
if(patch.LumpName == Name) hasPatchWithSameName = true; //mxd
|
|
}
|
|
|
|
// This loads the image
|
|
protected override LocalLoadResult LocalLoadImage()
|
|
{
|
|
// Checks
|
|
if(width == 0 || height == 0) return new LocalLoadResult(null);
|
|
|
|
BitmapData bitmapdata = null;
|
|
PixelColor* pixels = (PixelColor*)0;
|
|
|
|
Bitmap bitmap = null;
|
|
List<LogMessage> messages = new List<LogMessage>();
|
|
int[] columnumpatches = new int[width];
|
|
BitArray columnmasked = new BitArray(width, false);
|
|
bool hasnegativeoffsetpatch = false;
|
|
Dictionary<TexturePatch, Bitmap> patchbmps = new Dictionary<TexturePatch, Bitmap>();
|
|
|
|
bool fixnegativeoffsets = General.Map.Config.Compatibility.FixNegativePatchOffsets;
|
|
bool fixmaskedoffsets = General.Map.Config.Compatibility.FixMaskedPatchOffsets;
|
|
|
|
// Create texture bitmap
|
|
try
|
|
{
|
|
if(bitmap != null) bitmap.Dispose();
|
|
bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
|
|
bitmapdata = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
|
|
pixels = (PixelColor*)bitmapdata.Scan0.ToPointer();
|
|
General.ZeroPixels(pixels, width * height);
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
// Unable to make bitmap
|
|
messages.Add(new LogMessage(ErrorType.Error, "Unable to load texture image \"" + this.Name + "\". " + e.GetType().Name + ": " + e.Message));
|
|
}
|
|
|
|
int missingpatches = 0; //mxd
|
|
|
|
if(!messages.Any(x => x.Type == ErrorType.Error))
|
|
{
|
|
// Load all patch bitmaps, and see if the patch has a negative vertical offset
|
|
foreach (TexturePatch p in patches)
|
|
{
|
|
// Get the patch data stream
|
|
string patchlocation = string.Empty; //mxd
|
|
Stream patchdata = General.Map.Data.GetPatchData(p.LumpName, p.HasLongName, ref patchlocation);
|
|
if (patchdata != null)
|
|
{
|
|
// Get a reader for the data
|
|
Bitmap patchbmp = ImageDataFormat.TryLoadImage(patchdata, ImageDataFormat.DOOMPICTURE, General.Map.Data.Palette);
|
|
if (patchbmp == null)
|
|
{
|
|
//mxd. Probably that's a flat?..
|
|
if (General.Map.Config.MixTexturesFlats)
|
|
{
|
|
patchbmp = ImageDataFormat.TryLoadImage(patchdata, ImageDataFormat.DOOMFLAT, General.Map.Data.Palette);
|
|
}
|
|
if (patchbmp == null)
|
|
{
|
|
// Data is in an unknown format!
|
|
messages.Add(new LogMessage(ErrorType.Error, "Patch lump \"" + Path.Combine(patchlocation, p.LumpName) + "\" data format could not be read, while loading texture \"" + this.Name + "\". Does this lump contain valid picture data at all?"));
|
|
missingpatches++; //mxd
|
|
}
|
|
}
|
|
|
|
// Store the bitmap
|
|
patchbmps[p] = patchbmp;
|
|
|
|
// Done
|
|
patchdata.Dispose();
|
|
}
|
|
else
|
|
{
|
|
// Missing a patch lump!
|
|
messages.Add(new LogMessage(ErrorType.Error, "Missing patch lump \"" + p.LumpName + "\" while loading texture \"" + this.Name + "\". Did you forget to include required resources?"));
|
|
missingpatches++; //mxd
|
|
}
|
|
|
|
// Check if there are any patches with negative vertical offsets
|
|
if (p.Y < 0)
|
|
hasnegativeoffsetpatch = true;
|
|
}
|
|
|
|
// There's a bug in vanilla Doom where negative patch offsets are ignored (the patch y offset is set to 0). If
|
|
// the configuration is for an engine that doesn't fix the bug we have to emulate that behavior
|
|
// See https://doomwiki.org/wiki/Vertical_offsets_are_ignored_in_texture_patches
|
|
if (!fixnegativeoffsets || !fixmaskedoffsets)
|
|
{
|
|
// Check which columns have more than one patch
|
|
foreach(TexturePatch p in patches)
|
|
{
|
|
if (!patchbmps.ContainsKey(p) || patchbmps[p] == null) continue;
|
|
|
|
bool ismaked = BitmapIsMasked(patchbmps[p]);
|
|
|
|
for (int x = 0; x < patchbmps[p].Width; x++)
|
|
{
|
|
int ox = p.X + x;
|
|
if (ox >= 0 && ox < columnumpatches.Length)
|
|
{
|
|
if(!fixnegativeoffsets)
|
|
columnumpatches[ox]++;
|
|
|
|
if (!fixmaskedoffsets && ismaked)
|
|
columnmasked[ox] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Go for all patches
|
|
foreach(TexturePatch p in patches)
|
|
{
|
|
if(patchbmps.ContainsKey(p) && patchbmps[p] != null)
|
|
{
|
|
// Draw the patch
|
|
DrawToPixelData(patchbmps[p], pixels, width, height, p.X, p.Y, fixnegativeoffsets, fixmaskedoffsets, columnumpatches, columnmasked);
|
|
}
|
|
}
|
|
|
|
// Don't need the bitmaps anymore
|
|
foreach (Bitmap bmp in patchbmps.Values)
|
|
bmp?.Dispose();
|
|
|
|
// Done
|
|
bitmap.UnlockBits(bitmapdata);
|
|
}
|
|
|
|
// Dispose bitmap if load failed
|
|
if((bitmap != null) && (messages.Any(x => x.Type == ErrorType.Error) || missingpatches >= patches.Count)) //mxd. We can still display texture if at least one of the patches was loaded
|
|
{
|
|
bitmap.Dispose();
|
|
bitmap = null;
|
|
}
|
|
|
|
return new LocalLoadResult(bitmap, messages);
|
|
}
|
|
|
|
// This draws the picture to the given pixel color data
|
|
static unsafe void DrawToPixelData(Bitmap bmp, PixelColor* target, int targetwidth, int targetheight, int x, int y, bool fixnegativeoffsets, bool fixmaskedoffsets, int[] columnumpatches, BitArray columnmasked)
|
|
{
|
|
// Get bitmap
|
|
int width = bmp.Size.Width;
|
|
int height = bmp.Size.Height;
|
|
int patchy = y;
|
|
|
|
// Lock bitmap pixels
|
|
BitmapData bmpdata = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
|
|
PixelColor* pixels = (PixelColor*)bmpdata.Scan0.ToPointer();
|
|
|
|
// Go for all pixels in the original image
|
|
for (int ox = 0; ox < width; ox++)
|
|
{
|
|
int tx = x + ox;
|
|
int drawheight = height;
|
|
|
|
// If we have to emulate the negative vertical offset bug we also have to recalculate the height of the
|
|
// patch that is actually drawn, since it'll only draw as many pixels as it'd draw as if the negative
|
|
// vertical offset was taken into account
|
|
if ((patchy < 0 && !fixnegativeoffsets && tx < width && tx >= 0 && tx < columnumpatches.Length && columnumpatches[tx] > 1) && !(!fixmaskedoffsets && tx >= 0 && tx < columnmasked.Length && columnmasked[tx] == true))
|
|
drawheight = height + patchy;
|
|
|
|
for (int oy = 0; oy < drawheight; oy++)
|
|
{
|
|
// Copy this pixel?
|
|
if (pixels[oy * width + ox].a > 0.5f)
|
|
{
|
|
int realy = y;
|
|
|
|
if (!fixmaskedoffsets && tx >= 0 && tx < columnmasked.Length && columnmasked[tx] == true)
|
|
{
|
|
if (tx >= 0 && tx < columnumpatches.Length && columnumpatches[tx] == 1)
|
|
realy = 0;
|
|
}
|
|
else if (y < 0 && !fixnegativeoffsets)
|
|
realy = 0;
|
|
|
|
// Calculate target pixel and copy when within bounds
|
|
int ty = realy + oy;
|
|
if ((tx >= 0) && (tx < targetwidth) && (ty >= 0) && (ty < targetheight))
|
|
target[ty * targetwidth + tx] = pixels[oy * width + ox];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Done
|
|
bmp.UnlockBits(bmpdata);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the given bitmap has masked pixels
|
|
/// </summary>
|
|
/// <param name="bmp">Bitmap to check</param>
|
|
/// <returns>true if masked, false if not masked</returns>
|
|
internal static unsafe bool BitmapIsMasked(Bitmap bmp)
|
|
{
|
|
// Get bitmap
|
|
int width = bmp.Size.Width;
|
|
int height = bmp.Size.Height;
|
|
|
|
// Lock bitmap pixels
|
|
BitmapData bmpdata = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
|
|
PixelColor* pixels = (PixelColor*)bmpdata.Scan0.ToPointer();
|
|
|
|
for (int ox = 0; ox < width; ox++)
|
|
{
|
|
for (int oy = 0; oy < height; oy++)
|
|
{
|
|
if (pixels[oy * width + ox].a <= 0.5f)
|
|
{
|
|
bmp.UnlockBits(bmpdata);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
bmp.UnlockBits(bmpdata);
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|