Beispiel #1
0
 internal CleanupData(ManagedSpriteInstance instance)
 {
     PreviousSpriteInstance    = instance.PreviousSpriteInstance;
     ReferenceTexture          = instance.Reference;
     RecentAccessNode          = instance.RecentAccessNode;
     instance.RecentAccessNode = null;
     MapHash = instance.SpriteMapHash;
 }
Beispiel #2
0
    private static unsafe void SetDataPurge <T>(
        XTexture2D texture,
        XRectangle?rect,
        ReadOnlySpan <T> data,
        int startIndex,
        int elementCount,
        bool animated
        ) where T : unmanaged
    {
        TextureCache.Remove(texture);

        if (!ManagedSpriteInstance.Validate(texture, clean: true))
        {
            return;
        }

        if (texture.Format.IsBlock())
        {
            ManagedSpriteInstance.FullPurge(texture, animated: animated);
            return;
        }

#if ASYNC_SETDATA
        var byteData = Cacheable(texture) ? GetByteArray(data, startIndex, elementCount, out int elementSize) : null;

        ThreadQueue.Queue((data) =>
                          Thread.CurrentThread.Priority = ThreadPriority.BelowNormal;
                          ScaledTexture.Purge(
                              reference: texture,
                              bounds: rect,
                              data: new DataRef <byte>(
                                  data: data,
                                  offset: startIndex * elementSize,
                                  length: elementCount * elementSize
                                  )
                              ), byteData);
#else
        var byteData = Cacheable(texture) ? data : default;

        var span = byteData.IsEmpty ? default : byteData.Slice(startIndex, elementCount).AsBytes();

                   ManagedSpriteInstance.Purge(
                       reference: texture,
                       bounds: rect,
                       data: new(span),
                       animated: animated
                       );
#endif
    }
Beispiel #3
0
    internal ManagedTexture2D(
        ReadOnlyPinnedSpan <byte> .FixedSpan data,
        ManagedSpriteInstance instance,
        XTexture2D reference,
        Vector2I dimensions,
        SurfaceFormat format,
        string?name = null
        ) : base(
            graphicsDevice: reference.GraphicsDevice.IsDisposed ? DrawState.Device : reference.GraphicsDevice,
            width: dimensions.Width,
            height: dimensions.Height,
            mipmap: UseMips,
            format: format,
            type: PTexture2D.PlatformConstruct is null ? SurfaceType.Texture : SurfaceType.SwapChainRenderTarget,     // this prevents the texture from being constructed immediately
            shared: UseShared,
            arraySize: 1
            )
    {
        if (PTexture2D.PlatformConstruct is not null && !GL.Texture2DExt.Construct(this, data, dimensions, UseMips, format, SurfaceType.Texture, UseShared))
        {
            PTexture2D.PlatformConstruct(this, dimensions.X, dimensions.Y, UseMips, format, SurfaceType.Texture, UseShared);
            SetData(data.Array);
        }

        Name = name ?? $"{reference.NormalizedName()} [internal managed <{format}>]";

        Reference      = reference.MakeWeak();
        SpriteInstance = instance;
        Dimensions     = dimensions - instance.BlockPadding;

        reference.Disposing += OnParentDispose;

        Interlocked.Add(ref TotalAllocatedSize, (ulong)this.SizeBytes());
        Interlocked.Increment(ref TotalManagedTextures);

        if (Configuration.Config.Garbage.ShouldCollectAccountOwnedTextures)
        {
            Garbage.MarkOwned(format, dimensions.Area);
            Marked = true;
        }
    }