epic/OpenRA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Changed HardwarePalette.ApplyModifiers to be more efficient.

Browse Source 
- Add separate ImmutablePalette and MutablePalette classes since the distinction is extremely important to HardwarePalette.
- Keep a cache of palettes in HardwarePalette to avoid reallocation them every time ApplyModifiers is called.
- Palettes that are not allowed to be modified are copied to the buffer once when added, rather than every time ApplyModifiers is called.
- The AdjustPalette method now takes a read-only dictionary to prevent the dictionary being messed with.
- Added a constant for the palette size to remove its usage as a magic number in several areas.
- The ColorPreviewManagerWidget is annoying in that it needs to actually permanently update a palette after it has been added. To allow this, HardwarePalette now allows a palette to be replaced after initialization. The WorldRenderer therefore now also updates the PaletteReference it created earlier with the new palette to prevent stale data being used elsewhere.
This commit is contained in:
RoosterDragon
2014-06-16 20:25:05 +01:00
parent 5c82fff0ef
commit 7030d8b2b6
36 changed files with 327 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
OpenRA.Editor/Form1.cs
View File

@@ -153,11 +153,11 @@ namespace OpenRA.Editor
tileset = Program.Rules.TileSets[map.Tileset];
tilesetRenderer = new TileSetRenderer(tileset, modData.Manifest.TileSize);
var shadowIndex = new int[] { 3, 4 };
var palette = new Palette(GlobalFileSystem.Open(tileset.Palette), shadowIndex);
var palette = new ImmutablePalette(GlobalFileSystem.Open(tileset.Palette), shadowIndex);
// required for desert terrain in RA
var playerPalette = tileset.PlayerPalette ?? tileset.Palette;
var shadowedPalette = new Palette(GlobalFileSystem.Open(playerPalette), shadowIndex);
var shadowedPalette = new ImmutablePalette(GlobalFileSystem.Open(playerPalette), shadowIndex);
surface1.Bind(map, tileset, tilesetRenderer, palette, shadowedPalette);

6
OpenRA.Editor/RenderUtils.cs
View File

@@ -20,7 +20,7 @@ namespace OpenRA.Editor
{
static class RenderUtils
{
static Bitmap RenderShp(ISpriteSource shp, Palette p)
static Bitmap RenderShp(ISpriteSource shp, IPalette p)
{
var frame = shp.Frames.First();
@@ -45,7 +45,7 @@ namespace OpenRA.Editor
return bitmap;
}
public static ActorTemplate RenderActor(ActorInfo info, TileSet tileset, Palette p)
public static ActorTemplate RenderActor(ActorInfo info, TileSet tileset, IPalette p)
{
var image = RenderSprites.GetImage(info);
@@ -76,7 +76,7 @@ namespace OpenRA.Editor
}
}
public static ResourceTemplate RenderResourceType(ResourceTypeInfo info, string[] exts, Palette p)
public static ResourceTemplate RenderResourceType(ResourceTypeInfo info, string[] exts, IPalette p)
{
var image = info.EditorSprite;
using (var s = GlobalFileSystem.OpenWithExts(image, exts))

8
OpenRA.Editor/Surface.cs
View File

@@ -45,8 +45,8 @@ namespace OpenRA.Editor
public Map Map { get; private set; }
public TileSet TileSet { get; private set; }
public TileSetRenderer TileSetRenderer { get; private set; }
public Palette Palette { get; private set; }
public Palette PlayerPalette { get; private set; }
public IPalette Palette { get; private set; }
public IPalette PlayerPalette { get; private set; }
public int2 Offset;
public int2 GetOffset() { return Offset; }
@@ -81,7 +81,7 @@ namespace OpenRA.Editor
public Keys GetModifiers() { return ModifierKeys; }
public void Bind(Map m, TileSet ts, TileSetRenderer tsr, Palette p, Palette pp)
public void Bind(Map m, TileSet ts, TileSetRenderer tsr, IPalette p, IPalette pp)
{
Map = m;
TileSet = ts;
@@ -381,7 +381,7 @@ namespace OpenRA.Editor
var pr = Map.Players[name];
var pcpi = Program.Rules.Actors["player"].Traits.Get<PlayerColorPaletteInfo>();
var remap = new PlayerColorRemap(pcpi.RemapIndex, pr.Color, pcpi.Ramp);
return new Palette(PlayerPalette, remap).AsSystemPalette();
return new ImmutablePalette(PlayerPalette, remap).AsSystemPalette();
}
Cache<string, ColorPalette> playerPalettes;

2
OpenRA.Editor/TileSetRenderer.cs
View File

@@ -82,7 +82,7 @@ namespace OpenRA.Editor
templates.Add(t.Key, LoadTemplate(t.Value.Image, tileset.Extensions, sourceCache, t.Value.Frames));
}
public Bitmap RenderTemplate(ushort id, Palette p)
public Bitmap RenderTemplate(ushort id, IPalette p)
{
var template = TileSet.Templates[id];
var templateData = templates[id];

5
OpenRA.Game/Graphics/CursorProvider.cs
View File

@@ -41,7 +41,7 @@ namespace OpenRA.Graphics
palette = new HardwarePalette();
foreach (var p in nodesDict["Palettes"].Nodes)
palette.AddPalette(p.Key, new Palette(GlobalFileSystem.Open(p.Value.Value), shadowIndex), false);
palette.AddPalette(p.Key, new ImmutablePalette(GlobalFileSystem.Open(p.Value.Value), shadowIndex), false);
var spriteLoader = new SpriteLoader(new string[0], new SheetBuilder(SheetType.Indexed));
foreach (var s in nodesDict["Cursors"].Nodes)
@@ -53,9 +53,6 @@ namespace OpenRA.Graphics
PaletteReference CreatePaletteReference(string name)
{
var pal = palette.GetPalette(name);
if (pal == null)
throw new InvalidOperationException("Palette `{0}` does not exist".F(name));
return new PaletteReference(name, palette.GetPaletteIndex(name), pal);
}

102
OpenRA.Game/Graphics/HardwarePalette.cs
View File

@@ -1,6 +1,6 @@
#region Copyright & License Information
/*
* Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
* Copyright 2007-2014 The OpenRA Developers (see AUTHORS)
* This file is part of OpenRA, which is free software. It is made
* available to you under the terms of the GNU General Public License
* as published by the Free Software Foundation. For more information,
@@ -10,7 +10,6 @@
using System;
using System.Collections.Generic;
using System.Linq;
using OpenRA.Traits;
namespace OpenRA.Graphics
@@ -18,70 +17,101 @@ namespace OpenRA.Graphics
public class HardwarePalette
{
public const int MaxPalettes = 256;
int allocated = 0;
public ITexture Texture { get; private set; }
Dictionary<string, Palette> palettes;
Dictionary<string, int> indices;
Dictionary<string, bool> allowsMods;
readonly Dictionary<string, ImmutablePalette> palettes = new Dictionary<string, ImmutablePalette>();
readonly Dictionary<string, MutablePalette> modifiablePalettes = new Dictionary<string, MutablePalette>();
readonly IReadOnlyDictionary<string, MutablePalette> readOnlyModifiablePalettes;
readonly Dictionary<string, int> indices = new Dictionary<string, int>();
readonly uint[,] buffer = new uint[Palette.Size, MaxPalettes];
public HardwarePalette()
{
palettes = new Dictionary<string, Palette>();
indices = new Dictionary<string, int>();
allowsMods = new Dictionary<string, bool>();
Texture = Game.Renderer.Device.CreateTexture();
readOnlyModifiablePalettes = modifiablePalettes.AsReadOnly();
}
public Palette GetPalette(string name)
public IPalette GetPalette(string name)
{
Palette ret;
if (!palettes.TryGetValue(name,out ret))
throw new InvalidOperationException("Palette `{0}` does not exist".F(name));
return ret;
MutablePalette mutable;
if (modifiablePalettes.TryGetValue(name, out mutable))
return mutable.AsReadOnly();
ImmutablePalette immutable;
if (palettes.TryGetValue(name, out immutable))
return immutable;
throw new InvalidOperationException("Palette `{0}` does not exist".F(name));
}
public int GetPaletteIndex(string name)
{
int ret;
if (!indices.TryGetValue(name,out ret))
if (!indices.TryGetValue(name, out ret))
throw new InvalidOperationException("Palette `{0}` does not exist".F(name));
return ret;
}
public void AddPalette(string name, Palette p, bool allowModifiers)
public void AddPalette(string name, ImmutablePalette p, bool allowModifiers)
{
if (palettes.Count >= MaxPalettes)
throw new InvalidOperationException("Limit of {0} palettes reached. Cannot add {1}.".F(MaxPalettes, name));
if (palettes.ContainsKey(name))
throw new InvalidOperationException("Palette {0} has already been defined".F(name));
int index = palettes.Count;
indices.Add(name, index);
palettes.Add(name, p);
indices.Add(name, allocated++);
allowsMods.Add(name, allowModifiers);
if (allowModifiers)
modifiablePalettes.Add(name, new MutablePalette(p));
else
CopyPaletteToBuffer(index, p);
}
uint[,] data = new uint[MaxPalettes, 256];
public void ApplyModifiers(IEnumerable<IPaletteModifier> paletteMods)
public void ReplacePalette(string name, IPalette p)
{
var copy = palettes.ToDictionary(p => p.Key, p => new Palette(p.Value));
var modifiable = copy.Where(p => allowsMods[p.Key]).ToDictionary(p => p.Key, p => p.Value);
foreach (var mod in paletteMods)
mod.AdjustPalette(modifiable);
foreach (var pal in copy)
{
var j = indices[pal.Key];
var c = pal.Value.Values;
for (var i = 0; i < 256; i++)
data[j,i] = c[i];
}
Texture.SetData(data);
if (modifiablePalettes.ContainsKey(name))
CopyPaletteToBuffer(indices[name], modifiablePalettes[name] = new MutablePalette(p));
else if (palettes.ContainsKey(name))
CopyPaletteToBuffer(indices[name], palettes[name] = new ImmutablePalette(p));
else
throw new InvalidOperationException("Palette `{0}` does not exist".F(name));
Texture.SetData(buffer);
}
public void Initialize()
{
ApplyModifiers(new IPaletteModifier[] {});
CopyModifiablePalettesToBuffer();
Texture.SetData(buffer);
}
void CopyPaletteToBuffer(int index, IPalette p)
{
for (var i = 0; i < Palette.Size; i++)
buffer[i, index] = p[i];
}
void CopyModifiablePalettesToBuffer()
{
foreach (var kvp in modifiablePalettes)
CopyPaletteToBuffer(indices[kvp.Key], kvp.Value);
}
public void ApplyModifiers(IEnumerable<IPaletteModifier> paletteMods)
{
foreach (var mod in paletteMods)
mod.AdjustPalette(readOnlyModifiablePalettes);
// Update our texture with the changes.
CopyModifiablePalettesToBuffer();
Texture.SetData(buffer);
// Reset modified palettes back to their original colors, ready for next time.
foreach (var kvp in modifiablePalettes)
{
var originalPalette = palettes[kvp.Key];
var modifiedPalette = kvp.Value;
for (var i = 0; i < Palette.Size; i++)
modifiedPalette[i] = originalPalette[i];
}
}
}
}

201
OpenRA.Game/Graphics/Palette.cs
View File

@@ -1,6 +1,6 @@
#region Copyright & License Information
/*
* Copyright 2007-2012 The OpenRA Developers (see AUTHORS)
* Copyright 2007-2014 The OpenRA Developers (see AUTHORS)
* This file is part of OpenRA, which is free software. It is made
* available to you under the terms of the GNU General Public License
* as published by the Free Software Foundation. For more information,
@@ -8,94 +8,35 @@
*/
#endregion
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
namespace OpenRA.Graphics
{
public class Palette
public interface IPalette { uint this[int index] { get; } }
public interface IPaletteRemap { Color GetRemappedColor(Color original, int index); }
public static class Palette
{
public static Palette Load(string filename, int[] remap)
public const int Size = 256;
public static Color GetColor(this IPalette palette, int index)
{
using (var s = File.OpenRead(filename))
return new Palette(s, remap);
return Color.FromArgb((int)palette[index]);
}
uint[] colors;
public Color GetColor(int index)
{
return Color.FromArgb((int)colors[index]);
}
public void SetColor(int index, Color color)
{
colors[index] = (uint)color.ToArgb();
}
public void SetColor(int index, uint color)
{
colors[index] = (uint)color;
}
public uint[] Values
{
get { return colors; }
}
public void ApplyRemap(IPaletteRemap r)
{
for (var i = 0; i < 256; i++)
colors[i] = (uint)r.GetRemappedColor(Color.FromArgb((int)colors[i]), i).ToArgb();
}
public Palette(Stream s, int[] remapShadow)
{
colors = new uint[256];
using (var reader = new BinaryReader(s))
{
for (var i = 0; i < 256; i++)
{
var r = (byte)(reader.ReadByte() << 2);
var g = (byte)(reader.ReadByte() << 2);
var b = (byte)(reader.ReadByte() << 2);
colors[i] = (uint)((255 << 24) | (r << 16) | (g << 8) | b);
}
}
colors[0] = 0; // convert black background to transparency
foreach (var i in remapShadow)
colors[i] = 140u << 24;
}
public Palette(Palette p, IPaletteRemap r)
{
colors = (uint[])p.colors.Clone();
ApplyRemap(r);
}
public Palette(Palette p)
{
colors = (uint[])p.colors.Clone();
}
public Palette(uint[] data)
{
if (data.Length != 256)
throw new InvalidDataException("Attempting to create palette with incorrect array size");
colors = (uint[])data.Clone();
}
public ColorPalette AsSystemPalette()
public static ColorPalette AsSystemPalette(this IPalette palette)
{
ColorPalette pal;
using (var b = new Bitmap(1, 1, PixelFormat.Format8bppIndexed))
pal = b.Palette;
for (var i = 0; i < 256; i++)
pal.Entries[i] = GetColor(i);
for (var i = 0; i < Size; i++)
pal.Entries[i] = palette.GetColor(i);
// hack around a mono bug -- the palette flags get set wrong.
if (Platform.CurrentPlatform != PlatformType.Windows)
@@ -105,22 +46,116 @@ namespace OpenRA.Graphics
return pal;
}
public Bitmap AsBitmap()
public static Bitmap AsBitmap(this IPalette palette)
{
var b = new Bitmap(256, 1, PixelFormat.Format32bppArgb);
var b = new Bitmap(Size, 1, PixelFormat.Format32bppArgb);
var data = b.LockBits(new Rectangle(0, 0, b.Width, b.Height),
ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
unsafe
{
var c = (uint*)data.Scan0;
for (var x = 0; x < 256; x++)
*(c + x) = colors[x];
}
var temp = new uint[Palette.Size];
for (int i = 0; i < temp.Length; i++)
temp[i] = palette[i];
Marshal.Copy((int[])(object)temp, 0, data.Scan0, Size);
b.UnlockBits(data);
return b;
}
public static IPalette AsReadOnly(this IPalette palette)
{
if (palette is ImmutablePalette)
return palette;
return new ReadOnlyPalette(palette);
}
class ReadOnlyPalette : IPalette
{
IPalette palette;
public ReadOnlyPalette(IPalette palette) { this.palette = palette; }
public uint this[int index] { get { return palette[index]; } }
}
}
public interface IPaletteRemap { Color GetRemappedColor(Color original, int index); }
public class ImmutablePalette : IPalette
{
readonly uint[] colors = new uint[Palette.Size];
public uint this[int index]
{
get { return colors[index]; }
}
public ImmutablePalette(string filename, int[] remap)
{
using (var s = File.OpenRead(filename))
LoadFromStream(s, remap);
}
public ImmutablePalette(Stream s, int[] remapShadow)
{
LoadFromStream(s, remapShadow);
}
void LoadFromStream(Stream s, int[] remapShadow)
{
using (var reader = new BinaryReader(s))
for (var i = 0; i < Palette.Size; i++)
{
var r = (byte)(reader.ReadByte() << 2);
var g = (byte)(reader.ReadByte() << 2);
var b = (byte)(reader.ReadByte() << 2);
colors[i] = (uint)((255 << 24) | (r << 16) | (g << 8) | b);
}
colors[0] = 0; // Convert black background to transparency.
foreach (var i in remapShadow)
colors[i] = 140u << 24;
}
public ImmutablePalette(IPalette p, IPaletteRemap r)
: this(p)
{
for (var i = 0; i < Palette.Size; i++)
colors[i] = (uint)r.GetRemappedColor(this.GetColor(i), i).ToArgb();
}
public ImmutablePalette(IPalette p)
{
for (int i = 0; i < Palette.Size; i++)
colors[i] = p[i];
}
public ImmutablePalette(IEnumerable<uint> sourceColors)
{
var i = 0;
foreach (var sourceColor in sourceColors)
colors[i++] = sourceColor;
}
}
public class MutablePalette : IPalette
{
readonly uint[] colors = new uint[Palette.Size];
public uint this[int index]
{
get { return colors[index]; }
set { colors[index] = value; }
}
public MutablePalette(IPalette p)
{
for (int i = 0; i < Palette.Size; i++)
this[i] = p[i];
}
public void SetColor(int index, Color color)
{
colors[index] = (uint)color.ToArgb();
}
public void ApplyRemap(IPaletteRemap r)
{
for (var i = 0; i < Palette.Size; i++)
colors[i] = (uint)r.GetRemappedColor(this.GetColor(i), i).ToArgb();
}
}
}

4
OpenRA.Game/Graphics/Sheet.cs
View File

@@ -96,7 +96,7 @@ namespace OpenRA.Graphics
return bitmap;
}
public Bitmap AsBitmap(TextureChannel channel, Palette pal)
public Bitmap AsBitmap(TextureChannel channel, IPalette pal)
{
var d = Data;
var dataStride = 4 * Size.Width;
@@ -115,7 +115,7 @@ namespace OpenRA.Graphics
for (var x = 0; x < Size.Width; x++)
{
var paletteIndex = d[dataRowIndex + 4 * x];
colors[bdRowIndex + x] = pal.Values[paletteIndex];
colors[bdRowIndex + x] = pal[paletteIndex];
}
}
}

30
OpenRA.Game/Graphics/WorldRenderer.cs
View File

@@ -1,6 +1,6 @@
#region Copyright & License Information
/*
* Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
* Copyright 2007-2014 The OpenRA Developers (see AUTHORS)
* This file is part of OpenRA, which is free software. It is made
* available to you under the terms of the GNU General Public License
* as published by the Free Software Foundation. For more information,
@@ -12,7 +12,6 @@ using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using OpenRA.Primitives;
using OpenRA.Traits;
namespace OpenRA.Graphics
@@ -21,8 +20,8 @@ namespace OpenRA.Graphics
{
public readonly string Name;
public readonly int Index;
public readonly Palette Palette;
public PaletteReference(string name, int index, Palette palette)
public IPalette Palette { get; internal set; }
public PaletteReference(string name, int index, IPalette palette)
{
Name = name;
Index = index;
@@ -36,10 +35,10 @@ namespace OpenRA.Graphics
public readonly Theater Theater;
public Viewport Viewport { get; private set; }
internal readonly TerrainRenderer terrainRenderer;
internal readonly HardwarePalette palette;
internal Cache<string, PaletteReference> palettes;
Lazy<DeveloperMode> devTrait;
readonly TerrainRenderer terrainRenderer;
readonly HardwarePalette palette;
readonly Dictionary<string, PaletteReference> palettes;
readonly Lazy<DeveloperMode> devTrait;
internal WorldRenderer(World world)
{
@@ -47,9 +46,9 @@ namespace OpenRA.Graphics
Viewport = new Viewport(this, world.Map);
palette = new HardwarePalette();
palettes = new Cache<string, PaletteReference>(CreatePaletteReference);
foreach (var pal in world.traitDict.ActorsWithTrait<IPalette>())
pal.Trait.InitPalette(this);
palettes = new Dictionary<string, PaletteReference>();
foreach (var pal in world.traitDict.ActorsWithTrait<ILoadsPalettes>())
pal.Trait.LoadPalettes(this);
palette.Initialize();
@@ -62,14 +61,13 @@ namespace OpenRA.Graphics
PaletteReference CreatePaletteReference(string name)
{
var pal = palette.GetPalette(name);
if (pal == null)
throw new InvalidOperationException("Palette `{0}` does not exist".F(name));
return new PaletteReference(name, palette.GetPaletteIndex(name), pal);
}
public PaletteReference Palette(string name) { return palettes[name]; }
public void AddPalette(string name, Palette pal, bool allowModifiers) { palette.AddPalette(name, pal, allowModifiers); }
public PaletteReference Palette(string name) { return palettes.GetOrAdd(name, CreatePaletteReference); }
public void AddPalette(string name, ImmutablePalette pal) { palette.AddPalette(name, pal, false); }
public void AddPalette(string name, ImmutablePalette pal, bool allowModifiers) { palette.AddPalette(name, pal, allowModifiers); }
public void ReplacePalette(string name, IPalette pal) { palette.ReplacePalette(name, pal); palettes[name].Palette = pal; }
List<IRenderable> GenerateRenderables()
{

8
OpenRA.Game/Primitives/ReadOnlyDictionary.cs
View File

@@ -32,6 +32,14 @@ namespace OpenRA
bool TryGetValue(TKey key, out TValue value);
}
public static class ReadOnlyDictionary
{
public static IReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dict)
{
return dict as IReadOnlyDictionary<TKey, TValue> ?? new ReadOnlyDictionary<TKey, TValue>(dict);
}
}
/// <summary>
/// A minimal read only dictionary for .NET 4 implemented as a wrapper
/// around an IDictionary.

6
OpenRA.Game/Traits/Player/FixedColorPalette.cs
View File

@@ -31,7 +31,7 @@ namespace OpenRA.Traits
public object Create(ActorInitializer init) { return new FixedColorPalette(this); }
}
public class FixedColorPalette : IPalette
public class FixedColorPalette : ILoadsPalettes
{
readonly FixedColorPaletteInfo info;
@@ -40,10 +40,10 @@ namespace OpenRA.Traits
this.info = info;
}
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
var remap = new PlayerColorRemap(info.RemapIndex, info.Color, info.Ramp);
wr.AddPalette(info.Name, new Palette(wr.Palette(info.Base).Palette, remap), info.AllowModifiers);
wr.AddPalette(info.Name, new ImmutablePalette(wr.Palette(info.Base).Palette, remap), info.AllowModifiers);
}
}
}

6
OpenRA.Game/Traits/Player/PlayerColorPalette.cs
View File

@@ -29,7 +29,7 @@ namespace OpenRA.Traits
public object Create(ActorInitializer init) { return new PlayerColorPalette(init.self.Owner, this); }
}
public class PlayerColorPalette : IPalette
public class PlayerColorPalette : ILoadsPalettes
{
readonly Player owner;
readonly PlayerColorPaletteInfo info;
@@ -40,10 +40,10 @@ namespace OpenRA.Traits
this.info = info;
}
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
var remap = new PlayerColorRemap(info.RemapIndex, owner.Color, info.Ramp);
wr.AddPalette(info.BaseName + owner.InternalName, new Palette(wr.Palette(info.BasePalette).Palette, remap), info.AllowModifiers);
wr.AddPalette(info.BaseName + owner.InternalName, new ImmutablePalette(wr.Palette(info.BasePalette).Palette, remap), info.AllowModifiers);
}
}
}

7
OpenRA.Game/Traits/Player/PlayerHighlightPalette.cs
View File

@@ -9,6 +9,7 @@
#endregion
using System.Drawing;
using System.Linq;
using OpenRA.Graphics;
namespace OpenRA.Traits
@@ -22,7 +23,7 @@ namespace OpenRA.Traits
public object Create(ActorInitializer init) { return new PlayerHighlightPalette(init.self.Owner, this); }
}
public class PlayerHighlightPalette : IPalette
public class PlayerHighlightPalette : ILoadsPalettes
{
readonly Player owner;
readonly PlayerHighlightPaletteInfo info;
@@ -33,10 +34,10 @@ namespace OpenRA.Traits
this.info = info;
}
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
var argb = (uint)Color.FromArgb(128, owner.Color.RGB).ToArgb();
wr.AddPalette(info.BaseName + owner.InternalName, new Palette(Exts.MakeArray(256, i => i == 0 ? 0 : argb)), false);
wr.AddPalette(info.BaseName + owner.InternalName, new ImmutablePalette(Enumerable.Range(0, Palette.Size).Select(i => i == 0 ? 0 : argb)));
}
}
}

4
OpenRA.Game/Traits/TraitsInterfaces.cs
View File

@@ -150,8 +150,8 @@ namespace OpenRA.Traits
public interface IDamageModifier { float GetDamageModifier(Actor attacker, WarheadInfo warhead); }
public interface ISpeedModifier { decimal GetSpeedModifier(); }
public interface IFirepowerModifier { float GetFirepowerModifier(); }
public interface IPalette { void InitPalette(WorldRenderer wr); }
public interface IPaletteModifier { void AdjustPalette(Dictionary<string, Palette> b); }
public interface ILoadsPalettes { void LoadPalettes(WorldRenderer wr); }
public interface IPaletteModifier { void AdjustPalette(IReadOnlyDictionary<string, MutablePalette> b); }
public interface IPips { IEnumerable<PipType> GetPips(Actor self); }
public interface ITags { IEnumerable<TagType> GetTags(); }
public interface ISelectionBar { float GetValue(); Color GetColor(); }

10
OpenRA.Mods.D2k/FogPaletteFromR8.cs
View File

@@ -29,19 +29,19 @@ namespace OpenRA.Mods.RA
public object Create(ActorInitializer init) { return new FogPaletteFromR8(this); }
}
class FogPaletteFromR8 : IPalette
class FogPaletteFromR8 : ILoadsPalettes
{
readonly FogPaletteFromR8Info info;
public FogPaletteFromR8(FogPaletteFromR8Info info) { this.info = info; }
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
var colors = new uint[256];
var colors = new uint[Palette.Size];
using (var s = GlobalFileSystem.Open(info.Filename))
{
s.Seek(info.Offset, SeekOrigin.Begin);
for (var i = 0; i < 256; i++)
for (var i = 0; i < Palette.Size; i++)
{
var packed = s.ReadUInt16();
@@ -53,7 +53,7 @@ namespace OpenRA.Mods.RA
}
}
wr.AddPalette(info.Name, new Palette(colors), info.AllowModifiers);
wr.AddPalette(info.Name, new ImmutablePalette(colors), info.AllowModifiers);
}
}
}

10
OpenRA.Mods.D2k/PaletteFromR8.cs
View File

@@ -29,19 +29,19 @@ namespace OpenRA.Mods.RA
public object Create(ActorInitializer init) { return new PaletteFromR8(this); }
}
class PaletteFromR8 : IPalette
class PaletteFromR8 : ILoadsPalettes
{
readonly PaletteFromR8Info info;
public PaletteFromR8(PaletteFromR8Info info) { this.info = info; }
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
var colors = new uint[256];
var colors = new uint[Palette.Size];
using (var s = GlobalFileSystem.Open(info.Filename))
{
s.Seek(info.Offset, SeekOrigin.Begin);
for (var i = 0; i < 256; i++)
for (var i = 0; i < Palette.Size; i++)
{
var packed = s.ReadUInt16();
colors[i] = (uint)((255 << 24) | ((packed & 0xF800) << 8) | ((packed & 0x7E0) << 5) | ((packed & 0x1f) << 3));
@@ -51,7 +51,7 @@ namespace OpenRA.Mods.RA
}
}
wr.AddPalette(info.Name, new Palette(colors), info.AllowModifiers);
wr.AddPalette(info.Name, new ImmutablePalette(colors), info.AllowModifiers);
}
}
}

6
OpenRA.Mods.D2k/PaletteFromScaledPalette.cs
View File

@@ -35,15 +35,15 @@ namespace OpenRA.Mods.D2k
public object Create(ActorInitializer init) { return new PaletteFromScaledPalette(this); }
}
class PaletteFromScaledPalette : IPalette
class PaletteFromScaledPalette : ILoadsPalettes
{
readonly PaletteFromScaledPaletteInfo info;
public PaletteFromScaledPalette(PaletteFromScaledPaletteInfo info) { this.info = info; }
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
var remap = new ScaledPaletteRemap(info.Scale, info.Offset);
wr.AddPalette(info.Name, new Palette(wr.Palette(info.BasePalette).Palette, remap), info.AllowModifiers);
wr.AddPalette(info.Name, new ImmutablePalette(wr.Palette(info.BasePalette).Palette, remap), info.AllowModifiers);
}
}

6
OpenRA.Mods.RA/ChronoshiftPaletteEffect.cs
View File

@@ -33,16 +33,16 @@ namespace OpenRA.Mods.RA
remainingFrames--;
}
public void AdjustPalette(Dictionary<string,Palette> palettes)
public void AdjustPalette(IReadOnlyDictionary<string, MutablePalette> palettes)
{
if (remainingFrames == 0)
return;
var frac = (float)remainingFrames / chronoEffectLength;
foreach (var pal in palettes)
{
for (var x = 0; x < 256; x++)
for (var x = 0; x < Palette.Size; x++)
{
var orig = pal.Value.GetColor(x);
var lum = (int)(255 * orig.GetBrightness());

13
OpenRA.Mods.RA/CloakPaletteEffect.cs
View File

@@ -15,7 +15,7 @@ using OpenRA.Traits;
namespace OpenRA.Mods.RA
{
public class CloakPaletteEffectInfo : TraitInfo<CloakPaletteEffect> {}
public class CloakPaletteEffectInfo : TraitInfo<CloakPaletteEffect> { }
public class CloakPaletteEffect : IPaletteModifier, ITick
{
@@ -29,23 +29,22 @@ namespace OpenRA.Mods.RA
Color.FromArgb(178, 205, 250, 220),
};
public void AdjustPalette(Dictionary<string, Palette> b)
public void AdjustPalette(IReadOnlyDictionary<string, MutablePalette> b)
{
var i = (int)t;
var p = b[paletteName];
for (var j = 0; j < colors.Length; j++ )
for (var j = 0; j < colors.Length; j++)
{
var k = (i+j) % 16 + 0xb0;
p.SetColor(k, colors[j]);
var k = (i + j) % 16 + 0xb0;
p.SetColor(k, colors[j]);
}
}
public void Tick (Actor self)
public void Tick(Actor self)
{
t += 0.25f;
if (t >= 256) t = 0;
}
}
}

6
OpenRA.Mods.RA/LightPaletteRotator.cs
View File

@@ -18,7 +18,7 @@ namespace OpenRA.Mods.RA
[Desc("Palette effect used for blinking \"animations\" on actors.")]
class LightPaletteRotatorInfo : ITraitInfo
{
public readonly string[] ExcludePalettes = {};
public readonly string[] ExcludePalettes = { };
public object Create(ActorInitializer init) { return new LightPaletteRotator(this); }
}
@@ -38,7 +38,7 @@ namespace OpenRA.Mods.RA
this.info = info;
}
public void AdjustPalette(Dictionary<string,Palette> palettes)
public void AdjustPalette(IReadOnlyDictionary<string, MutablePalette> palettes)
{
foreach (var pal in palettes)
{
@@ -49,7 +49,7 @@ namespace OpenRA.Mods.RA
if (rotate > 9)
rotate = 18 - rotate;
pal.Value.SetColor(0x67, pal.Value.GetColor(230+rotate));
pal.Value.SetColor(0x67, pal.Value.GetColor(230 + rotate));
}
}
}

12
OpenRA.Mods.RA/MenuPaletteEffect.cs
View File

@@ -66,24 +66,24 @@ namespace OpenRA.Mods.RA
}
}
public void AdjustPalette(Dictionary<string, Palette> palettes)
public void AdjustPalette(IReadOnlyDictionary<string, MutablePalette> palettes)
{
if (to == EffectType.None && remainingFrames == 0)
return;
foreach (var pal in palettes)
foreach (var pal in palettes.Values)
{
for (var x = 0; x < 256; x++)
for (var x = 0; x < Palette.Size; x++)
{
var orig = pal.Value.GetColor(x);
var orig = pal.GetColor(x);
var t = ColorForEffect(to, orig);
if (remainingFrames == 0)
pal.Value.SetColor(x, t);
pal.SetColor(x, t);
else
{
var f = ColorForEffect(from, orig);
pal.Value.SetColor(x, Exts.ColorLerp((float)remainingFrames / Info.FadeLength, t, f));
pal.SetColor(x, Exts.ColorLerp((float)remainingFrames / Info.FadeLength, t, f));
}
}
}

6
OpenRA.Mods.RA/NukePaletteEffect.cs
View File

@@ -33,7 +33,7 @@ namespace OpenRA.Mods.RA
remainingFrames--;
}
public void AdjustPalette(Dictionary<string,Palette> palettes)
public void AdjustPalette(IReadOnlyDictionary<string, MutablePalette> palettes)
{
if (remainingFrames == 0)
return;
@@ -42,11 +42,11 @@ namespace OpenRA.Mods.RA
foreach (var pal in palettes)
{
for (var x = 0; x < 256; x++)
for (var x = 0; x < Palette.Size; x++)
{
var orig = pal.Value.GetColor(x);
var white = Color.FromArgb(orig.A, 255, 255, 255);
pal.Value.SetColor(x, Exts.ColorLerp(frac,orig,white));
pal.Value.SetColor(x, Exts.ColorLerp(frac, orig, white));
}
}
}

6
OpenRA.Mods.RA/PaletteFromCurrentTileset.cs
View File

@@ -26,7 +26,7 @@ namespace OpenRA.Mods.RA
public object Create(ActorInitializer init) { return new PaletteFromCurrentTileset(init.world, this); }
}
class PaletteFromCurrentTileset : IPalette
class PaletteFromCurrentTileset : ILoadsPalettes
{
readonly World world;
readonly PaletteFromCurrentTilesetInfo info;
@@ -37,9 +37,9 @@ namespace OpenRA.Mods.RA
this.info = info;
}
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
wr.AddPalette(info.Name, new Palette(GlobalFileSystem.Open(world.TileSet.Palette), info.ShadowIndex), info.AllowModifiers);
wr.AddPalette(info.Name, new ImmutablePalette(GlobalFileSystem.Open(world.TileSet.Palette), info.ShadowIndex), info.AllowModifiers);
}
}
}

6
OpenRA.Mods.RA/PaletteFromFile.cs
View File

@@ -29,7 +29,7 @@ namespace OpenRA.Mods.RA
public object Create(ActorInitializer init) { return new PaletteFromFile(init.world, this); }
}
class PaletteFromFile : IPalette
class PaletteFromFile : ILoadsPalettes
{
readonly World world;
readonly PaletteFromFileInfo info;
@@ -39,10 +39,10 @@ namespace OpenRA.Mods.RA
this.info = info;
}
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
if (info.Tileset == null || info.Tileset.ToLowerInvariant() == world.Map.Tileset.ToLowerInvariant())
wr.AddPalette(info.Name, new Palette(GlobalFileSystem.Open(info.Filename), info.ShadowIndex), info.AllowModifiers);
wr.AddPalette(info.Name, new ImmutablePalette(GlobalFileSystem.Open(info.Filename), info.ShadowIndex), info.AllowModifiers);
}
public string Filename

7
OpenRA.Mods.RA/PaletteFromRGBA.cs
View File

@@ -8,6 +8,7 @@
*/
#endregion
using System.Linq;
using OpenRA.Graphics;
using OpenRA.Traits;
@@ -33,7 +34,7 @@ namespace OpenRA.Mods.RA
public object Create(ActorInitializer init) { return new PaletteFromRGBA(init.world, this); }
}
class PaletteFromRGBA : IPalette
class PaletteFromRGBA : ILoadsPalettes
{
readonly World world;
readonly PaletteFromRGBAInfo info;
@@ -43,14 +44,14 @@ namespace OpenRA.Mods.RA
this.info = info;
}
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
// Enable palette only for a specific tileset
if (info.Tileset != null && info.Tileset.ToLowerInvariant() != world.Map.Tileset.ToLowerInvariant())
return;
var c = (uint)((info.A << 24) | (info.R << 16) | (info.G << 8) | info.B);
wr.AddPalette(info.Name, new Palette(Exts.MakeArray(256, i => (i == 0) ? 0 : c)), info.AllowModifiers);
wr.AddPalette(info.Name, new ImmutablePalette(Enumerable.Range(0, Palette.Size).Select(i => (i == 0) ? 0 : c)), info.AllowModifiers);
}
}
}

6
OpenRA.Mods.RA/PlayerPaletteFromCurrentTileset.cs
View File

@@ -26,7 +26,7 @@ namespace OpenRA.Mods.RA
public object Create(ActorInitializer init) { return new PlayerPaletteFromCurrentTileset(init.world, this); }
}
class PlayerPaletteFromCurrentTileset : IPalette
class PlayerPaletteFromCurrentTileset : ILoadsPalettes
{
readonly World world;
readonly PlayerPaletteFromCurrentTilesetInfo info;
@@ -37,10 +37,10 @@ namespace OpenRA.Mods.RA
this.info = info;
}
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
var filename = world.TileSet.PlayerPalette ?? world.TileSet.Palette;
wr.AddPalette(info.Name, new Palette(GlobalFileSystem.Open(filename), info.ShadowIndex), info.AllowModifiers);
wr.AddPalette(info.Name, new ImmutablePalette(GlobalFileSystem.Open(filename), info.ShadowIndex), info.AllowModifiers);
}
}
}

7
OpenRA.Mods.RA/ShroudPalette.cs
View File

@@ -9,6 +9,7 @@
#endregion
using System.Drawing;
using System.Linq;
using OpenRA.Graphics;
using OpenRA.Traits;
@@ -26,16 +27,16 @@ namespace OpenRA.Mods.RA
public object Create(ActorInitializer init) { return new ShroudPalette(this); }
}
class ShroudPalette : IPalette
class ShroudPalette : ILoadsPalettes
{
readonly ShroudPaletteInfo info;
public ShroudPalette(ShroudPaletteInfo info) { this.info = info; }
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
var c = info.Fog ? Fog : Shroud;
wr.AddPalette(info.Name, new Palette(Exts.MakeArray(256, i => (uint)c[i % 8].ToArgb())), false);
wr.AddPalette(info.Name, new ImmutablePalette(Enumerable.Range(0, Palette.Size).Select(i => (uint)c[i % 8].ToArgb())));
}
static Color[] Fog = new[] {

8
OpenRA.Mods.RA/VoxelNormalsPalette.cs
View File

@@ -22,7 +22,7 @@ namespace OpenRA.Mods.RA
public object Create(ActorInitializer init) { return new VoxelNormalsPalette(this); }
}
public class VoxelNormalsPalette : IPalette
public class VoxelNormalsPalette : ILoadsPalettes
{
readonly VoxelNormalsPaletteInfo info;
@@ -31,7 +31,7 @@ namespace OpenRA.Mods.RA
this.info = info;
}
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
// Rotate vectors to expected orientation
// Voxel coordinates are x=forward, y=right, z=up
@@ -40,7 +40,7 @@ namespace OpenRA.Mods.RA
// Map normals into color range
// Introduces a maximum error of ~0.5%
var data = new uint[256];
var data = new uint[Palette.Size];
for (var i = 0; i < n.Length / 3; i++)
{
data[i] = 0xFF000000;
@@ -51,7 +51,7 @@ namespace OpenRA.Mods.RA
}
}
wr.AddPalette(info.Name, new Palette(data), false);
wr.AddPalette(info.Name, new ImmutablePalette(data));
}
// Normal vector tables from http://www.sleipnirstuff.com/forum/viewtopic.php?t=8048

21
OpenRA.Mods.RA/WaterPaletteRotation.cs
View File

@@ -18,7 +18,7 @@ namespace OpenRA.Mods.RA
[Desc("Palette effect used for sprinkle \"animations\" on terrain tiles.")]
class WaterPaletteRotationInfo : ITraitInfo
{
public readonly string[] ExcludePalettes = {};
public readonly string[] ExcludePalettes = { };
public object Create(ActorInitializer init) { return new WaterPaletteRotation(init.world, this); }
}
@@ -38,23 +38,26 @@ namespace OpenRA.Mods.RA
public void Tick(Actor self) { t += .25f; }
static uint[] temp = new uint[7]; /* allocating this on the fly actually hurts our profile */
uint[] temp = new uint[7]; /* allocating this on the fly actually hurts our profile */
public void AdjustPalette(Dictionary<string,Palette> palettes)
public void AdjustPalette(IReadOnlyDictionary<string, MutablePalette> palettes)
{
foreach (var pal in palettes)
var rotate = (int)t % 7;
if (rotate == 0)
return;
foreach (var kvp in palettes)
{
if (info.ExcludePalettes.Contains(pal.Key))
if (info.ExcludePalettes.Contains(kvp.Key))
continue;
var colors = pal.Value.Values;
var rotate = (int)t % 7;
var palette = kvp.Value;
for (var i = 0; i < 7; i++)
temp[(rotate + i) % 7] = colors[world.TileSet.WaterPaletteRotationBase + i];
temp[(rotate + i) % 7] = palette[world.TileSet.WaterPaletteRotationBase + i];
for (var i = 0; i < 7; i++)
pal.Value.SetColor(world.TileSet.WaterPaletteRotationBase + i, temp[i]);
palette[world.TileSet.WaterPaletteRotationBase + i] = temp[i];
}
}
}

13
OpenRA.Mods.RA/Widgets/ColorPreviewManagerWidget.cs
View File

@@ -16,14 +16,14 @@ namespace OpenRA.Mods.RA.Widgets
{
public class ColorPreviewManagerWidget : Widget
{
public readonly string Palette = "colorpicker";
public readonly string PaletteName = "colorpicker";
public readonly int[] RemapIndices = ChromeMetrics.Get<int[]>("ColorPickerRemapIndices");
public readonly float Ramp = 0.05f;
public HSLColor Color;
HSLColor cachedColor;
WorldRenderer worldRenderer;
Palette preview;
IPalette preview;
[ObjectCreator.UseCtor]
public ColorPreviewManagerWidget(WorldRenderer worldRenderer)
@@ -34,17 +34,18 @@ namespace OpenRA.Mods.RA.Widgets
public override void Initialize(WidgetArgs args)
{
base.Initialize(args);
preview = worldRenderer.Palette(Palette).Palette;
preview = worldRenderer.Palette(PaletteName).Palette;
}
public override void Tick()
{
if (cachedColor == Color)
return;
preview.ApplyRemap(new PlayerColorRemap(RemapIndices, Color, Ramp));
cachedColor = Color;
var newPalette = new MutablePalette(preview);
newPalette.ApplyRemap(new PlayerColorRemap(RemapIndices, Color, Ramp));
worldRenderer.ReplacePalette(PaletteName, newPalette);
}
}
}

2
OpenRA.Mods.RA/Widgets/Logic/AssetBrowserLogic.cs
View File

@@ -95,7 +95,7 @@ namespace OpenRA.Mods.RA.Widgets.Logic
var colorDropdown = panel.GetOrNull<DropDownButtonWidget>("COLOR");
if (colorDropdown != null)
{
colorDropdown.IsDisabled = () => currentPalette != colorPreview.Palette;
colorDropdown.IsDisabled = () => currentPalette != colorPreview.PaletteName;
colorDropdown.OnMouseDown = _ => ShowColorDropDown(colorDropdown, colorPreview, world);
panel.Get<ColorBlockWidget>("COLORBLOCK").GetColor = () => Game.Settings.Player.Color.RGB;
}

9
OpenRA.Mods.TS/ShroudPalette.cs
View File

@@ -9,8 +9,7 @@
#endregion
using System;
using System.Drawing;
using OpenRA.FileFormats;
using System.Linq;
using OpenRA.Graphics;
using OpenRA.Traits;
@@ -25,13 +24,13 @@ namespace OpenRA.Mods.TS
public object Create(ActorInitializer init) { return new TSShroudPalette(this); }
}
class TSShroudPalette : IPalette
class TSShroudPalette : ILoadsPalettes
{
readonly TSShroudPaletteInfo info;
public TSShroudPalette(TSShroudPaletteInfo info) { this.info = info; }
public void InitPalette(WorldRenderer wr)
public void LoadPalettes(WorldRenderer wr)
{
Func<int, uint> makeColor = i =>
{
@@ -40,7 +39,7 @@ namespace OpenRA.Mods.TS
return 0;
};
wr.AddPalette(info.Name, new Palette(Exts.MakeArray(256, i => makeColor(i))), false);
wr.AddPalette(info.Name, new ImmutablePalette(Enumerable.Range(0, Palette.Size).Select(i => makeColor(i))));
}
}
}

8
OpenRA.TilesetBuilder/FormBuilder.cs
View File

@@ -25,7 +25,7 @@ namespace OpenRA.TilesetBuilder
string srcfile;
int size;
public TerrainTypeInfo[] TerrainType;
public Palette TerrainPalette;
public ImmutablePalette TerrainPalette;
public bool PaletteFromImage = true;
public string PaletteFile = "";
public string ImageFile = "";
@@ -60,7 +60,7 @@ namespace OpenRA.TilesetBuilder
if (!PaletteFromImage)
{
TerrainPalette = Palette.Load(PaletteFile, shadowIndex);
TerrainPalette = new ImmutablePalette(PaletteFile, shadowIndex);
rbitmap.Palette = TerrainPalette.AsSystemPalette();
}
@@ -247,8 +247,8 @@ namespace OpenRA.TilesetBuilder
static string ExportPalette(List<Color> p, string file)
{
while (p.Count < 256) p.Add(Color.Black); // pad the palette out with extra blacks
var paletteData = p.Take(256).SelectMany(
while (p.Count < Palette.Size) p.Add(Color.Black); // pad the palette out with extra blacks
var paletteData = p.Take(Palette.Size).SelectMany(
c => new byte[] { (byte)(c.R >> 2), (byte)(c.G >> 2), (byte)(c.B >> 2) }).ToArray();
File.WriteAllBytes(file, paletteData);
return file;

14
OpenRA.Utility/Command.cs
View File

@@ -96,7 +96,7 @@ namespace OpenRA.Utility
shadowIndex[shadowIndex.Length - 3] = 4;
}
var palette = Palette.Load(args[2], shadowIndex);
var palette = new ImmutablePalette(args[2], shadowIndex);
ISpriteSource source;
using (var stream = File.OpenRead(src))
@@ -209,16 +209,14 @@ namespace OpenRA.Utility
= PlayerColorRemap.GetRemapIndex(destRemapIndex, i);
// map everything else to the best match based on channel-wise distance
var srcPalette = Palette.Load(args[1].Split(':')[1], shadowIndex);
var destPalette = Palette.Load(args[2].Split(':')[1], shadowIndex);
var srcPalette = new ImmutablePalette(args[1].Split(':')[1], shadowIndex);
var destPalette = new ImmutablePalette(args[2].Split(':')[1], shadowIndex);
var fullIndexRange = Exts.MakeArray<int>(256, x => x);
for (var i = 0; i < 256; i++)
for (var i = 0; i < Palette.Size; i++)
if (!remap.ContainsKey(i))
remap[i] = fullIndexRange
remap[i] = Enumerable.Range(0, Palette.Size)
.Where(a => !remap.ContainsValue(a))
.MinBy(a => ColorDistance(destPalette.Values[a], srcPalette.Values[i]));
.MinBy(a => ColorDistance(destPalette[a], srcPalette[i]));
var srcImage = ShpReader.Load(args[3]);

6
glsl/shp.frag
View File

@@ -3,6 +3,6 @@ uniform sampler2D DiffuseTexture, Palette;
void main()
{
vec4 x = texture2D(DiffuseTexture, gl_TexCoord[0].st);
vec2 p = vec2( dot(x, gl_TexCoord[1]), gl_TexCoord[0].p );
gl_FragColor = texture2D(Palette,p);
}
vec2 p = vec2(gl_TexCoord[0].p, dot(x, gl_TexCoord[1]));
gl_FragColor = texture2D(Palette, p);
}

8
glsl/vxl.frag
View File

@@ -7,11 +7,11 @@ uniform vec3 AmbientLight, DiffuseLight;
void main()
{
vec4 x = texture2D(DiffuseTexture, gl_TexCoord[0].st);
vec4 color = texture2D(Palette, vec2(dot(x, gl_TexCoord[1]), PaletteRows.x));
vec4 color = texture2D(Palette, vec2(PaletteRows.x, dot(x, gl_TexCoord[1])));
if (color.a < 0.01)
discard;
vec4 normal = (2.0*texture2D(Palette, vec2(dot(x, gl_TexCoord[2]), PaletteRows.y)) - 1.0);
vec3 intensity = AmbientLight + DiffuseLight*max(dot(normal, LightDirection), 0.0);
gl_FragColor = vec4(intensity*color.rgb, color.a);
vec4 normal = (2.0 * texture2D(Palette, vec2(PaletteRows.y, dot(x, gl_TexCoord[2]))) - 1.0);
vec3 intensity = AmbientLight + DiffuseLight * max(dot(normal, LightDirection), 0.0);
gl_FragColor = vec4(intensity * color.rgb, color.a);
}