Exemplo n.º 1
0
        internal static void Dispose()
        {
            _font              = null;
            _fontSmall         = null;
            _uiSpritesheet     = null;
            _uiStylesheet      = null;
            Stylesheet.Current = null;

            _whiteRegion = null;
            if (_white != null)
            {
                _white.Dispose();
                _white = null;
            }

            if (_uiBitmap != null)
            {
                _uiBitmap.Dispose();
                _uiBitmap = null;
            }

#if !XENKO
            if (_uiRasterizerState != null)
            {
                _uiRasterizerState.Dispose();
                _uiRasterizerState = null;
            }
#endif
        }
Exemplo n.º 2
0
        /// <summary>
        /// Draws the specified texture.
        /// </summary>
        /// <param name="texture">The texture.</param>
        /// <param name="position">The position.</param>
        /// <param name="renderSize">Size of the render.</param>
        /// <param name="color">The color.</param>
        /// <param name="source">The source.</param>
        /// <param name="centerOrigin">if set to <c>true</c> [center origin].</param>
        public override void Draw(TextureBase texture, PointF position, Size renderSize, ColorW color, Rect source, bool centerOrigin)
        {
            testRectangle.X      = (int)position.X;
            testRectangle.Y      = (int)position.Y;
            testRectangle.Width  = (int)renderSize.Width;
            testRectangle.Height = (int)renderSize.Height;
            if (isClipped && !currentScissorRectangle.Intersects(testRectangle))
            {
                return;
            }

            sourceRect.X      = (int)source.X;
            sourceRect.Y      = (int)source.Y;
            sourceRect.Width  = (int)source.Width;
            sourceRect.Height = (int)source.Height;
            vecColor.A        = color.A;
            vecColor.R        = color.R;
            vecColor.G        = color.G;
            vecColor.B        = color.B;
            if (centerOrigin)
            {
                origin.X = testRectangle.Width / 2f;
                origin.Y = testRectangle.Height / 2f;
            }

            Texture2D native = texture.GetNativeTexture() as Texture2D;

            spriteBatch.Draw(native, testRectangle, sourceRect, vecColor, 0, origin);
        }
Exemplo n.º 3
0
        internal static void Dispose()
        {
            _font                 = null;
            _fontSmall            = null;
            _uiTextureRegionAtlas = null;
            _uiStylesheet         = null;
            Stylesheet.Current    = null;

            _assetManager.ClearCache();

            _whiteRegion = null;
            if (_white != null)
            {
                _white.Dispose();
                _white = null;
            }

#if !XENKO
            if (_uiRasterizerState != null)
            {
                _uiRasterizerState.Dispose();
                _uiRasterizerState = null;
            }
#endif
        }
Exemplo n.º 4
0
        public static Texture2D LoadTexture2D(Stream stream)
        {
#if !XENKO
            return(Texture2D.FromStream(MyraEnvironment.GraphicsDevice, stream));
#else
            return(Texture2D.Load(MyraEnvironment.GraphicsDevice, stream));
#endif
        }
Exemplo n.º 5
0
        public static Texture2D CreateTexture2D(int width, int height)
        {
#if !XENKO
            return(new Texture2D(MyraEnvironment.GraphicsDevice, width, height, false, SurfaceFormat.Color));
#else
            return(Texture2D.New2D(MyraEnvironment.GraphicsDevice, width, height, false, PixelFormat.R8G8B8A8_UNorm, TextureFlags.ShaderResource));
#endif
        }
Exemplo n.º 6
0
        private static void DrawPolygonEdge(SpriteBatch spriteBatch, Texture2D texture, Vector2 point1, Vector2 point2,
                                            Color color, float thickness)
        {
            var length = Vector2.Distance(point1, point2);
            var angle  = (float)Math.Atan2(point2.Y - point1.Y, point2.X - point1.X);
            var scale  = new Vector2(length, thickness);

            spriteBatch.Draw(texture, point1, color: color, rotation: angle, scale: scale);
        }
Exemplo n.º 7
0
        public TextureWithOffset(Texture2D texture)
        {
            if (texture == null)
            {
                throw new ArgumentNullException("texture");
            }

            Texture = texture;
        }
Exemplo n.º 8
0
        /// <summary>
        /// Draws the geometry texture.
        /// </summary>
        /// <param name="buffer">The buffer.</param>
        /// <param name="position">The position.</param>
        /// <param name="texture">The texture.</param>
        /// <param name="opacity">The opacity.</param>
        /// <param name="depth">The depth.</param>
        public override void DrawGeometryTexture(GeometryBuffer buffer, PointF position, TextureBase texture, float opacity, float depth)
        {
            XenkoGeometryBuffer paradoxBuffer = buffer as XenkoGeometryBuffer;
            Texture2D           nativeTexture = texture.GetNativeTexture() as Texture2D;

            paradoxBuffer.EffectInstance.Parameters.Set(SpriteEffectKeys.Color, Color.White * opacity);
            paradoxBuffer.EffectInstance.Parameters.Set(TexturingKeys.Texture0, nativeTexture);
            DrawGeometry(buffer, position, depth);
        }
Exemplo n.º 9
0
        public TextureRegion(Texture2D texture, Rectangle bounds)
        {
            if (texture == null)
            {
                throw new ArgumentNullException("texture");
            }

            _texture = texture;
            _bounds  = bounds;
        }
Exemplo n.º 10
0
        public static void SetData <T>(Texture2D texture, T[] data) where T : struct
        {
#if !XENKO
            texture.SetData(data);
#else
            var commandList = MyraEnvironment.Game.GraphicsContext.CommandList;

            texture.SetData(commandList, data);
#endif
        }
Exemplo n.º 11
0
        public static void SetData(Texture2D texture, Color[] data)
        {
#if !XENKO
            texture.SetData(data);
#else
            var commandList = MyraEnvironment.Game.GraphicsContext.CommandList;

            texture.SetData <Color>(commandList, data);
#endif
        }
Exemplo n.º 12
0
        public static Texture2D CreateTexture2D(GraphicsDevice graphicsDevice, int width, int height, byte[] data)
        {
#if !XENKO
            var result = new Texture2D(graphicsDevice, width, height, false, SurfaceFormat.Color);
            result.SetData(data);
            return(result);
#else
            return(Texture2D.New2D(graphicsDevice, width, height, PixelFormat.R8G8B8A8_UNorm, data));
#endif
        }
Exemplo n.º 13
0
        public TextureRegion(TextureRegion region, Rectangle bounds)
        {
            if (region == null)
            {
                throw new ArgumentNullException("region");
            }

            _texture = region.Texture;
            bounds.Offset(region.Bounds.Location);
            _bounds = bounds;
        }
Exemplo n.º 14
0
        public static Color[] GetData(Texture2D texture)
        {
#if !XENKO
            var result = new Color[texture.Width * texture.Height];
            texture.GetData(result);
            return(result);
#else
            var commandList = MyraEnvironment.Game.GraphicsContext.CommandList;

            return(texture.GetData <Color>(commandList));
#endif
        }
        private bool NeedToRecreateTexture(Xenko.Graphics.Texture tex, Vector3 dim)
        {
            if (tex == null || !TextureDimensionsEqual(tex, dim))
            {
                if (tex != null)
                {
                    tex.Dispose();
                }

                return(true);
            }
            return(false);
        }
    private bool NeedToRecreateTexture(Xenko.Graphics.Texture tex, Vector3 dim, Xenko.Graphics.PixelFormat pixelFormat, MultisampleCount samples)
    {
        if (tex == null || !TextureDimensionsEqual(tex, dim) || tex.Format != pixelFormat || tex.MultisampleCount != samples)
        {
            if (tex != null)
            {
                tex.Dispose();
            }

            return(true);
        }
        return(false);
    }
Exemplo n.º 17
0
        public static bool DisposeTextureBySpecs(Xenko.Graphics.Texture tex, Vector3 dim, Xenko.Graphics.PixelFormat pixelFormat, MultisampleCount samples)
        {
            if (tex == null || !TextureDimensionsEqual(tex, dim) || tex.Format != pixelFormat || tex.MultisampleCount != samples)
            {
                if (tex != null)
                {
                    tex.Dispose();
                }

                return(true);
            }
            return(false);
        }
    public void Render(VoxelStorageContext storageContext, IVoxelStorage Storage, RenderDrawContext drawContext)
    {
        if (NeedToRecreateTexture(MSAARenderTarget, new Vector3(voxelizationView.ViewSize.X, voxelizationView.ViewSize.Y, 1), PixelFormat.R8G8B8A8_UNorm, MultisampleCount.X8))
        {
            MSAARenderTarget = Texture.New(storageContext.device, TextureDescription.New2D((int)voxelizationView.ViewSize.X, (int)voxelizationView.ViewSize.Y, new MipMapCount(false), PixelFormat.R8G8B8A8_UNorm, TextureFlags.RenderTarget, 1, GraphicsResourceUsage.Default, MultisampleCount.X8), null);
        }
        drawContext.CommandList.ResetTargets();
        if (MSAARenderTarget != null)
        {
            drawContext.CommandList.SetRenderTarget(null, MSAARenderTarget);
        }

        Storage.Render(storageContext, drawContext, voxelizationView);
    }
Exemplo n.º 19
0
        /// <summary>
        /// Creates a Texture2D from Stream and optionally premultiplies alpha
        /// </summary>
        /// <param name="graphicsDevice"></param>
        /// <param name="stream"></param>
        /// <param name="premultiplyAlpha"></param>
        /// <returns></returns>
        public static unsafe Texture2D FromStream(Stream stream, bool premultiplyAlpha)
        {
            byte[] bytes;

            // Rewind stream if it is at end
            if (stream.CanSeek && stream.Length == stream.Position)
            {
                stream.Seek(0, SeekOrigin.Begin);
            }

            // Copy it's data to memory
            // As some platforms dont provide full stream functionality and thus streams can't be read as it is
            using (var ms = new MemoryStream())
            {
                stream.CopyTo(ms);
                bytes = ms.ToArray();
            }

            // The data returned is always four channel BGRA
            var result = ImageResult.FromMemory(bytes, ColorComponents.RedGreenBlueAlpha);

            if (premultiplyAlpha)
            {
                fixed(byte *b = &result.Data[0])
                {
                    for (var i = 0; i < result.Data.Length; i += 4)
                    {
                        var a = b[i + 3];
                        b[i]     = ApplyAlpha(b[i], a);
                        b[i + 1] = ApplyAlpha(b[i + 1], a);
                        b[i + 2] = ApplyAlpha(b[i + 2], a);
                    }
                }
            }

            Texture2D texture = null;

            texture = CrossEngineStuff.CreateTexture2D(result.Width, result.Height);
            CrossEngineStuff.SetData(texture, result.Data);

            return(texture);
        }
Exemplo n.º 20
0
        public static TextureRegionAtlas FromJson(string json, Texture2D texture)
        {
            var root = (Dictionary <string, object>)Json.Deserialize(json);

            var regions = new Dictionary <string, TextureRegion>();

            foreach (var pair in root)
            {
                var entry = (Dictionary <string, object>)pair.Value;

                var jBounds = (Dictionary <string, object>)entry[StylesheetLoader.BoundsName];
                var bounds  = new Rectangle(int.Parse(jBounds[StylesheetLoader.LeftName].ToString()),
                                            int.Parse(jBounds[StylesheetLoader.TopName].ToString()),
                                            int.Parse(jBounds[StylesheetLoader.WidthName].ToString()),
                                            int.Parse(jBounds[StylesheetLoader.HeightName].ToString()));

                TextureRegion region;
                if (entry[StylesheetLoader.TypeName].ToString() == "0")
                {
                    region = new TextureRegion(texture, bounds);
                }
                else
                {
                    var jPadding = (Dictionary <string, object>)entry[StylesheetLoader.PaddingName];
                    var padding  = new PaddingInfo
                    {
                        Left   = int.Parse(jPadding[StylesheetLoader.LeftName].ToString()),
                        Top    = int.Parse(jPadding[StylesheetLoader.TopName].ToString()),
                        Right  = int.Parse(jPadding[StylesheetLoader.RightName].ToString()),
                        Bottom = int.Parse(jPadding[StylesheetLoader.BottomName].ToString())
                    };

                    region = new NinePatchRegion(texture, bounds, padding);
                }

                regions[pair.Key.ToString()] = region;
            }

            return(new TextureRegionAtlas(regions));
        }
Exemplo n.º 21
0
        /// <summary>
        /// Creates the texture.
        /// </summary>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        /// <param name="mipmap">if set to <c>true</c> [mipmap].</param>
        /// <param name="dynamic">if set to <c>true</c> [dynamic].</param>
        /// <returns></returns>
        public override TextureBase CreateTexture(int width, int height, bool mipmap, bool dynamic)
        {
            if (width == 0 || height == 0)
            {
                return(null);
            }

            Texture2D native = null;

            if (dynamic)
            {
                native = Texture2D.New2D(GraphicsDevice, width, height, PixelFormat.R8G8B8A8_UNorm, usage: GraphicsResourceUsage.Dynamic);
            }
            else
            {
                native = Texture2D.New2D(GraphicsDevice, width, height, PixelFormat.R8G8B8A8_UNorm);
            }

            XenkoTexture texture = new XenkoTexture(native);

            return(texture);
        }
        public void Render(VoxelStorageContext storageContext, RenderDrawContext drawContext, RenderView view)
        {
            RenderView voxelizationView = view;
            Int2       ViewSize         = VoxelizationViewSizes[view];

            if (VoxelUtils.DisposeTextureBySpecs(MSAARenderTarget, new Vector3(ViewSize.X, ViewSize.Y, 1), PixelFormat.R8G8B8A8_UNorm, MultisampleCount))
            {
                MSAARenderTarget = Texture.New(storageContext.device, TextureDescription.New2D(ViewSize.X, ViewSize.Y, new MipMapCount(false), PixelFormat.R8G8B8A8_UNorm, TextureFlags.RenderTarget, 1, GraphicsResourceUsage.Default, MultisampleCount), null);
            }

            drawContext.CommandList.ResetTargets();
            if (MSAARenderTarget != null)
            {
                drawContext.CommandList.SetRenderTarget(null, MSAARenderTarget);
            }

            var renderSystem = drawContext.RenderContext.RenderSystem;

            drawContext.CommandList.SetViewport(new Viewport(0, 0, ViewSize.X, ViewSize.Y));

            renderSystem.Draw(drawContext, voxelizationView, renderSystem.RenderStages[voxelizationView.RenderStages[0].Index]);
        }
        public virtual void Collect(RenderContext Context, IShadowMapRenderer ShadowMapRenderer)
        {
            renderVoxelVolumes = Context.VisibilityGroup.Tags.Get(CurrentRenderVoxelVolumes);

            if (renderVoxelVolumes == null)
            {
                return;
            }

            Vector3 resolutionMax     = new Vector3(0, 0, 0);
            int     fragmentsMax      = 0;
            int     fragmentsCountMax = 0;

            //Create per-volume textures
            foreach (var pair in renderVoxelVolumes)
            {
                var volume = pair.Value;
                var bounds = volume.ClipMapMatrix.ScaleVector;

                var resolution = bounds / volume.AproxVoxelSize;

                //Calculate closest power of 2 on each axis
                resolution.X = (float)Math.Pow(2, Math.Round(Math.Log(resolution.X, 2)));
                resolution.Y = (float)Math.Pow(2, Math.Round(Math.Log(resolution.Y, 2)));
                resolution.Z = (float)Math.Pow(2, Math.Round(Math.Log(resolution.Z, 2)));

                resolution = new Vector3(resolution.X, resolution.Z, resolution.Y);//Temporary

                Vector3 ClipMapResolution = new Vector3(resolution.X, resolution.Y, resolution.Z * volume.ClipMapCount);
                Vector3 MipMapResolution  = resolution / 2;

                RenderVoxelVolumeData data;
                if (!renderVoxelVolumeData.TryGetValue(pair.Key, out data))
                {
                    renderVoxelVolumeData.Add(pair.Key, data = new RenderVoxelVolumeData());
                }

                data.ClipMapResolution = resolution;
                if (NeedToRecreateTexture(data.ClipMaps, ClipMapResolution))
                {
                    data.ClipMaps = Xenko.Graphics.Texture.New3D(Context.GraphicsDevice, (int)ClipMapResolution.X, (int)ClipMapResolution.Y, (int)ClipMapResolution.Z, new MipMapCount(false), Xenko.Graphics.PixelFormat.R16G16B16A16_Float, TextureFlags.ShaderResource | TextureFlags.UnorderedAccess);
                }
                if (NeedToRecreateTexture(data.MipMaps, resolution))
                {
                    data.MipMaps = Xenko.Graphics.Texture.New3D(Context.GraphicsDevice, (int)MipMapResolution.X, (int)MipMapResolution.Y, (int)MipMapResolution.Z, new MipMapCount(true), Xenko.Graphics.PixelFormat.R16G16B16A16_Float, TextureFlags.ShaderResource | TextureFlags.UnorderedAccess);
                }


                resolutionMax     = Vector3.Min(new Vector3(256), Vector3.Max(resolutionMax, resolution));
                fragmentsMax      = Math.Max(fragmentsMax, (int)(ClipMapResolution.X * ClipMapResolution.Y * ClipMapResolution.Z));
                fragmentsCountMax = Math.Max(fragmentsCountMax, (int)(ClipMapResolution.X * ClipMapResolution.Y) * volume.ClipMapCount);
            }

            //Create re-usable textures

            float resolutionMaxSide = Math.Max(Math.Max(resolutionMax.X, resolutionMax.Y), resolutionMax.Z);

            if (NeedToRecreateTexture(MSAARenderTarget, new Vector3(resolutionMaxSide, resolutionMaxSide, 1)))
            {
                MSAARenderTarget = Texture.New(Context.GraphicsDevice, TextureDescription.New2D((int)resolutionMaxSide, (int)resolutionMaxSide, new MipMapCount(false), PixelFormat.R8G8B8A8_UNorm, TextureFlags.RenderTarget, 1, GraphicsResourceUsage.Default, MultisampleCount.X8), null);
            }

            if (NeedToRecreateBuffer(Fragments, fragmentsMax))
            {
                Fragments = Xenko.Graphics.Buffer.Structured.New(Context.GraphicsDevice, fragmentsMax, 24, true);
            }
            if (NeedToRecreateBuffer(FragmentsCounter, fragmentsCountMax))
            {
                FragmentsCounter = Xenko.Graphics.Buffer.Typed.New(Context.GraphicsDevice, fragmentsCountMax, PixelFormat.R32_SInt, true);
            }

            Vector3 MipMapResolutionMax = resolutionMax / 2;

            if (TempMipMaps == null || !TextureDimensionsEqual(TempMipMaps[0], MipMapResolutionMax))
            {
                if (TempMipMaps != null)
                {
                    for (int i = 0; i < TempMipMaps.Length; i++)
                    {
                        TempMipMaps[0].Dispose();
                    }
                }

                int mipCount = 1 + (int)Math.Floor(Math.Log(Math.Max(MipMapResolutionMax.X, Math.Max(MipMapResolutionMax.Y, MipMapResolutionMax.Z)), 2));

                TempMipMaps = new Xenko.Graphics.Texture[mipCount];

                for (int i = 0; i < TempMipMaps.Length; i++)
                {
                    TempMipMaps[i] = Xenko.Graphics.Texture.New3D(Context.GraphicsDevice, (int)MipMapResolutionMax.X, (int)MipMapResolutionMax.Y, (int)MipMapResolutionMax.Z, false, Xenko.Graphics.PixelFormat.R16G16B16A16_Float, TextureFlags.ShaderResource | TextureFlags.UnorderedAccess);

                    MipMapResolutionMax /= 2;
                    MipMapResolutionMax  = Vector3.Max(new Vector3(1), MipMapResolutionMax);
                }
            }
            if (Generate3DMipmaps == null)
            {
                Generate3DMipmaps = new Xenko.Rendering.ComputeEffect.ComputeEffectShader(Context)
                {
                    ShaderSourceName = "Generate3DMipmaps"
                };
                ClearBuffer = new Xenko.Rendering.ComputeEffect.ComputeEffectShader(Context)
                {
                    ShaderSourceName = "ClearBuffer"
                };
                ArrangeFragments = new Xenko.Rendering.ComputeEffect.ComputeEffectShader(Context)
                {
                    ShaderSourceName = "ArrangeFragments"
                };
            }

            //Create all the views
            reflectiveVoxelViews.Clear();
            foreach (var pair in renderVoxelVolumes)
            {
                var volume = pair.Value;
                var data   = renderVoxelVolumeData[pair.Key];
                var bounds = volume.ClipMapMatrix.ScaleVector;

                var shadowRenderView = new RenderView();

                float nearClip = 0.1f;
                float farClip  = 999.7f;
                //Currently hard coded and kinda odd
                shadowRenderView.View       = Matrix.Translation(0.0f, 1.0f, 0.0f) * Matrix.RotationX(-3.1415f / 2.0f);
                shadowRenderView.Projection = Matrix.OrthoRH(bounds.X * (float)Math.Pow(2, volume.ClipMapCount), bounds.Z * (float)Math.Pow(2, volume.ClipMapCount), nearClip, farClip);
                Matrix.Multiply(ref shadowRenderView.View, ref shadowRenderView.Projection, out shadowRenderView.ViewProjection);
                shadowRenderView.Frustum     = new BoundingFrustum(ref shadowRenderView.ViewProjection);
                shadowRenderView.CullingMode = CameraCullingMode.Frustum;
                shadowRenderView.ViewSize    = new Vector2(1024, 1024);

                float maxRes = Math.Max(Math.Max(data.ClipMapResolution.X, data.ClipMapResolution.Y), data.ClipMapResolution.Z);

                var rotmat = new Matrix(1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1);//xzy

                var viewToTexTrans = Matrix.Translation(0.5f, 0.5f, 0.5f);
                var viewToTexScale = Matrix.Scaling(0.5f, 0.5f, 0.5f);
                var viewportAspect = Matrix.Scaling(data.ClipMapResolution / maxRes);

                // Matrix BaseVoxelMatrix = transmat * scalemat * rotmat;
                Matrix BaseVoxelMatrix = volume.ClipMapMatrix * Matrix.Identity;
                BaseVoxelMatrix.Invert();
                BaseVoxelMatrix = BaseVoxelMatrix * Matrix.Scaling(2f, 2f, 2f) * rotmat;

                data.Matrix         = BaseVoxelMatrix * viewToTexScale * viewToTexTrans;
                data.ViewportMatrix = BaseVoxelMatrix * viewportAspect;
                data.ClipMapCount   = volume.ClipMapCount;

                shadowRenderView.NearClipPlane = nearClip;
                shadowRenderView.FarClipPlane  = farClip;
                shadowRenderView.RenderStages.Add(VoxelStage);

                reflectiveVoxelViews.Add(shadowRenderView, pair.Key);

                // Add the render view for the current frame
                Context.RenderSystem.Views.Add(shadowRenderView);

                // Collect objects in shadow views
                Context.VisibilityGroup.TryCollect(shadowRenderView);

                ShadowMapRenderer?.RenderViewsWithShadows.Add(shadowRenderView);
            }
        }
Exemplo n.º 24
0
 public static object GetNativeRenderTargetView(Texture texture)
 {
     return(GetNativeRenderTargetViewImpl(texture));
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="MonoGameTexture"/> class.
 /// </summary>
 /// <param name="nativeTexture">The native texture.</param>
 public XenkoTexture(object nativeTexture)
     : base(nativeTexture)
 {
     texture = nativeTexture as Texture2D;
 }
Exemplo n.º 26
0
 private static void Draw(this SpriteBatch spriteBatch, Texture2D texture, Vector2 offset, Color color, Vector2 scale, float rotation = 0.0f)
 {
     spriteBatch.Draw(texture, offset, null, color, rotation, Vector2.Zero, scale, SpriteEffects.None, 0.0f);
 }
Exemplo n.º 27
0
        public NinePatchRegion(Texture2D texture, Rectangle bounds, Thickness info) : base(texture, bounds)
        {
            _info = info;

            var centerWidth  = bounds.Width - info.Left - info.Right;
            var centerHeight = bounds.Height - info.Top - info.Bottom;

            var y = bounds.Y;

            if (info.Top > 0)
            {
                if (info.Left > 0)
                {
                    _topLeft = new TextureRegion(texture,
                                                 new Rectangle(bounds.X,
                                                               y,
                                                               info.Left,
                                                               info.Top));
                }

                if (centerWidth > 0)
                {
                    _topCenter = new TextureRegion(texture,
                                                   new Rectangle(bounds.X + info.Left,
                                                                 y,
                                                                 centerWidth,
                                                                 info.Top));
                }

                if (info.Right > 0)
                {
                    _topRight = new TextureRegion(texture,
                                                  new Rectangle(bounds.X + info.Left + centerWidth,
                                                                y,
                                                                info.Right,
                                                                info.Top));
                }
            }

            y += info.Top;
            if (centerHeight > 0)
            {
                if (info.Left > 0)
                {
                    _centerLeft = new TextureRegion(texture,
                                                    new Rectangle(bounds.X,
                                                                  y,
                                                                  info.Left,
                                                                  centerHeight));
                }

                if (centerWidth > 0)
                {
                    _center = new TextureRegion(texture,
                                                new Rectangle(bounds.X + info.Left,
                                                              y,
                                                              centerWidth,
                                                              centerHeight));
                }

                if (info.Right > 0)
                {
                    _centerRight = new TextureRegion(texture,
                                                     new Rectangle(bounds.X + info.Left + centerWidth,
                                                                   y,
                                                                   info.Right,
                                                                   centerHeight));
                }
            }

            y += centerHeight;
            if (info.Bottom > 0)
            {
                if (info.Left > 0)
                {
                    _bottomLeft = new TextureRegion(texture,
                                                    new Rectangle(bounds.X,
                                                                  y,
                                                                  info.Left,
                                                                  info.Bottom));
                }

                if (centerWidth > 0)
                {
                    _bottomCenter = new TextureRegion(texture,
                                                      new Rectangle(bounds.X + info.Left,
                                                                    y,
                                                                    centerWidth,
                                                                    info.Bottom));
                }

                if (info.Right > 0)
                {
                    _bottomRight = new TextureRegion(texture,
                                                     new Rectangle(bounds.X + info.Left + centerWidth,
                                                                   y,
                                                                   info.Right,
                                                                   info.Bottom));
                }
            }
        }
Exemplo n.º 28
0
 /// <summary>
 /// Covers the whole texture
 /// </summary>
 /// <param name="texture"></param>
 public TextureRegion(Texture2D texture) : this(texture, new Rectangle(0, 0, texture.Width, texture.Height))
 {
 }
Exemplo n.º 29
0
 public TextureWithOffset(Texture2D texture, Point offset) : this(texture)
 {
     Offset = offset;
 }
Exemplo n.º 30
0
 private static CpuDescriptorHandle GetNativeRenderTargetViewImpl(Texture texture)
 {
     return(texture.NativeRenderTargetView);
 }