| public SetPixel ( uint x, uint y, System.Color color ) : void | ||
| x | uint | X coordinate of pixel in the image |
| y | uint | Y coordinate of pixel in the image |
| color | System.Color | New color for pixel (x, y) |
| return | void | |
/*
* This function draws a full line to the full 512x512 window. It draws from both the left and right name tables at the line specified.
* It draws a full line and accounts for name table mirroring. From here the data is drawn to the window to be read in later.
*/
public void drawFullBGLineToWindow(uint lineNumber)
{
bool isLineUpperTable;
if (isNametableMirrored && !isHorizNametableMirror)
{
//If name table is vertically mirrored, then draw the top. The bottom is just a copy.
isLineUpperTable = true;
}
else
{
//If line is less in the lower half of 512 lines
isLineUpperTable = (lineNumber < 256);
}
Color[] leftTable = drawBGLineFromNameTable(lineNumber % 256, true, isLineUpperTable);
Color[] rightTable;
if (isNametableMirrored && isHorizNametableMirror)
{
//If name table is horizontally mirrored, the draw the left table for both tables. The right is just a copy.
rightTable = leftTable;
}
else
{
rightTable = drawBGLineFromNameTable(lineNumber % 256, false, isLineUpperTable);
}
for (int x = 0; x < 256; x++)
{
fullWindow.SetPixel((uint)x, lineNumber, leftTable[x]);
fullWindow.SetPixel((uint)(x + 256), lineNumber, rightTable[x]);
}
}
public MainTitleScreen(RenderWindow window)
: base(window)
{
Type = ScreenType.MainTitleScreen;
base.Init();
// Gui.AddGameWidget(imb);
initMenu();
StraightLineVariableData slvd = new StraightLineVariableData(200F, 100 * 4);
// slvd.AddKeyData(.25F, 100F);
slvd.AddKeyData(.5F, 300F);
// slvd.AddKeyData(.75F, 100F);
slvd.ComputeData();
img = new Image(800, 600, new Color(0, 0, 0, 0));
for (int i = 0; i < slvd.GetCount(); ++i)
{
// Log.Cl(slvd.GetData(i));
img.SetPixel((uint)(100 + i / 4), (uint)slvd.GetData(i), Color.Red);
// img.SetPixel((uint)(100 + i / 4), (uint)slvd.GetData(i) + 4, Color.Blue);
}
tex = new SFML.Graphics.Texture(img);
spre = new Sprite(tex);
imb.AddMessage("hoy hoy !");
imb.OnStopping += new MessageBox.EventHandler(imb_OnStopping);
}
private void SetNextBlock()
{
Color col = BlockInformation.BlockColors.Where(c => c.Key == m_Arena.CurrentPiece).FirstOrDefault().Value;
int[,] currentBlock = BlockInformation.BlockArrays.Where(a => a.Key == m_Arena.CurrentPiece).FirstOrDefault().Value;
if (currentBlock != null && col != null)
{
SFML.Graphics.Image img = new SFML.Graphics.Image(100, 100, Color.White);
for (int y = 0; y < currentBlock.GetLength(0); y++)
{
for (int x = 0; x < currentBlock.GetLength(1); x++)
{
if (currentBlock[y, x] <= 0)
{
continue;
}
uint posY = (img.Size.Y / 2) - ((uint)y / 2);
uint posX = (img.Size.X / 2) + ((uint)x / 2);
for (uint i = 0; i < BlockInformation.Size.Y; i++)
{
for (uint j = 0; j < BlockInformation.Size.X; j++)
{
img.SetPixel(posX + j, posY + i, col);
}
}
}
}
imageNextBlock.SetImage(img);
}
}
public static void SliceAndDice(Vector2f startPoint, Vector2f endPoint, Texture victim, out Texture sliceA,
out Texture sliceB, float repeatsX, float repeatsY)
{
//startPoint = new Vector2f(ConvertUnits.ToDisplayUnits(startPoint.X),
// ConvertUnits.ToDisplayUnits(startPoint.Y));
//endPoint = new Vector2f(ConvertUnits.ToDisplayUnits(endPoint.X),
// ConvertUnits.ToDisplayUnits(endPoint.Y));
var input = victim.CopyToImage();
var outputA = new Image((uint)(input.Size.X * repeatsX), (uint)(input.Size.Y * repeatsY), Color.Transparent);
var outputB = new Image((uint)(input.Size.X * repeatsX), (uint)(input.Size.Y * repeatsY), Color.Transparent);
for (uint y = 0; y < input.Size.Y * repeatsY; y++)
{
for (uint x = 0; x < input.Size.X * repeatsX; x++)
{
var pos = new Vector2f(x, y);
var start = new Vector2(startPoint.X, startPoint.Y);
var end = new Vector2(endPoint.X, endPoint.Y);
var line = end - start;
line.Normalize();
if (WhichSideOfLine(startPoint, endPoint, pos))
outputA.SetPixel(x, y, input.GetPixel(x % input.Size.X, y % input.Size.Y));
else
outputB.SetPixel(x, y, input.GetPixel(x % input.Size.X, y % input.Size.Y));
}
}
sliceA = new Texture(outputA);
sliceB = new Texture(outputB);
}
private void importerUneSéquenceToolStripMenuItem_Click(object sender, EventArgs e)
{
if (openTexture.ShowDialog() == DialogResult.OK)
{
var name = Path.GetFileNameWithoutExtension(openTexture.FileName);
while (char.IsDigit(name[name.Length - 1]))
{
name = name.Substring(0, name.Length - 1);
}
var list = openTexture.FileNames.ToList();
list.Sort();
var imgs = list.ConvertAll((s) => new SFML.Graphics.Image(s));
Vector2u size = imgs[0].Size;
if (!imgs.All((img) => img.Size == size))
{
MessageBox.Show(this, "Les images ne font pas toutes la même taille.", "Erreur lors de la compilation d'images", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
Vector2i matrixSize = default;
{
var root = Math.Sqrt(imgs.Count);
matrixSize.X = (int)Math.Ceiling(root);
if (root - Math.Truncate(root) < .5)
{
matrixSize.Y = (int)Math.Floor(root);
}
else
{
matrixSize.Y = (int)Math.Ceiling(root);
}
}
var globalImg = new SFML.Graphics.Image((uint)(size.X * matrixSize.X), (uint)(size.Y * matrixSize.Y), SFML.Graphics.Color.Transparent);
Vector2i offset = default;
foreach (var img in imgs)
{
for (uint x = 0; x < size.X; x++)
{
for (uint y = 0; y < size.Y; y++)
{
globalImg.SetPixel(x + (uint)offset.X, y + (uint)offset.Y, img.GetPixel(x, y));
}
}
offset.X += (int)size.X;
if (offset.X >= globalImg.Size.X)
{
offset.X = 0;
offset.Y += (int)size.Y;
}
}
var res = new Resource();
res.Name = name;
res.Smooth = true;
res.ChangeBaseImage(globalImg);
res.ChangeFrames((Vector2i)globalImg.Size, new Vector2i());
Program.DynamicObject.AddResource(res);
UpdateInterface();
}
}
public static SFML.Graphics.Image BitmapToImage(Bitmap bitmap)
{
SFML.Graphics.Image image = new SFML.Graphics.Image((uint)bitmap.Width, (uint)bitmap.Height);
for (int x = 0; x < bitmap.Width; x++)
{
for (int y = 0; y < bitmap.Height; y++)
{
System.Drawing.Color systemColor = bitmap.GetPixel(x, y);
SFML.Graphics.Color sfmlColor = new SFML.Graphics.Color(systemColor.R, systemColor.G, systemColor.B);
image.SetPixel((uint)x, (uint)y, sfmlColor);
}
}
return(image);
}
public Sprite Paint(byte[,,] data)
{
Image image = new Image((uint)data.GetLength(0), (uint)data.GetLength(1));
sizeVector = image.Size;
for (uint i = 0; i < data.GetLength(0); i++)
{
for (uint j = 0; j < data.GetLength(1); j++)
{
Color color = new Color(data[i, j, 0], data[i, j, 1], data[i, j, 2]);
image.SetPixel(i, j, color);
}
}
Texture texture = new Texture(image);
return(new Sprite(texture));
}
public static void Initialize()
{
var style = Styles.Titlebar | Styles.Close;
size = new Vector2f(Configuration.Width, Configuration.Height);
Window = new RenderWindow(new VideoMode(Configuration.Width, Configuration.Height), "Open Empires", style);
Window.SetFramerateLimit(Configuration.Framerate);
Window.SetVerticalSyncEnabled(Configuration.VSync);
Window.Closed += (sender, args) => Window.Close();
Window.Resized += (sender, args) => Resize(new Vector2f(args.Width, args.Height));
/*Window.MouseButtonPressed += (sender, args) => DispatchEvent(new MouseButtonInputArgs(args.Button, true, args.X, args.Y));
Window.MouseButtonReleased += (sender, args) => DispatchEvent(new MouseButtonInputArgs(args.Button, false, args.X, args.Y));
Window.MouseWheelMoved += (sender, args) => DispatchEvent(new MouseWheelInputArgs(args.Delta, args.X, args.Y));
Window.MouseMoved += (sender, args) => DispatchEvent(new MouseMoveInputArgs(args.X, args.Y));*/
Window.MouseMoved += new EventHandler<MouseMoveEventArgs>(Window_MouseMoved);
Window.MouseWheelMoved += (sender, args) =>
{
/* Mouse wheel zoom implementation where the view will zoom
* towards the area the cursor is pointing to
*/
var mousePos = Mouse.GetPosition(Window);
float relX = (float) mousePos.X / Window.Size.X - 0.5f;
float relY = (float) mousePos.Y / Window.Size.Y - 0.5f;
GameView.Move(new Vector2f {
X = relX * GameView.Size.X,
Y = relY * GameView.Size.Y
});
GameView.Zoom(1 - (args.Delta * 0.1f));
GameView.Move(new Vector2f {
X = -relX * GameView.Size.X,
Y = -relY * GameView.Size.Y
});
};
Window.KeyPressed += (sender, args) =>
{
KeyStates[(int)args.Code] = true;
};
Window.KeyReleased += (sender, args) =>
{
KeyStates[(int)args.Code] = false;
};
Blendomatic.ReadBlendomatic(new System.IO.FileStream("blendomatic.dat", System.IO.FileMode.Open));
map = new Map();
GameView = new View(DefaultView);
GameView.Center = new Vector2f((map.Width/2)*96, 0);
var blend = Blendomatic.BlendingModes[2];
var tile = blend.Tiles[12];
var img = new Image(97, 49);
for (var y = 0; y < img.Size.Y; y++)
for (var x = 0; x < img.Size.X; x++)
img.SetPixel((uint)x, (uint)y, new Color(255, 0, 0, 0));
var i = 0;
for (var y = 0; y < img.Size.X; y++)
{
var bytesPerRow = y < 24 ? 1 + (4 * y) : 97 - (4 * (y - 24));
var startX = 48 - (bytesPerRow / 2);
for (var x = 0; x < bytesPerRow; x++)
img.SetPixel((uint)(startX + x), (uint)y, new Color(0, 0, 0, tile[i++]));
}
var slpFile = new SLPFile();
slpFile.LoadFile("textures/ter15002.slp");
var spritewidth = slpFile.GetFrame(0).m_Width;
var spriteheight = slpFile.GetFrame(0).m_Height;
var imgg = new Image((uint)spritewidth, (uint)(spriteheight ), slpFile.GetFrame(0).GetRGBAArray());
for (var y = 0; y < imgg.Size.Y; y++)
for (var x = 0; x < imgg.Size.X; x++)
{
var col = imgg.GetPixel((uint)x, (uint)y);
col.A = (byte)(Math.Min(255, (128-img.GetPixel((uint)x, (uint)y).A)*2));
if (img.GetPixel((uint)x, (uint)y).R == 255)
col.A = 0;
imgg.SetPixel((uint)x, (uint)y, col);
}
selected = new Sprite(new Texture(imgg));
/* blend sand to forest now */
var blend2 = Blendomatic.BlendingModes[2];
var tile2 = blend2.Tiles[12];
var img2 = new Image(97, 49);
for (var y = 0; y < img2.Size.Y; y++)
for (var x = 0; x < img2.Size.X; x++)
img2.SetPixel((uint)x, (uint)y, new Color(255, 0, 0, 0));
var i2 = 0;
for (var y = 0; y < img.Size.X; y++)
{
var bytesPerRow = y < 24 ? 1 + (4 * y) : 97 - (4 * (y - 24));
var startX = 48 - (bytesPerRow / 2);
for (var x = 0; x < bytesPerRow; x++)
img2.SetPixel((uint)(startX + x), (uint)y, new Color(0, 0, 0, tile[i2++]));
}
var slpFile2 = new SLPFile();
slpFile2.LoadFile("textures/ter15017.slp");
var spritewidth2 = slpFile2.GetFrame(0).m_Width;
var spriteheight2 = slpFile2.GetFrame(0).m_Height;
var imgg2 = new Image((uint)spritewidth2, (uint)(spriteheight2), slpFile2.GetFrame(0).GetRGBAArray());
for (var y = 0; y < imgg2.Size.Y; y++)
for (var x = 0; x < imgg2.Size.X; x++)
{
var col = imgg2.GetPixel((uint)x, (uint)y);
col.A = (byte)(Math.Min(255, (128 - img.GetPixel((uint)x, (uint)y).A) * 2));
if (img2.GetPixel((uint)x, (uint)y).R == 255)
col.A = 0;
imgg2.SetPixel((uint)x, (uint)y, col);
}
selected2 = new Sprite(new Texture(imgg2));
EntManager = new EntityManager();
}
public static Texture GeneratePlanetTexture(Vector2u texSize)
{
var imgSize = texSize;
perlin = new Perlin(random.Next(2, 3), 0.2, NoiseQuality.Best, 4, 0.7, random.Next(0, 1024));
ridgedMulti = new RidgedMulti(random.NextDouble() * 2, 0.3, 2, NoiseQuality.Best, random.Next(0, 1024));
voronoi = new Voronoi(0.1, random.NextDouble() * 2, true, random.Next(0, 1024));
selectModule = new Select(1.0, 1.0, 0.0);
selectModule.SetSourceModule(0, perlin);
selectModule.SetSourceModule(1, ridgedMulti);
selectModule.SetSourceModule(2, voronoi);
heightMapBuilder = new PlanarNoiseMapBuilder(imgSize.X, imgSize.Y, 0, selectModule, 1, 5, 1, 5, true);
heightMap = heightMapBuilder.Build();
var texColors = new GradientColour();
texColors.AddGradientPoint(-1, GenerateProceduralColor());
texColors.AddGradientPoint(-0.2 + random.NextDouble() * 0.4, GenerateProceduralColor());
texColors.AddGradientPoint(1, GenerateProceduralColor());
var renderer = new ImageBuilder(heightMap, texColors);
var renderedImg = renderer.Render();
var img = new Bitmap(renderedImg);
var sfmlImg = new SFML.Graphics.Image(imgSize.X, imgSize.Y);
for (uint x = 0; x < imgSize.X; x++)
{
for (uint y = 0; y < imgSize.Y; y++)
{
var col = img.GetPixel((int)x, (int)y);
sfmlImg.SetPixel(x, y, new Color(col.R, col.G, col.B, col.A));
}
}
var returnTex = new Texture(sfmlImg);
return returnTex;
}
static void Main(string[] args)
{
var palette = new Image("palette.png");
palVec = new Vector3f[256];
for (uint x = 0; x < palVec.Length; x++)
{
palVec[x] = (Vector3f)palette.GetPixel(x, 0);
}
var image = new Image("test.png");
var imgVec = new Vector3f[image.Size.X, image.Size.Y];
var imgRes = new byte[image.Size.X, image.Size.Y];
for (uint y = 0; y < image.Size.Y; y++)
{
for (uint x = 0; x < image.Size.X; x++)
{
imgVec[x, y] = (Vector3f)image.GetPixel(x, y);
}
}
for (uint y = 0; y < image.Size.Y; y++)
{
for (uint x = 0; x < image.Size.X; x++)
{
if (x == 0 || y == 0 || x == image.Size.X - 1 || y == image.Size.Y - 1)
{
imgRes[x, y] = FindClosestColor(imgVec[x, y]);
continue;
}
var oldPix = imgVec[x, y];
var newCol = FindClosestColor(oldPix);
var newPix = palVec[newCol];
var error = oldPix - newPix;
imgRes[x, y] = newCol;
imgVec[x + 1, y + 0] += error * (7.0f / 16.0f);
imgVec[x - 1, y + 1] += error * (3.0f / 16.0f);
imgVec[x + 0, y + 1] += error * (5.0f / 16.0f);
imgVec[x + 1, y + 1] += error * (1.0f / 16.0f);
}
}
for (uint y = 0; y < image.Size.Y; y++)
{
for (uint x = 0; x < image.Size.X; x++)
{
image.SetPixel(x, y, (Color)palVec[imgRes[x, y]]);
}
}
image.SaveToFile("out.png");
var o = File.OpenWrite("out.pic");
for (uint y = 0; y < image.Size.Y; y++)
{
for (uint x = 0; x < image.Size.X; x++)
{
o.WriteByte(imgRes[x, y]);
}
}
o.Dispose();
}
