public static Texture2D Clip(GraphicsDevice gd, Texture2D texture, Rectangle source) { var newTexture = new Texture2D(gd, source.Width, source.Height); var size = source.Width * source.Height; uint[] buffer = GetBuffer(size); if (FSOEnvironment.SoftwareDepth) { //opengl es does not like this var texBuf = GetBuffer(texture.Width * texture.Height); texture.GetData(texBuf); var destOff = 0; for (int y=source.Y; y<source.Bottom; y++) { int offset = y * texture.Width + source.X; for (int x = 0; x < source.Width; x++) { buffer[destOff++] = texBuf[offset++]; } } } else { texture.GetData(0, source, buffer, 0, size); } newTexture.SetData(buffer); return newTexture; }
public Level(Texture2D _brick, Texture2D _badGuys, Texture2D _projectile, Texture2D _blank, GraphicsDevice graphicsDevice, SpriteBatch _spriteBatch) { spriteBatch = _spriteBatch; int brick2 = brickSize * brickSize; singleBrick = new Color[brick2]; beginBrick = new Color[brick2]; contBrick = new Color[brick2]; endBrick = new Color[brick2]; topDoor = new Color[brick2]; botDoor = new Color[brick2]; destructBrick = new Color[brick2]; collectable = new Color[brick2]; openDoor = new AnimatedSprite(); projectile = _projectile; badGuys = _badGuys; brick = _brick; _brick.GetData<Color>(0, new Rectangle(0, 0, brickSize, brickSize), topDoor, 0, brick2); _brick.GetData<Color>(0, new Rectangle(0, brickSize, brickSize, brickSize), botDoor, 0, brick2); _brick.GetData<Color>(0, new Rectangle(0, 2 * brickSize, brickSize, brickSize), singleBrick, 0, brick2); _brick.GetData<Color>(0, new Rectangle(0, 3 * brickSize, brickSize, brickSize), beginBrick, 0, brick2); _brick.GetData<Color>(0, new Rectangle(0, 4 * brickSize, brickSize, brickSize), contBrick, 0, brick2); _brick.GetData<Color>(0, new Rectangle(0, 5 * brickSize, brickSize, brickSize), endBrick, 0, brick2); _brick.GetData<Color>(0, new Rectangle(0, 6 * brickSize, brickSize, brickSize), destructBrick, 0, brick2); _brick.GetData<Color>(0, new Rectangle(0, 7 * brickSize, brickSize, brickSize), collectable, 0, brick2); currLvlText = new Texture2D(graphicsDevice, _blank.Width, _blank.Height); blankLevel = new Color[_blank.Height*_blank.Width]; _blank.GetData<Color>(blankLevel); currLvlText.SetData<Color>(blankLevel); }
public override void GetData <T>(T[] data, int mipLevel, Rectangle?subimage, int startIndex, int elementCount) { if (subimage.HasValue) { XNA.Rectangle rect; Rectangle v = subimage.Value; XNAHelper.ConvertRectangle(ref v, out rect); _texture2D.GetData <T>(mipLevel, rect, data, startIndex, elementCount); } else { _texture2D.GetData <T>(mipLevel, null, data, startIndex, elementCount); } }
public static Vertices FromTextrure(Texture2D polygonTexture) { uint[] data = new uint[polygonTexture.Width * polygonTexture.Height]; polygonTexture.GetData(data); return PolygonTools.CreatePolygon(data, polygonTexture.Width); }
public Bonus(ContentManager content, Viewport view, int type, int positionX, int positionY, int velocityX, int velocityY, float rotation) { this.type = type; switch (type) { case 0: bonusTexture = content.Load<Texture2D>("bonus/damageup"); break; case 1: bonusTexture = content.Load<Texture2D>("bonus/levelup"); break; case 2: bonusTexture = content.Load<Texture2D>("bonus/lifeup"); break; case 3: bonusTexture = content.Load<Texture2D>("bonus/speedup"); break; } position = new Vector2(positionX, positionY); velocity = new Vector2(velocityX, velocityY); rotationSpeed = rotation; origin = new Vector2(bonusTexture.Width / 2, bonusTexture.Height / 2); textureData = new Color[bonusTexture.Width * bonusTexture.Height]; bonusTexture.GetData(textureData); }
private Texture2D processTexture(Texture2D texture) { //Some programs such as Photoshop save PNG and other RGBA images without premultiplied alpha if (!Constants.Instance.PremultipliedAlpha) { //XNA 4.0+ assumes that all RGBA images have premultiplied alpha channels. //Code snippet borrowed from http://xboxforums.create.msdn.com/forums/p/62320/383015.aspx#485897 Byte4[] data = new Byte4[texture.Width * texture.Height]; texture.GetData<Byte4>(data); for (int i = 0; i < data.Length; i++) { Vector4 vec = data[i].ToVector4(); float alpha = vec.W / 255.0f; int a = (int)(vec.W); int r = (int)(alpha * vec.X); int g = (int)(alpha * vec.Y); int b = (int)(alpha * vec.Z); uint packed = (uint)( (a << 24) + (b << 16) + (g << 8) + r ); data[i].PackedValue = packed; } texture.SetData<Byte4>(data); } return texture; }
public override void LoadContent() { //load texture that will represent the physics body _polygonTexture = ScreenManager.ContentManager.Load<Texture2D>("Content/Texture"); //Create an array to hold the data from the texture uint[] data = new uint[_polygonTexture.Width * _polygonTexture.Height]; //Transfer the texture data to the array _polygonTexture.GetData(data); //Calculate the vertices from the array Vertices verts = Vertices.CreatePolygon(data, _polygonTexture.Width, _polygonTexture.Height); //Make sure that the origin of the texture is the centroid (real center of geometry) _polygonOrigin = verts.GetCentroid(); //Use the body factory to create the physics body _polygonBody = BodyFactory.Instance.CreatePolygonBody(PhysicsSimulator, verts, 5); _polygonBody.Position = new Vector2(500, 400); GeomFactory.Instance.CreatePolygonGeom(PhysicsSimulator, _polygonBody, verts, 0); _circleTexture = DrawingHelper.CreateCircleTexture(ScreenManager.GraphicsDevice, 35, Color.Gold, Color.Black); _circleOrigin = new Vector2(_circleTexture.Width / 2f, _circleTexture.Height / 2f); _circleBody = BodyFactory.Instance.CreateCircleBody(PhysicsSimulator, 35, 1); _circleBody.Position = new Vector2(300, 400); GeomFactory.Instance.CreateCircleGeom(PhysicsSimulator, _circleBody, 35, 20); base.LoadContent(); }
public static XGraphics.Texture2D FromFile(GraphicsDevice device, string file, bool premultiplyAlpha) { XGraphics.Texture2D tex = null; using (FileStream fs = File.OpenRead(file)) { tex = XGraphics.Texture2D.FromStream(device, fs); } if (premultiplyAlpha) { byte[] data = new byte[tex.Width * tex.Height * 4]; tex.GetData(data); for (int i = 0; i < data.Length; i += 4) { int a = data[i + 3]; data[i + 0] = (byte)(data[i + 0] * a / 255); data[i + 1] = (byte)(data[i + 1] * a / 255); data[i + 2] = (byte)(data[i + 2] * a / 255); } tex.SetData(data); } return(tex); }
private void BuildSelectorTexture() { Vector2 textureSize = new Vector2(this.Size.X * 2, this.Size.Y * 2); selectorTexture = new Texture2D(Globals.GraphicsDevice, (int)textureSize.X, (int)textureSize.Y); Texture hold = Globals.GraphicsDevice.Textures[0]; Globals.GraphicsDevice.Textures[0] = null; Color[] colors = new Color[(int)textureSize.X * (int)textureSize.Y]; selectorTexture.GetData(colors); Vector2 center = new Vector2(textureSize.X / 2, textureSize.Y / 2); int ndx = 0; for (int y = 0; y < textureSize.Y; y++) { for (int x = 0; x < textureSize.X; x++) { Vector2 location = new Vector2(x, y); float radius = (center - location).Length(); if (radius + 3 >= textureSize.X / 2 && radius <= textureSize.X / 2) colors[ndx] = Color.Black; ndx++; } } selectorTexture.SetData(colors); Globals.GraphicsDevice.Textures[0] = hold; }
public Map(Game game, string name) : base(game) { Name = name; DrawOrder = 1; MapImage = _sandGame.Content.Load<Texture2D>(string.Format("Textures/Maps/{0}-image", Name)); _map = _sandGame.Content.Load<Texture2D>(string.Format("Textures/Maps/{0}", Name)); Width = _map.Width; Height = _map.Height; _mapTexture = new Color[(int)(Width * Height)]; _map.GetData(_mapTexture); for(int x = 0; x < Width; x++) { for(int y = 0; y < Height; y++) { var color = _mapTexture[(int)(x + (y * Width))]; if(color == Color.Red) { RedSpawn = new Vector2(x, y); } else if(color == Color.Lime) { BlueSpawn = new Vector2(x, y); } } } }
public static void generateShadedTexture(Color col, Texture2D bsprite, ref Texture2D target) { //System.Console.WriteLine("Input colour: " + col.ToString()); try { Color[] shades = generateShades(col); /*System.Console.WriteLine("Output colours: " + shades[0]); System.Console.WriteLine("\t" + shades[1]); System.Console.WriteLine("\t" + shades[2]); System.Console.WriteLine("\t" + shades[3]); System.Console.WriteLine("\t" + shades[4]);*/ Color[] colArray = new Color[bsprite.Width * bsprite.Height]; bsprite.GetData<Color>(colArray); for (int c = 0; c < colArray.Length; c++) { for (int i = 0; i < 5; i++) { if (colArray[c] == BLUE_SHADES[i]) { colArray[c] = shades[i]; break; } } } target.SetData<Color>(colArray); } catch (System.Exception e) { System.Console.OpenStandardError(); System.Console.WriteLine(e.Message); System.Console.WriteLine(e.StackTrace); System.Console.Error.Close(); } //System.Console.WriteLine("Finished texture shading!"); }
protected void LoadHeightData( Texture2D heightMap, float magnify ) { float minimumHeight = float.MaxValue; float maximumHeight = float.MinValue; mWidth = heightMap.Width; mLength = heightMap.Height; Color[] heightMapColors = new Color[ mWidth * mLength ]; heightMap.GetData( heightMapColors ); mHeightMap = new float[ mWidth * mLength ]; for( int x = 0; x < mWidth; x++ ) for( int y = 0; y < mLength; y++ ) { mHeightMap[ x + y * mWidth ] = heightMapColors[ x + y * mWidth ].R; if( mHeightMap[ x + y * mWidth ] < minimumHeight ) minimumHeight = mHeightMap[ x + y * mWidth ]; if( mHeightMap[ x + y * mWidth ] > maximumHeight ) maximumHeight = mHeightMap[ x + y * mWidth ]; } // normalise height data to be between 0 and 30.0f for( int x = 0; x < mWidth; x++ ) for( int y = 0; y < mLength; y++ ) mHeightMap[ x + y * mWidth ] = ( mHeightMap[ x + y * mWidth ] - minimumHeight ) / ( maximumHeight - minimumHeight ) * magnify; }
public static List<Vertices> GetVertsFromMapImage( Texture2D image, float scale, out Vector2 origin ) { uint[] data = new uint[ image.Width * image.Height ]; image.GetData( data ); Vertices textureVertices = PolygonTools.CreatePolygon( data, image.Width, false ); Vector2 centroid = -textureVertices.GetCentroid(); textureVertices.Translate( ref centroid ); origin = -centroid; //We simplify the vertices found in the texture. textureVertices = SimplifyTools.ReduceByDistance( textureVertices, 4f ); //Since it is a concave polygon, we need to partition it into several smaller convex polygons //scale the vertices from graphics space to sim space //Settings.MaxPolygonVertices = 1000; var list = BayazitDecomposer.ConvexPartition( textureVertices ); Vector2 vertScale = new Vector2( ConvertUnits.ToSimUnits( 1 ) ) * scale; foreach ( Vertices vertices in list ) { vertices.Scale( ref vertScale ); } return list; }
private void BuildColorSelector() { Texture hold = Globals.GraphicsDevice.Textures[0]; Globals.GraphicsDevice.Textures[0] = null; Vector2 selectorSize = new Vector2(5, 10); colorSelector = new Texture2D(Globals.GraphicsDevice, (int)selectorSize.X, (int)selectorSize.Y); Color[] colors = new Color[(int)selectorSize.X * (int)selectorSize.Y]; colorSelector.GetData(colors); int ndx = 0; for (int y = 0; y < selectorSize.Y; y++) { for (int x = 0; x < selectorSize.X; x++) { if (y < selectorSize.Y / 2) { if (x <= y) colors[ndx] = Color.Black; } else { colors[ndx] = Color.Black; if (x >= selectorSize.Y - y) colors[ndx] = Color.Transparent; } ndx++; } } colorSelector.SetData(colors); Globals.GraphicsDevice.Textures[0] = hold; }
private static Boolean PixelPerfectCollision(Rectangle Bounds1, Texture2D Texture1, Rectangle Bounds2, Texture2D Texture2) { Color[] bitsA = new Color[Bounds1.Width * Bounds1.Height]; Color[] bitsB = new Color[Bounds2.Width * Bounds1.Height]; Texture1.GetData(bitsA); Texture2.GetData(bitsB); int x1 = Math.Max(Bounds1.X, Bounds2.X); int x2 = Math.Min(Bounds1.X + Bounds1.Width, Bounds2.X + Bounds2.Width); int y1 = Math.Max(Bounds1.Y, Bounds2.Y); int y2 = Math.Min(Bounds1.Y + Bounds1.Height, Bounds2.Y + Bounds2.Height); // For each single pixel in the intersecting rectangle for (int y = y1; y < y2; ++y) { for (int x = x1; x < x2; ++x) { // Get the color from each texture Color a = bitsA[(x - Bounds1.X) + (y - Bounds1.Y) * Texture1.Width]; Color b = bitsB[(x - Bounds2.X) + (y - Bounds2.Y) * Texture2.Width]; if (a.A != 0 && b.A != 0) // If both colors are not transparent (the alpha channel is not 0), then there is a collision { return true; } } } return false; }
public static float[,] LoadHeightData(Texture2D height_map, ref int terrain_width, ref int terrain_height, ref float min_height, ref float max_height, float height_limit) { terrain_width = height_map.Width; terrain_height = height_map.Height; Color[] map_colors = new Color[terrain_height * terrain_width]; height_map.GetData<Color>(map_colors); float[,] height_data = new float[terrain_width, terrain_height]; for(int x=0; x<terrain_width; x++) { for(int y=0; y<terrain_height; y++) { height_data[x, y] = map_colors[x+y*terrain_width].R; if (height_data[x, y] > max_height) max_height = height_data[x, y]; if(height_data[x, y] < min_height) min_height = height_data[x, y]; } } for (int x = 0; x < terrain_width; x++) { for(int y=0; y< terrain_height; y++) { if (max_height == min_height) height_data[x, y] = Math.Min(min_height, height_limit); else height_data[x, y] = (height_data[x, y] - min_height) / (max_height - min_height) * height_limit; } } return height_data; }
private void BuildVertices(Texture2D heightMap) { var heightMapColors = new Color[_vertexCount]; heightMap.GetData(heightMapColors); float x = _position.X; float z = _position.Z; float y = _position.Y; float maxX = x + _topSize; for (int i = 0; i < _vertexCount; i++) { if (x > maxX) { x = _position.X; z++; } y = _position.Y + (heightMapColors[i].R / 2.0f); var vert = new VertexPositionNormalTexture(new Vector3(x * _scale, y * _scale, z * _scale), Vector3.Zero, Vector2.Zero); vert.TextureCoordinate = new Vector2(((vert.Position.X - _position.X) / _topSize), ((vert.Position.Z - _position.Z) / _topSize)) / _scale; Vertices[i] = vert; x++; } }
public Trap(Texture2D texture, Vector2 pos) : base(texture, pos) { hitbox = new Rectangle((int)pos.X, (int)pos.Y, texture.Width, texture.Height); texData = new Color[texture.Width * texture.Height]; texture.GetData(texData); }
public AnimatedSprite(Texture2D texture) { this.texture = texture; int area = texture.Width * texture.Height; data = new Color[area]; texture.GetData(0, null, data, 0, area); }
public static bool AddNewLevelBlock(Level level, Vector3 coordinate, Texture2D heightMap, Texture2D alphaMap, string[] detailTextureNames, Vector2[] uvOffsets, Vector2[] uvScales) { if (level.Contains(coordinate)) { return false; } Color[] heightColors = new Color[HeightMapMesh.NUM_SIDE_VERTICES * HeightMapMesh.NUM_SIDE_VERTICES]; if (heightMap.Width != HeightMapMesh.NUM_SIDE_VERTICES || heightMap.Height != HeightMapMesh.NUM_SIDE_VERTICES) { RenderTarget2D resizedHeightMap = new RenderTarget2D(GraphicsManager.Device, HeightMapMesh.NUM_SIDE_VERTICES, HeightMapMesh.NUM_SIDE_VERTICES); GraphicsManager.Device.SetRenderTarget(resizedHeightMap); GraphicsManager.SpriteBatch.Begin(); GraphicsManager.SpriteBatch.Draw(heightMap, new Rectangle(0, 0, HeightMapMesh.NUM_SIDE_VERTICES, HeightMapMesh.NUM_SIDE_VERTICES), Color.White); GraphicsManager.SpriteBatch.End(); GraphicsManager.Device.SetRenderTarget(null); resizedHeightMap.GetData(heightColors); } else { heightMap.GetData(heightColors); } float[,] heights = new float[HeightMapMesh.NUM_SIDE_VERTICES, HeightMapMesh.NUM_SIDE_VERTICES]; for (int i = 0; i < heightColors.Length; i++) { heights[i % HeightMapMesh.NUM_SIDE_VERTICES, i / HeightMapMesh.NUM_SIDE_VERTICES] = ConvertColorToFloat(heightColors[i]); } if (alphaMap.Height != HeightMapMesh.NUM_SIDE_VERTICES * HeightMapMesh.NUM_SIDE_TEXELS_PER_QUAD || alphaMap.Width != HeightMapMesh.NUM_SIDE_VERTICES * HeightMapMesh.NUM_SIDE_TEXELS_PER_QUAD) { RenderTarget2D resizedAlphaMap = new RenderTarget2D(GraphicsManager.Device, HeightMapMesh.NUM_SIDE_VERTICES * HeightMapMesh.NUM_SIDE_TEXELS_PER_QUAD, HeightMapMesh.NUM_SIDE_VERTICES * HeightMapMesh.NUM_SIDE_TEXELS_PER_QUAD); GraphicsManager.Device.SetRenderTarget(resizedAlphaMap); GraphicsManager.SpriteBatch.Begin(); GraphicsManager.SpriteBatch.Draw(alphaMap, new Rectangle(0, 0, HeightMapMesh.NUM_SIDE_VERTICES * HeightMapMesh.NUM_SIDE_TEXELS_PER_QUAD, HeightMapMesh.NUM_SIDE_VERTICES * HeightMapMesh.NUM_SIDE_TEXELS_PER_QUAD), Color.White); GraphicsManager.SpriteBatch.End(); GraphicsManager.Device.SetRenderTarget(null); alphaMap = resizedAlphaMap; } HeightMapMesh heightMapMesh = new HeightMapMesh(heights, alphaMap, detailTextureNames, uvOffsets, uvScales); AssetLibrary.AddHeightMap(level.Name + coordinate.ToString(), heightMapMesh); level.AddNewBlock(coordinate); return true; }
/// <summary> /// It gets picture and splits it into 9 parts (3x3). /// </summary> /// <param name="image">the picture that sholud be splitted</param> /// <param name="width">into parts with width = <paramref name="width"/></param> /// <param name="height">into parts with height = height</param> /// <param name="xCount">rows</param> /// <param name="yCount">columns</param> /// <returns></returns> public List<Shape> Split(Texture2D image, int width, int height, int xCount = 3, int yCount = 3) { List<Shape> result = new List<Shape>(); int dataPerPart = width * height; int uniqueIndexer = 1; Color[] originalData = new Color[image.Width * image.Height]; image.GetData<Color>(originalData); for (int y = 0; y < yCount * height; y += height) for (int x = 0; x < xCount * width; x += width) { Texture2D part = new Texture2D(image.GraphicsDevice, width, height); Color[] partData = new Color[dataPerPart]; for (int py = 0; py < height; py++) for (int px = 0; px < width; px++) { int partIndex = px + py * width; if (y + py >= image.Height || x + px >= image.Width) partData[partIndex] = Color.Transparent; else partData[partIndex] = originalData[(x + px) + (y + py) * image.Width]; } part.SetData<Color>(partData); Shape shape = new Shape(part); shape.UniqueNumber = uniqueIndexer; uniqueIndexer++; result.Add(shape); } return result; }
private void LoadTexture(Texture2D texture) { var data = new Int32[texture.Width*texture.Height]; texture.GetData(data); // Make levels of darkness m_TextureData = new Int32[Darknesslevels][,]; float darkness = 1.0f; for (int d = 0; d < Darknesslevels; d++) { m_TextureData[d] = new Int32[texture.Width,texture.Height]; for (int x = 0; x < texture.Width; x++) { for (int y = 0; y < texture.Height; y++) { var index = x + (texture.Width*y); var pixel = data[index]; var bytes = BitConverter.GetBytes(pixel); pixel = 255 << 24 | (Byte) (bytes[2]/darkness) << 16 | (Byte) (bytes[1]/darkness) << 8 | (Byte) (bytes[0]/darkness); m_TextureData[d][x, y] = pixel; } } // TODO find the perfect co-efficents for the equation of darkness darkness += 0.00f + (d*0.0125f) + (d*d*0.00025f); } }
public static uint[] GetTextureData(Texture2D texture) { int dataLength = texture.Width * texture.Height; uint[] pixelData = new uint[dataLength]; texture.GetData<uint>(pixelData); return pixelData; }
public NinePatchImage(Texture2D texture) { _texture = texture; XnaColor[] data = new XnaColor[texture.Width * texture.Height]; texture.GetData(data); Stretch = new Area( vertical: GetLine(texture, data, 0, 1, 0, 0), horizontal: GetLine(texture, data, 1, 0, 0, 0)); Content = new Area( vertical: GetLine(texture, data, 0, 1, _texture.Width - 1, 0), horizontal: GetLine(texture, data, 1, 0, 0, _texture.Height - 1)); Width = _texture.Width - 2; Height = _texture.Height - 2; _leftTop = new XnaRectangle(1, 1, Stretch.Horizontal.Start, Stretch.Vertical.Start); _leftCenter = new XnaRectangle(1, Stretch.Vertical.Start, Stretch.Horizontal.Start, Stretch.Vertical.Size); _leftBottom = new XnaRectangle(1, Stretch.Vertical.End, Stretch.Horizontal.Start, texture.Height - 1 - Stretch.Vertical.End); _centerTop = new XnaRectangle(Stretch.Horizontal.Start, 1, Stretch.Horizontal.Size, Stretch.Vertical.Start); _center = new XnaRectangle(Stretch.Horizontal.Start, Stretch.Vertical.Start, Stretch.Horizontal.Size, Stretch.Vertical.Size); _centerBottom = new XnaRectangle(Stretch.Horizontal.Start, Stretch.Vertical.End, Stretch.Horizontal.Size, texture.Height - 1 - Stretch.Vertical.End); _rightTop = new XnaRectangle(Stretch.Horizontal.End, 1, texture.Width - 1 - Stretch.Horizontal.End, Stretch.Vertical.Start); _rightCenter = new XnaRectangle(Stretch.Horizontal.End, Stretch.Vertical.Start, texture.Width - 1 - Stretch.Horizontal.End, Stretch.Vertical.Size); _rightBottom = new XnaRectangle(Stretch.Horizontal.End, Stretch.Vertical.End, texture.Width - 1 - Stretch.Horizontal.End, texture.Height - 1 - Stretch.Vertical.End); }
public Level Parse(Texture2D mapImage) { Level level = new Level(); _levelScaleFactor = 4; _imageHeight = mapImage.Height; _imageWidth = mapImage.Width; Color[] colorData; colorData = new Color[_imageWidth * _imageHeight]; mapImage.GetData<Color>(colorData); for (int y = 0; y < _imageHeight; y++) { for (int x = 0; x < _imageWidth; x++) { Color currentPixel = colorData[_imageWidth * y + x]; if (currentPixel == Color.White) continue; Point position = new Point(x, y); //Wall if all are the same if (currentPixel.R == currentPixel.G && currentPixel.G == currentPixel.B) HandleWall(position, currentPixel, colorData, level); else if (currentPixel == PLAYER_COLOR) HandlePlayer(position, currentPixel, colorData, level); else if (currentPixel == FRIENDLY_COLOR) HandleFriendly(position, currentPixel, colorData, level); else if (currentPixel == ENEMY_COLOR) HandleEnemy(position, currentPixel, colorData, level); } } return level; }
public static Texture2D Crop(Texture2D source, Rectangle area) { if (source == null) return null; Texture2D cropped = new Texture2D(source.GraphicsDevice, area.Width, area.Height); Color[] data = new Color[source.Width * source.Height]; Color[] cropData = new Color[cropped.Width * cropped.Height]; source.GetData<Color>(data); int index = 0; for (int y = area.Y; y < area.Y + area.Height; y++) { for (int x = area.X; x < area.X + area.Width; x++) { cropData[index] = data[x + (y * source.Width)]; index++; } } cropped.SetData<Color>(cropData); return cropped; }
public IMTexture(Texture2D texture) { Texture = texture; LODColor = Color.Black; // If this is a null texture, use a black LOD color. if (Texture == null) return; // Calculate the load color dynamically. float r = 0, g = 0, b = 0; Color[] pixelData = new Color[texture.Width * texture.Height]; texture.GetData<Color>(pixelData); for (int i = 0; i < texture.Width; i++) for (int j = 0; j < texture.Height; j++) { r += pixelData[i + j * texture.Width].R; g += pixelData[i + j * texture.Width].G; b += pixelData[i + j * texture.Width].B; } r /= texture.Width * texture.Height; g /= texture.Width * texture.Height; b /= texture.Width * texture.Height; LODColor = new Color(r / 256, g / 256, b / 256); }
public static void CopyAlpha(ref Texture2D TextureTo, Texture2D TextureFrom) { if (TextureTo.Width != TextureFrom.Width || TextureTo.Height != TextureFrom.Height) { return; } var size = TextureTo.Width * TextureTo.Height; uint[] buffer = GetBuffer(); TextureTo.GetData(buffer, 0, size); var sizeFrom = TextureFrom.Width * TextureFrom.Height; var bufferFrom = GetBuffer(); TextureFrom.GetData(bufferFrom, 0, sizeFrom); for (int i = 0; i < size; i++) { //ARGB buffer[i] = (buffer[i] & 0x00FFFFFF) | (bufferFrom[i] & 0xFF000000); } TextureTo.SetData(buffer, 0, size, SetDataOptions.None); FreeBuffer(buffer); FreeBuffer(bufferFrom); }
/// <summary> /// Checks for collision in the bitmap /// </summary> /// <param name="collisionTexture">texture you want collision against</param> /// <param name="checkPoint">point you want to check for collision</param> /// <returns>collision type</returns> public CollisionType CheckForCollisions(Texture2D collisionTexture, Point checkPoint) { var collisionColors = new Color[collisionTexture.Height * collisionTexture.Width]; collisionTexture.GetData(collisionColors); var checkIndex = checkPoint.X + checkPoint.Y * collisionTexture.Width; // Index out of bounds if (checkIndex > collisionColors.Length - 1) return CollisionType.Unwalkable; var detectedColor = collisionColors[checkIndex]; if (detectedColor == BushTile) return CollisionType.Bush; if ( detectedColor == HealingHerb ) return CollisionType.HealingHerb; if (detectedColor == WalkableTile) return CollisionType.Walkable; if (detectedColor == TrainerTriggerBushTile) return CollisionType.TrainerTriggerBush; if (detectedColor == TrainerTriggerTile) return CollisionType.TrainerTrigger; return CollisionType.Unwalkable; }
public void LoadContent(ContentManager contentManager, string theAsset) { Texture = contentManager.Load<Texture2D>(theAsset); Size = new Rectangle(0, 0, (int) (Texture.Width * Scale), (int) (Texture.Height * Scale)); TextureData = new Color[Texture.Width * Texture.Height]; Texture.GetData(TextureData); }
public bool PixelCollision(Texture2D player, Rectangle playerR, Rectangle cannonR) { Texture2D cannon = this.texCannon; Color[] colorDataPlayer = new Color[player.Width * player.Height]; Color[] colorDataCannon = new Color[cannon.Width * cannon.Height]; player.GetData<Color>(colorDataPlayer); cannon.GetData<Color>(colorDataCannon); int top, bottom, left, right; top = Math.Max(playerR.Top, cannonR.Top); //el mayor top (el q esta mas abajo) osea el top del rectangulo q se forma al colisionar bottom = Math.Min(playerR.Bottom, cannonR.Bottom); left = Math.Max(playerR.Left, cannonR.Left); right = Math.Min(playerR.Right, cannonR.Right); for (int y = top; y < bottom; y++) { for (int x = left; x < right; x++) { Color A = colorDataPlayer[(y - playerR.Top) * (playerR.Width) + (x - playerR.Left)]; Color B = colorDataCannon[(y - cannonR.Top) * (cannonR.Width) + (x - cannonR.Left)]; if (A.A != 0 && B.A != 0)//si el alpha no es 0 (no es transparente) colisiona return true; } } return false; }
public static void blit(Texture2D src, Rectangle srcRect, Texture2D dest, Rectangle destRect) { int count = srcRect.Width * srcRect.Height; uint[] data = new uint[count]; src.GetData<uint>(0, srcRect, data, 0, count); dest.SetData<uint>(0, destRect, data, 0, count, SetDataOptions.None); }
public static WriteableBitmap ToBitmapSource(this Texture2D texture) { var bmp = new WriteableBitmap(texture.Width, texture.Height, 96, 96, PixelFormats.Bgra32, null); var pixelData = new int[texture.Width * texture.Height]; texture.GetData(pixelData); bmp.Lock(); unsafe { var pixels = (int *)bmp.BackBuffer; for (var i = 0; i < pixelData.Length; i++) { pixels[i] = ColorToWindows(pixelData[i]); } } bmp.AddDirtyRect(new Int32Rect(0, 0, texture.Width, texture.Height)); bmp.Unlock(); return(bmp); }
public static CellSurface ToSurface(this Texture2D image, SadConsole.Font font, bool blockMode = false) { int imageWidth = image.Width; int imageHeight = image.Height; Color[] pixels = new Color[imageWidth * imageHeight]; image.GetData <Color>(pixels); CellSurface surface = new CellSurface(imageWidth / font.Size.X, imageHeight / font.Size.Y); global::System.Threading.Tasks.Parallel.For((int)0, (int)(imageHeight / font.Size.Y), (h) => //for (int h = 0; h < imageHeight / font.Size.Y; h++) { int startY = (h * font.Size.Y); //System.Threading.Tasks.Parallel.For(0, imageWidth / font.Size.X, (w) => for (int w = 0; w < imageWidth / font.Size.X; w++) { int startX = (w * font.Size.X); float allR = 0; float allG = 0; float allB = 0; for (int y = 0; y < font.Size.Y; y++) { for (int x = 0; x < font.Size.X; x++) { int cY = y + startY; int cX = x + startX; Color color = pixels[cY * imageWidth + cX]; allR += color.R; allG += color.G; allB += color.B; } } byte sr = (byte)(allR / (font.Size.X * font.Size.Y)); byte sg = (byte)(allG / (font.Size.X * font.Size.Y)); byte sb = (byte)(allB / (font.Size.X * font.Size.Y)); var newColor = new Color(sr, sg, sb); float sbri = newColor.GetBrightness() * 255; if (blockMode) { if (sbri > 204) { surface.SetGlyph(w, h, 219, newColor); //█ } else if (sbri > 152) { surface.SetGlyph(w, h, 178, newColor); //▓ } else if (sbri > 100) { surface.SetGlyph(w, h, 177, newColor); //▒ } else if (sbri > 48) { surface.SetGlyph(w, h, 176, newColor); //░ } } else { if (sbri > 230) { surface.SetGlyph(w, h, (int)'#', newColor); } else if (sbri > 207) { surface.SetGlyph(w, h, (int)'&', newColor); } else if (sbri > 184) { surface.SetGlyph(w, h, (int)'$', newColor); } else if (sbri > 161) { surface.SetGlyph(w, h, (int)'X', newColor); } else if (sbri > 138) { surface.SetGlyph(w, h, (int)'x', newColor); } else if (sbri > 115) { surface.SetGlyph(w, h, (int)'=', newColor); } else if (sbri > 92) { surface.SetGlyph(w, h, (int)'+', newColor); } else if (sbri > 69) { surface.SetGlyph(w, h, (int)';', newColor); } else if (sbri > 46) { surface.SetGlyph(w, h, (int)':', newColor); } else if (sbri > 23) { surface.SetGlyph(w, h, (int)'.', newColor); } } } } ); return(surface); }
public static void ToSurface(this Texture2D image, BasicSurface surface, Color[] cachedColorArray, bool blockMode = false) { int imageWidth = image.Width; int imageHeight = image.Height; image.GetData <Color>(cachedColorArray); SurfaceEditor editor = new SurfaceEditor(surface); editor.Clear(); global::System.Threading.Tasks.Parallel.For(0, imageHeight / surface.Font.Size.Y, (h) => //for (int h = 0; h < imageHeight / surface.Font.Size.Y; h++) { int startY = (h * surface.Font.Size.Y); //System.Threading.Tasks.Parallel.For(0, imageWidth / surface.Font.Size.X, (w) => for (int w = 0; w < imageWidth / surface.Font.Size.X; w++) { int startX = (w * surface.Font.Size.X); float allR = 0; float allG = 0; float allB = 0; for (int y = 0; y < surface.Font.Size.Y; y++) { for (int x = 0; x < surface.Font.Size.X; x++) { int cY = y + startY; int cX = x + startX; Color color = cachedColorArray[cY * imageWidth + cX]; allR += color.R; allG += color.G; allB += color.B; } } byte sr = (byte)(allR / (surface.Font.Size.X * surface.Font.Size.Y)); byte sg = (byte)(allG / (surface.Font.Size.X * surface.Font.Size.Y)); byte sb = (byte)(allB / (surface.Font.Size.X * surface.Font.Size.Y)); var newColor = new Color(sr, sg, sb); float sbri = newColor.GetBrightness() * 255; if (blockMode) { if (sbri > 204) { editor.SetGlyph(w, h, 219, newColor); //█ } else if (sbri > 152) { editor.SetGlyph(w, h, 178, newColor); //▓ } else if (sbri > 100) { editor.SetGlyph(w, h, 177, newColor); //▒ } else if (sbri > 48) { editor.SetGlyph(w, h, 176, newColor); //░ } } else { if (sbri > 230) { editor.SetGlyph(w, h, (int)'#', newColor); } else if (sbri > 207) { editor.SetGlyph(w, h, (int)'&', newColor); } else if (sbri > 184) { editor.SetGlyph(w, h, (int)'$', newColor); } else if (sbri > 161) { editor.SetGlyph(w, h, (int)'X', newColor); } else if (sbri > 138) { editor.SetGlyph(w, h, (int)'x', newColor); } else if (sbri > 115) { editor.SetGlyph(w, h, (int)'=', newColor); } else if (sbri > 92) { editor.SetGlyph(w, h, (int)'+', newColor); } else if (sbri > 69) { editor.SetGlyph(w, h, (int)';', newColor); } else if (sbri > 46) { editor.SetGlyph(w, h, (int)':', newColor); } else if (sbri > 23) { editor.SetGlyph(w, h, (int)'.', newColor); } } } } ); }
public override void GetData <T>(T[] data, int mipLevel, int left, int right, int startIndex, int elementCount) { _texture2D.GetData <T>(mipLevel, new Microsoft.Xna.Framework.Rectangle(0, 0, left, right), data, startIndex, elementCount); }