public static void execute() // executes the pipeline { if (win == null) return; Graphics.frame_index++; render_target = win; win.Clear(familiarize_color(back_color)); Statistics.sprites_drawn = 0; Statistics.sprites_discarded = 0; Pipeline.execute(); win.Display(); if (screenshot_signal) { bool found = false; int ctr = 0; string path = ""; while (!found) { path = XF.Application.root_path + "screenshot" + ctr + ".png"; found = !System.IO.File.Exists(path); ctr++; } SFML.Graphics.Image screenshot = new SFML.Graphics.Image(screen_w, screen_h); screenshot.CopyScreen(win) ; screenshot.SaveToFile(path); screenshot_signal = false; } }
/// <summary> /// <para>Loads Image from given Zip-File and Entry.</para> /// </summary> private Image LoadImageFrom(ZipFile zipFile, ZipEntry imageEntry) { string ResourceName = Path.GetFileNameWithoutExtension(imageEntry.Name).ToLowerInvariant(); if (TextureCache.Textures.Contains(ResourceName)) { return(null); // ImageCache.Images[ResourceName]; } var byteBuffer = new byte[zipBufferSize]; try { Stream zipStream = zipFile.GetInputStream(imageEntry); var memStream = new MemoryStream(); StreamUtils.Copy(zipStream, memStream, byteBuffer); memStream.Position = 0; Image loadedImg = new Image(memStream); TextureCache.Add(ResourceName, loadedImg); memStream.Close(); zipStream.Close(); memStream.Dispose(); zipStream.Dispose(); return(loadedImg); } catch (Exception I) { System.Console.WriteLine("Failed to load " + imageEntry.Name + ": " + I.ToString()); } return(null); }
protected static bool IsAssetValid(Image asset) { if (asset == null || asset.IsDisposed) return false; return true; }
public static Sprite LoadSprite(string fileName, Vector2f scale) { Image image = new Image(fileName); Texture texture = new Texture(image); Sprite sprite = new Sprite(texture) { Scale = scale }; return sprite; }
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); } }
/// <summary> /// Processes a black and white image to determine which areas on a map can or can't be clicked /// </summary> /// <param name="path">Path to click map file</param> /// <param name="pathGrid">Grid object to set</param> /// <returns></returns> public static void LoadAndProcessClickMap(string path, PathNode[,] pathNodes, Grid pathGrid, int tileSize) { var map = new SFML.Graphics.Image(path); var clickMap = new bool[map.Size.X, map.Size.Y]; float totalPixelsInTile = tileSize * tileSize; int totalTrue = 0; int xMax = 0; int yMax = 0; for (int x = 0; x < pathNodes.GetLength(0); x++) { for (int y = 0; y < pathNodes.GetLength(1); y++) { totalTrue = 0; xMax = tileSize * x + tileSize; for (int xMap = tileSize * x; xMap < xMax; xMap++) { yMax = tileSize * y + tileSize; for (int yMap = tileSize * y; yMap < yMax; yMap++) { if (xMap < map.Size.X && yMap < map.Size.Y && map.GetPixel((uint)xMap, (uint)yMap).B > 40) { totalTrue++; } } } pathGrid.SetTile(x, y, pathNodes[x, y].Enabled = (totalTrue / totalPixelsInTile) >= .5f); } } }
// [omeg] added, pixelData are in RGBA format public override void LoadTextureRaw(Texture texture, byte[] pixelData) { if (null == texture) { return; } Debug.Print("LoadTextureRaw: {0}", texture.RendererData); if (texture.RendererData != null) { FreeTexture(texture); } SFMLTexture sfTexture; try { var img = new Image((uint)texture.Width, (uint)texture.Height, pixelData); // SFML Image sfTexture = new SFMLTexture(img); sfTexture.Smooth = true; img.Dispose(); } catch (LoadingFailedException) { Debug.Print("LoadTextureRaw: failed"); texture.Failed = true; return; } texture.RendererData = sfTexture; texture.Failed = false; }
public void resetPPU() { frame = new SFML.Graphics.Image(256, 240); emptyFrame = new SFML.Graphics.Image(1, 1); fullWindow = new SFML.Graphics.Image(512, 512); screenUpdateWatch = new Stopwatch(); ppuRam = new byte[0x4000]; oamRam = new byte[0x100]; scrollWrittenOnce = false; ppuAddressWrittenOnce = false; oamAddressWrittenOnce = false; ppuWriteAddress = 0; tempPPUWriteAddress = 0; oamWriteAddress = 0; tempOAMWriteAddress = 0; pendingNMI = false; spriteZeroHit = false; spriteOverflow = false; isNametableMirrored = false; isHorizNametableMirror = false; isVertNametableMirror = false; scrollX = 0; scrollY = 0; ly = 0; ppuState = 0; frameCount = 0; }
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 Sprite LoadSprite(string fileName, Vector2f scale, bool flipH, bool flipV) { Image image = new Image(fileName); if (flipH) image.FlipHorizontally(); else if (flipV) image.FlipVertically(); Texture texture = new Texture(image); Sprite sprite = new Sprite(texture) { Scale = scale }; return sprite; }
public PixelCollider(Texture texture, params int[] tags) { this.texture = texture.SFMLTexture; collideImage = this.texture.CopyToImage(); Width = this.texture.Size.X; Height = this.texture.Size.Y; AddTag(tags); }
/// <summary> /// Creates a pixel collider. /// </summary> /// <param name="source">The source image to create the collider from.</param> /// <param name="tags">The tags to register the collider with.</param> public PixelCollider(string source, params int[] tags) { texture = Textures.Load(source); collideImage = texture.CopyToImage(); Width = texture.Size.X; Height = texture.Size.Y; AddTag(tags); }
/// <summary> /// Set the icon of the current window. /// </summary> /// <param name="width">The width of the icon.</param> /// <param name="height">The height of the icon.</param> /// <param name="source">The source path to the icon image.</param> public void SetIcon(string source) { SFML.Graphics.Image img; img = new SFML.Graphics.Image(source); iconWidth = img.Size.X; iconHeight = img.Size.Y; iconPath = source; iconImage = img; Window?.SetIcon(iconWidth, iconHeight, iconImage.Pixels); }
public static byte[] ToBytes(Texture image) { if (image == null) { throw new ArgumentNullException("image"); } SFML.Graphics.Image im = image.CopyToImage(); byte[] pixels = im.Pixels; im.Dispose(); return(pixels); }
/// <summary> /// Processes a greyscale image to determe a scaling factor for each location on the map /// </summary> /// <param name="path">Indigo path to content</param> /// <param name="minScaleValue">Scaling value that represents black in the image</param> /// <param name="maxScaleVale">Scaling value that represents white in the image</param> /// <returns></returns> public static float[,] LoadAndProcessPerspectiveMap(string path, float minScaleValue, float maxScaleVale) { var map = new SFML.Graphics.Image(path); var perspectiveMap = new float[map.Size.X, map.Size.Y]; float maxValue = maxScaleVale - minScaleValue; for (uint i = 0; i < map.Size.X; i++) { for (uint j = 0; j < map.Size.Y; j++) { perspectiveMap[i, j] = (map.GetPixel(i, j).B / 255f) * maxValue + minScaleValue; } } return(perspectiveMap); }
private void btnSplit_Click(object sender, EventArgs e) { if (Resource != null) { btnSplit.Visible = false; if (!Directory.Exists(txtOutputPath.Text)) { Directory.CreateDirectory(txtOutputPath.Text); } var srcExt = txtFile.Text.Substring( txtFile.Text.LastIndexOf(".") + 1); var srcName = txtFile.Text.Substring( txtFile.Text.LastIndexOf(Path.DirectorySeparatorChar) + 1).Replace("." + srcExt, string.Empty); var cols = ((int)numericX.Value >= 1) ? (int)numericX.Value : 1; var rows = ((int)numericY.Value >= 1) ? (int)numericY.Value : 1; var width = (int)Resource.Image.Size.X / cols; var height = (int)Resource.Image.Size.Y / rows; for (int r = 0; r < rows; r++) { for (int c = 0; c < cols; c++) { var destName = txtOutputFormat.Text.Replace( "%f", srcName).Replace( "%ext", srcExt).Replace( "%r", r.ToString()).Replace( "%c", c.ToString()).Replace( "%t", ((r * cols) + c).ToString()); Image image = new Image((uint)width, (uint)height); image.Copy(Resource.Image, 0, 0, new IntRect(c * width, r * height, width, height)); image.SaveToFile(txtOutputPath.Text + destName); image?.Dispose(); image = null; Application.DoEvents(); } } btnSplit.Visible = true; } txtFile.Focus(); }
public static SFML.Graphics.Image ToSFMLImage(System.Drawing.Bitmap bmp) { SFML.Graphics.Color[,] sfmlcolorarray = new SFML.Graphics.Color[bmp.Height, bmp.Width]; SFML.Graphics.Image newimage = null; for (int x = 0; x < bmp.Width; x++) { for (int y = 0; y < bmp.Height; y++) { System.Drawing.Color csharpcolor = bmp.GetPixel(x, y); sfmlcolorarray[y, x] = new SFML.Graphics.Color(csharpcolor.R, csharpcolor.G, csharpcolor.B, csharpcolor.A); } } newimage = new SFML.Graphics.Image(sfmlcolorarray); return(newimage); }
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 GraphicsDisplay(uint width, uint height) { Width = width; Height = height; _data = new Image(width, height, Color.Black); _dataTexture = new Texture(_data); _palette = new Image("Data/palette.png"); _paletteTexture = new Texture(_palette); _display = new Sprite(_dataTexture); _renderer = new Shader("Data/display.vert", "Data/display.frag"); _renderer.SetParameter("data", _dataTexture); _renderer.SetParameter("dataSize", width, height); _renderer.SetParameter("palette", _paletteTexture); }
/// <summary> /// <para>Loads the embedded base files.</para> /// </summary> public void LoadBaseResources() { Assembly _assembly = Assembly.GetExecutingAssembly(); ; Stream _stream; _stream = _assembly.GetManifestResourceStream("SS14.Client.Services._EmbeddedBaseResources.bluehigh.ttf"); if (_stream != null) _fonts.Add("base_font", new Font( _stream)); _stream = null; _stream = _assembly.GetManifestResourceStream("SS14.Client.Services._EmbeddedBaseResources.noSprite.png"); if (_stream != null) { Image nospriteimage = new Image( _stream); _images.Add("nosprite", nospriteimage); _sprites.Add("nosprite", new CluwneSprite("nosprite", nospriteimage)); } _stream = null; }
/// <summary> /// <para>Loads the embedded base files.</para> /// </summary> public void LoadBaseResources() { Assembly _assembly = Assembly.GetExecutingAssembly();; Stream _stream; _stream = _assembly.GetManifestResourceStream("SS14.Client.Services._EmbeddedBaseResources.bluehigh.ttf"); if (_stream != null) { _fonts.Add("base_font", new Font(_stream)); } _stream = null; _stream = _assembly.GetManifestResourceStream("SS14.Client.Services._EmbeddedBaseResources.noSprite.png"); if (_stream != null) { Image nospriteimage = new Image(_stream); _images.Add("nosprite", nospriteimage); _sprites.Add("nosprite", new CluwneSprite("nosprite", nospriteimage)); } _stream = null; }
public Bitmap GetEditorImage(TileObject instance) { Icon editorIcon = instance.EditorIcon; if (editorIcon == null) { return(null); } Texture texture = GetTexture(editorIcon.GetResourceId(0)); if (texture == null) { return(null); } Image image = texture.CopyToImage(); byte[] pixels = image.Pixels; int width = (int)image.Size.X; int height = (int)image.Size.Y; Bitmap bmp = new Bitmap(width, height, PixelFormat.Format32bppArgb); var boundsRect = new Rectangle(0, 0, width, height); BitmapData bmpData = bmp.LockBits(boundsRect, ImageLockMode.WriteOnly, bmp.PixelFormat); IntPtr ptr = bmpData.Scan0; int bytes = bmpData.Stride * bmp.Height; var rgbValues = new byte[bytes]; Array.Copy(pixels, 0, rgbValues, 0, pixels.Length); Marshal.Copy(rgbValues, 0, ptr, bytes); bmp.UnlockBits(bmpData); return(bmp); }
public static Bitmap BitmapFromTexture(Texture tex) { if (tex == null) { throw new ArgumentNullException("tex"); } SFML.Graphics.Image im = tex.CopyToImage(); Bitmap bitmap = new Bitmap((int)im.Size.X, (int)im.Size.Y); for (uint x = 0; x < im.Size.X; x++) { for (uint y = 0; y < im.Size.Y; y++) { SFML.Graphics.Color c = im.GetPixel(x, y); bitmap.SetPixel((int)x, (int)y, System.Drawing.Color.FromArgb(c.A, c.R, c.G, c.B)); } } im.Dispose(); return(bitmap); }
private bool IsUnderCursor(TileObject to, Vector2f cursorProjection) { if (!_layersVisibility[(int)to.Layer]) { return(false); } if (to.Icon == null) { return(false); } for (int i = 0; i < to.Icon.SpritesCount; i++) { Texture texture = GetTexture(to.Icon.GetResourceId(i)); if (texture == null) { return(false); } Image image = texture.CopyToImage(); Vector2f sfmlCursor = cursorProjection; Vector2f sfmlObject = WorldToSfml(to.Position, to.Offset); float imageX = sfmlCursor.X - sfmlObject.X; float imageY = sfmlCursor.Y - sfmlObject.Y; if (imageX < 0 || imageY < 0 || imageX >= PixelsPerUnit || imageY >= PixelsPerUnit) { continue; } uint imageXInt = (uint)Math.Round(imageX); uint imageYInt = (uint)Math.Round(imageY); if (image.GetPixel(imageXInt, imageYInt).A > 0) { return(true); } } return(false); }
/// <summary> /// Adds a sprite to the batch of sprites to be rendered, specifying the texture, destination, and source rectangles, /// color tint, rotation, origin, effects, and sort depth. /// </summary> /// <param name="texture">The sprite texture.</param> /// <param name="position">The location, in screen coordinates, where the sprite will be drawn.</param> /// <param name="color">The color channel modulation to use. Use <see cref="Color.White"/> for full color with /// no tinting.</param> /// <param name="shader">The shader to use on the text being drawn.</param> public virtual void Draw(Image texture, Vector2 position, Color color, Shader shader = null) { Draw(texture, position, null, color, 0, Vector2.Zero, Vector2.One, SpriteEffects.None, shader); }
internal Layer(World world, System.Xml.XmlElement la, int tilewidth, int tileheight, SFML.Graphics.Image image) { Name = la.GetAttributeString("name"); width = la.GetAttributeInt("width"); height = la.GetAttributeInt("height"); this.tilewidth = tilewidth; this.tileheight = tileheight; tiles = new int[width * height]; var data = la.FirstElement("data"); int index = 0; foreach (var tile in data.ElementsNamed("tile")) { var gid = tile.GetAttributeInt("gid"); tiles[index] = gid; ++index; } foreach (var o in ObjectDatas) { if (o.gid != 0) { var sp = Tiles.CreateSprite(image, o.gid, tilewidth, tileheight); sp.Position = o.pos; sprites.Add(sp); } } }
/// <summary> /// Adds a sprite to the batch of sprites to be rendered, specifying the texture, destination, and source rectangles, /// color tint, rotation, origin, effects, and sort depth. /// </summary> /// <param name="texture">The sprite texture.</param> /// <param name="position">The location, in screen coordinates, where the sprite will be drawn.</param> /// <param name="sourceRectangle">A rectangle specifying, in texels, which section of the rectangle to draw. /// Use null to draw the entire texture.</param> /// <param name="color">The color channel modulation to use. Use <see cref="Color.White"/> for full color with /// no tinting.</param> /// <param name="rotation">The angle, in radians, to rotate the sprite around the origin.</param> /// <param name="origin">The origin of the sprite. Specify (0,0) for the upper-left corner.</param> /// <param name="scale">Vector containing separate scalar multiples for the x- and y-axes of the sprite.</param> /// <param name="effects">Rotations to apply prior to rendering.</param> /// <param name="shader">The shader to use on the text being drawn.</param> public virtual void Draw(Image texture, Vector2 position, Rectangle? sourceRectangle, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects = SpriteEffects.None, Shader shader = null) { if (!IsAssetValid(texture)) return; _sprite.Image = texture; _sprite.Position = position; _sprite.SubRect = sourceRectangle.HasValue ? (IntRect)sourceRectangle : new IntRect(0, 0, (int)_sprite.Image.Width, (int)_sprite.Image.Height); _sprite.Color = color; _sprite.Rotation = MathHelper.ToDegrees(rotation); _sprite.Origin = origin; _sprite.FlipX((effects & SpriteEffects.FlipHorizontally) != 0); _sprite.FlipY((effects & SpriteEffects.FlipVertically) != 0); _sprite.Scale = scale; _rt.Draw(_sprite, shader); }
/// <summary> /// Adds a sprite to the batch of sprites to be rendered, specifying the texture, destination, and source rectangles, /// color tint, rotation, origin, effects, and sort depth. /// </summary> /// <param name="texture">The sprite texture.</param> /// <param name="position">The location, in screen coordinates, where the sprite will be drawn.</param> /// <param name="sourceRectangle">A rectangle specifying, in texels, which section of the rectangle to draw. /// Use null to draw the entire texture.</param> /// <param name="color">The color channel modulation to use. Use <see cref="Color.White"/> for full color with /// no tinting.</param> /// <param name="rotation">The angle, in radians, to rotate the sprite around the origin.</param> /// <param name="origin">The origin of the sprite. Specify (0,0) for the upper-left corner.</param> /// <param name="scale">Uniform multiple by which to scale the sprite width and height.</param> /// <param name="effects">Rotations to apply prior to rendering.</param> /// <param name="shader">The shader to use on the text being drawn.</param> public virtual void Draw(Image texture, Vector2 position, Rectangle? sourceRectangle, Color color, float rotation, Vector2 origin, float scale, SpriteEffects effects = SpriteEffects.None, Shader shader = null) { Draw(texture, position, sourceRectangle, color, rotation, origin, new Vector2(scale), effects, shader); }
/// <summary> /// <para>Loads all Resources from given Zip into the respective Resource Lists and Caches</para> /// </summary> public void LoadResourceZip(string path = null, string pw = null) { string zipPath = path ?? _configurationManager.GetResourcePath(); string password = pw ?? _configurationManager.GetResourcePassword(); if (!File.Exists(zipPath)) { throw new FileNotFoundException("Specified Zip does not exist: " + zipPath); } FileStream zipFileStream = File.OpenRead(zipPath); var zipFile = new ZipFile(zipFileStream); if (!string.IsNullOrWhiteSpace(password)) { zipFile.Password = password; } var directories = from ZipEntry a in zipFile where a.IsDirectory orderby a.Name.ToLowerInvariant() == "textures" descending select a; Dictionary <string, List <ZipEntry> > sorted = new Dictionary <string, List <ZipEntry> >(); foreach (ZipEntry dir in directories) { if (sorted.ContainsKey(dir.Name.ToLowerInvariant())) { continue; //Duplicate folder? shouldnt happen. } List <ZipEntry> folderContents = (from ZipEntry entry in zipFile where entry.Name.ToLowerInvariant().Contains(dir.Name.ToLowerInvariant()) where entry.IsFile select entry).ToList(); sorted.Add(dir.Name.ToLowerInvariant(), folderContents); } sorted = sorted.OrderByDescending(x => x.Key == "textures/").ToDictionary(x => x.Key, x => x.Value); //Textures first. foreach (KeyValuePair <string, List <ZipEntry> > current in sorted) { switch (current.Key) { case ("textures/"): foreach (ZipEntry texture in current.Value) { if (supportedImageExtensions.Contains(Path.GetExtension(texture.Name).ToLowerInvariant())) { Image loadedImg = LoadImageFrom(zipFile, texture); if (loadedImg == null) { continue; } else { _images.Add(texture.Name, loadedImg); } } } break; case ("tai/"): // Tai? foreach (ZipEntry tai in current.Value) { if (Path.GetExtension(tai.Name).ToLowerInvariant() == ".tai") { IEnumerable <CluwneSprite> loadedSprites = LoadSpritesFrom(zipFile, tai); foreach (CluwneSprite currentSprite in loadedSprites.Where(currentSprite => !_sprites.ContainsKey(currentSprite.Name))) { _sprites.Add(currentSprite.Name, currentSprite); } } } break; case ("fonts/"): foreach (ZipEntry font in current.Value) { if (Path.GetExtension(font.Name).ToLowerInvariant() == ".ttf") { Font loadedFont = LoadFontFrom(zipFile, font); if (loadedFont == null) { continue; } string ResourceName = Path.GetFileNameWithoutExtension(font.Name).ToLowerInvariant(); _fonts.Add(ResourceName, loadedFont); } } break; case ("particlesystems/"): foreach (ZipEntry particles in current.Value) { if (Path.GetExtension(particles.Name).ToLowerInvariant() == ".xml") { ParticleSettings particleSettings = LoadParticlesFrom(zipFile, particles); if (particleSettings == null) { continue; } else { _particles.Add(Path.GetFileNameWithoutExtension(particles.Name), particleSettings); } } } break; case ("shaders/"): foreach (ZipEntry shader in current.Value) { //FIXME Throws Exception //if (Path.GetExtension(shader.Name).ToLowerInvariant() == ".fx") //{ // FXShader loadedShader = LoadShaderFrom(zipFile, shader); // if (loadedShader == null) continue; // else _shaders.Add(shader.Name, loadedShader); //} } break; case ("animations/"): foreach (ZipEntry animation in current.Value) { if (Path.GetExtension(animation.Name).ToLowerInvariant() == ".xml") { AnimationCollection animationCollection = LoadAnimationCollectionFrom(zipFile, animation); if (animationCollection == null) { continue; } else { _animationCollections.Add(animationCollection.Name, animationCollection); } } } break; } } sorted = null; zipFile.Close(); zipFileStream.Close(); zipFileStream.Dispose(); GC.Collect(); }
/// <summary> /// Adds a sprite to the batch of sprites to be rendered, specifying the texture, destination, and source rectangles, /// color tint, rotation, origin, effects, and sort depth. /// </summary> /// <param name="texture">The sprite texture.</param> /// <param name="destinationRectangle">A rectangle specifying, in screen coordinates, where the sprite will be drawn. /// If this rectangle is not the same size as sourceRectangle, the sprite is scaled to fit.</param> /// <param name="color">The color channel modulation to use. Use <see cref="Color.White"/> for full color with /// no tinting.</param> /// <param name="shader">The shader to use on the text being drawn.</param> public virtual void Draw(Image texture, Rectangle destinationRectangle, Color color, Shader shader = null) { Draw(texture, destinationRectangle, null, color, 0f, Vector2.Zero, SpriteEffects.None, shader); }
public void generate(string unique_identifier, uint w, uint h, uint color) { image = new SFML.Graphics.Image(w, h, familiarize_color(color)); size_full.set(w, h); set_sprite_grid(1, 1); identifier = unique_identifier; }
/// <summary> /// The main entry point for the application. /// </summary> static void Main() { // NOTE : This is workaround to create a functioning opengl context for OpenTK (for current OpenTK version) var gameWindow = new OpenTK.GameWindow(); // Request a 24-bits depth buffer when creating the window var contextSettings = new ContextSettings(); contextSettings.DepthBits = 24; // Create the main window RenderWindow window = new RenderWindow(new VideoMode(800, 600), "SFML graphics with OpenGL", Styles.Default, contextSettings); window.SetVerticalSyncEnabled(true); // Initialize OpenTK // NOTE : next 2 lines are kept from old examples until we resolve proper OpenTK versioning //Toolkit.Init(); //GraphicsContext context = new GraphicsContext(new ContextHandle(IntPtr.Zero), null); // Setup event handlers window.Closed += new EventHandler(OnClosed); window.KeyPressed += new EventHandler <KeyEventArgs>(OnKeyPressed); window.Resized += new EventHandler <SizeEventArgs>(OnResized); // Create a sprite for the background var background = new Sprite(new Texture("resources/background.jpg")); // Create a text to display on top of the OpenGL object var text = new Text("SFML / OpenGL demo", new Font("resources/sansation.ttf")); text.Position = new Vector2f(250, 450); text.FillColor = new SFML.Graphics.Color(255, 255, 255, 170); // Make the window the active target for OpenGL calls window.SetActive(); // Load an OpenGL texture. // We could directly use a SFML.Graphics.Texture as an OpenGL texture (with its Bind() member function), // but here we want more control on it (generate mipmaps, ...) so we create a new one int texture = 0; using (var image = new SFML.Graphics.Image("resources/texture.jpg")) { GL.GenTextures(1, out texture); GL.BindTexture(TextureTarget.Texture2D, texture); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, (int)image.Size.X, (int)image.Size.Y, 0, PixelFormat.Rgba, PixelType.UnsignedByte, image.Pixels); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear); } // Enable Z-buffer read and write GL.Enable(EnableCap.DepthTest); GL.DepthMask(true); GL.ClearDepth(1); // Disable lighting GL.Disable(EnableCap.Lighting); // Configure the viewport (the same size as the window) GL.Viewport(0, 0, (int)window.Size.X, (int)window.Size.Y); // Setup a perspective projection GL.MatrixMode(MatrixMode.Projection); GL.LoadIdentity(); float ratio = (float)(window.Size.X) / window.Size.Y; GL.Frustum(-ratio, ratio, -1, 1, 1, 500); // Bind the texture GL.Enable(EnableCap.Texture2D); GL.BindTexture(TextureTarget.Texture2D, texture); // Define a 3D cube (6 faces made of 2 triangles composed by 3 vertices) float[] cube = new float[] { // positions // texture coordinates -20, -20, -20, 0, 0, -20, 20, -20, 1, 0, -20, -20, 20, 0, 1, -20, -20, 20, 0, 1, -20, 20, -20, 1, 0, -20, 20, 20, 1, 1, 20, -20, -20, 0, 0, 20, 20, -20, 1, 0, 20, -20, 20, 0, 1, 20, -20, 20, 0, 1, 20, 20, -20, 1, 0, 20, 20, 20, 1, 1, -20, -20, -20, 0, 0, 20, -20, -20, 1, 0, -20, -20, 20, 0, 1, -20, -20, 20, 0, 1, 20, -20, -20, 1, 0, 20, -20, 20, 1, 1, -20, 20, -20, 0, 0, 20, 20, -20, 1, 0, -20, 20, 20, 0, 1, -20, 20, 20, 0, 1, 20, 20, -20, 1, 0, 20, 20, 20, 1, 1, -20, -20, -20, 0, 0, 20, -20, -20, 1, 0, -20, 20, -20, 0, 1, -20, 20, -20, 0, 1, 20, -20, -20, 1, 0, 20, 20, -20, 1, 1, -20, -20, 20, 0, 0, 20, -20, 20, 1, 0, -20, 20, 20, 0, 1, -20, 20, 20, 0, 1, 20, -20, 20, 1, 0, 20, 20, 20, 1, 1 }; // Enable position and texture coordinates vertex components GL.EnableClientState(ArrayCap.VertexArray); GL.EnableClientState(ArrayCap.TextureCoordArray); GL.VertexPointer(3, VertexPointerType.Float, 5 * sizeof(float), Marshal.UnsafeAddrOfPinnedArrayElement(cube, 0)); GL.TexCoordPointer(2, TexCoordPointerType.Float, 5 * sizeof(float), Marshal.UnsafeAddrOfPinnedArrayElement(cube, 3)); // Disable normal and color vertex components GL.DisableClientState(ArrayCap.NormalArray); GL.DisableClientState(ArrayCap.ColorArray); var clock = new Clock(); // Start game loop while (window.IsOpen) { // Process events window.DispatchEvents(); // Clear the window GL.Clear(ClearBufferMask.DepthBufferBit); // Draw background window.PushGLStates(); window.Draw(background); window.PopGLStates(); // Clear the depth buffer GL.Clear(ClearBufferMask.DepthBufferBit); // We get the position of the mouse cursor, so that we can move the box accordingly float x = Mouse.GetPosition(window).X * 200.0F / window.Size.X - 100.0F; float y = -Mouse.GetPosition(window).Y * 200.0F / window.Size.Y + 100.0F; // Apply some transformations GL.MatrixMode(MatrixMode.Modelview); GL.LoadIdentity(); GL.Translate(x, y, -100.0F); GL.Rotate(clock.ElapsedTime.AsSeconds() * 50, 1.0F, 0.0F, 0.0F); GL.Rotate(clock.ElapsedTime.AsSeconds() * 30, 0.0F, 1.0F, 0.0F); GL.Rotate(clock.ElapsedTime.AsSeconds() * 90, 0.0F, 0.0F, 1.0F); // Draw the cube GL.DrawArrays(OpenTK.Graphics.OpenGL.PrimitiveType.Triangles, 0, 36); // Draw some text on top of our OpenGL object window.PushGLStates(); window.Draw(text); window.PopGLStates(); // Finally, display the rendered frame on screen window.Display(); } // Don't forget to destroy our texture GL.DeleteTextures(1, ref texture); }
/// <summary> /// This method is called on the client side, called when the client just connect /// or make sure that it got everything drawn correctly /// </summary> /// <param name="p">an array of byte representing the image, its size is width * height * 4</param> public void DrawReceivedWhiteboard(int curMap, byte[] p) { if (curMap < 0) return; if (p == null) return; changeMap(curMap); startBoard = new SFML.Graphics.Image(MapSprite.Texture.Size.X, MapSprite.Texture.Size.Y, p); boardImage.Update(startBoard); ToDraw = new Sprite(boardImage); forDraw.Draw(ToDraw); }
internal void reload() { loading_in_progress = true; var path = _filepath; if (path == "") throw new Exception("Trying to reload a texture that hasn't been properly loaded, derp"); //Debug.Log("Loading texture from file... " + path); string ext = path.Substring(path.LastIndexOf('.') + 1); string def_file = path; def_file = def_file.Remove(def_file.LastIndexOf('.')); def_file += ".def"; string alpha_file = path; alpha_file = alpha_file.Remove(alpha_file.LastIndexOf('.')); alpha_file += "_alpha." + ext; bool has_alpha_tex = System.IO.File.Exists(alpha_file); if (!_loaded) if (System.IO.File.Exists(def_file)) { parse_graphics_def_file(this, def_file); } if (this.image != null) this.image.Bind(); //this.render_image = null; this.image = new Image(path); size_full.set(image.Width, image.Height); set_sprite_grid(sequence.x, sequence.y); image.Smooth = manipulate_smooth; _loaded = true; loading_in_progress = false; }
/// <summary> /// Creates a new CluwneSprite With a key and a Image /// </summary> /// <param name="key"> Key </param> /// <param name="image"> Image </param> public CluwneSprite(string key, Image image) { this._key = key; this._image = image; }
/// <summary> /// Adds a sprite to the batch of sprites to be rendered, specifying the texture, destination, and source rectangles, /// color tint, rotation, origin, effects, and sort depth. /// </summary> /// <param name="texture">The sprite texture.</param> /// <param name="position">The location, in screen coordinates, where the sprite will be drawn.</param> /// <param name="sourceRectangle">A rectangle specifying, in texels, which section of the rectangle to draw. /// Use null to draw the entire texture.</param> /// <param name="color">The color channel modulation to use. Use <see cref="Color.White"/> for full color with /// no tinting.</param> /// <param name="rotation">The angle, in radians, to rotate the sprite around the origin.</param> /// <param name="origin">The origin of the sprite. Specify (0,0) for the upper-left corner.</param> /// <param name="scale">Vector containing separate scalar multiples for the x- and y-axes of the sprite.</param> /// <param name="effects">Rotations to apply prior to rendering.</param> /// <param name="shader">The shader to use on the text being drawn.</param> public override void Draw(Image texture, Vector2 position, Rectangle? sourceRectangle, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects = SpriteEffects.None, Shader shader = null) { base.Draw(texture, position.Round(), sourceRectangle, color, rotation, origin, scale, effects, shader); }
// [omeg] added, pixelData are in RGBA format public override void LoadTextureRaw(Texture texture, byte[] pixelData) { if (null == texture) return; Debug.Print("LoadTextureRaw: {0}", texture.RendererData); if (texture.RendererData != null) FreeTexture(texture); SFMLTexture sfTexture; try { var img = new Image((uint)texture.Width, (uint)texture.Height, pixelData); // SFML Image sfTexture = new SFMLTexture(img); sfTexture.Smooth = true; img.Dispose(); } catch (LoadingFailedException) { Debug.Print("LoadTextureRaw: failed"); texture.Failed = true; return; } texture.RendererData = sfTexture; texture.Failed = false; }
/// <summary> /// <para>Loads Image from given Zip-File and Entry.</para> /// </summary> private Image LoadImageFrom(ZipFile zipFile, ZipEntry imageEntry) { string ResourceName = Path.GetFileNameWithoutExtension(imageEntry.Name).ToLowerInvariant(); if (TextureCache.Textures.Contains(ResourceName)) return null; // ImageCache.Images[ResourceName]; var byteBuffer = new byte[zipBufferSize]; try { Stream zipStream = zipFile.GetInputStream(imageEntry); var memStream = new MemoryStream(); StreamUtils.Copy(zipStream, memStream, byteBuffer); memStream.Position = 0; Image loadedImg = new Image(memStream); TextureCache.Add(ResourceName, loadedImg); memStream.Close(); zipStream.Close(); memStream.Dispose(); zipStream.Dispose(); return loadedImg; } catch(Exception I) { System.Console.WriteLine("Failed to load " + imageEntry.Name + ": " + I.ToString()); } return null; }
/// <summary> /// This method will change the map being drawn to the map index that was given /// </summary> /// <param name="id">an integer that represent the map index inside the data /// content pipeline for maps</param> public void changeMap(int id) { // Reset map MapSprite = new Sprite(MainViewer.Instance.Data.MapsList[id].TextureImage); forDraw = new RenderTexture(MapSprite.Texture.Size.X, MapSprite.Texture.Size.Y); startBoard = new SFML.Graphics.Image(MapSprite.Texture.Size.X, MapSprite.Texture.Size.Y); loadedMap = true; boardImage.Update(startBoard); if (ViewPort != null && DrawWindow != null) { Zoom(100); MainViewer.Instance.UpdateDrawTurretList(id); } else { MainViewer.Instance.CurrentMap = id; } }
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; }
public SmiteMap() { InitializeComponent(); // By default no offset (draw at 0, 0) OffsetX = 0; OffsetY = 0; // initialize empty int for temporary god location: tempGodX = 0; tempGodY = 0; // Set the default zoom zoom = 1; //Defining the default shape for both images and drawing stuffs startBoard = new SFML.Graphics.Image(963, 891); forDraw = new RenderTexture(963, 891); // Defining drawing vertexes for lines vertexesToDraw = new Vector2f[6]; // Define the whiteboard data for transmiting between client and server WhiteBoardPixel = new List<byte>(); WhiteBoardX = new List<int>(); WhiteBoardY = new List<int>(); // Create a texture from the image boardImage = new Texture(startBoard); // No map loaded by default loadedMap = false; // Default selected Team is team1 selectedTeam1 = true; // Initialize god team draw order renderOrder = new List<KeyValuePair<int, int>>(); }
/// <summary> /// Adds a sprite to the batch of sprites to be rendered, specifying the texture, destination, and source rectangles, /// color tint, rotation, origin, effects, and sort depth. /// </summary> /// <param name="texture">The sprite texture.</param> /// <param name="position">The location, in screen coordinates, where the sprite will be drawn.</param> /// <param name="sourceRectangle">A rectangle specifying, in texels, which section of the rectangle to draw. /// Use null to draw the entire texture.</param> /// <param name="color">The color channel modulation to use. Use <see cref="Color.White"/> for full color with /// no tinting.</param> /// <param name="shader">The shader to use on the text being drawn.</param> public override void Draw(Image texture, Vector2 position, Rectangle? sourceRectangle, Color color, Shader shader = null) { base.Draw(texture, position.Round(), sourceRectangle, color, shader); }