Пример #1
0
        public static ITexture2D New(VideoTypes videoType, IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
        {
            ITexture2D api = null;

            #if WIN32
            if (videoType == VideoTypes.D3D9) api = new D3D9.Texture2D(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback);
            #endif

            #if WIN32 || WINRT || WP8
            if (videoType == VideoTypes.D3D11) api = new D3D11.Texture2D(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback);
            #endif

            #if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl
            if (videoType == VideoTypes.OpenGL) api = new OpenGL.Texture2D(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback);
            #endif

            #if XNA
            if (videoType == VideoTypes.XNA) api = new XNA.Texture2D(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback);
            #endif

            #if VITA
            if (videoType == VideoTypes.Vita) api = new Vita.Texture2D(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback);
            #endif

            if (api == null) Debug.ThrowError("Texture2DAPI", "Unsuported InputType: " + videoType);
            return api;
        }
Пример #2
0
 public Texture2D(IDisposableResource parent, string filename, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
     : base(parent)
 {
     Image.New(filename, false,
     delegate (object sender, bool succeeded)
     {
         if (succeeded)
         {
             var image = (Image)sender;
             init(parent, image, image.Size.Width, image.Size.Height, generateMipmaps, MultiSampleTypes.None, image.SurfaceFormat, RenderTargetUsage.PlatformDefault, usage, false, loadedCallback);
         }
         else
         {
             FailedToLoad = true;
             Dispose();
             if (loadedCallback != null) loadedCallback(this, false);
         }
     });
 }
Пример #3
0
        protected override bool init(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
        {
            initSuccess = base.init(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, true, loadedCallback);
            if (!initSuccess) return false;

            try
            {
                if (usage == BufferUsages.Write) Debug.ThrowError("RenderTarget", "Only Textures may be writable");

                if (image != null)
                {
                    width = image.Size.Width;
                    height = image.Size.Height;
                    surfaceFormat = image.SurfaceFormat;
                }

                renderTargetCom = new RenderTargetCom();
                var error = renderTargetCom.Init(video.com, width, height, com, 0, video.surfaceFormat(surfaceFormat), usage == BufferUsages.Read);

                switch (error)
                {
                    case RenderTargetError.RenderTargetView: Debug.ThrowError("RenderTarget", "Failed to create RenderTargetView"); break;
                    case RenderTargetError.StagingTexture: Debug.ThrowError("RenderTarget", "Failed to create Staging Texture"); break;
                }
            }
            catch (Exception e)
            {
                FailedToLoad = true;
                Loader.AddLoadableException(e);
                Dispose();
                if (loadedCallback != null) loadedCallback(this, false);
                return false;
            }

            Loaded = true;
            if (loadedCallback != null) loadedCallback(this, true);
            return true;
        }
Пример #4
0
 public Texture2D(DisposableI parent, int width, int height, SurfaceFormats surfaceFormat, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
     : base(parent)
 {
     init(parent, null, null, width, height, false, MultiSampleTypes.None, surfaceFormat, RenderTargetUsage.PlatformDefault, usage, false, loadedCallback);
 }
Пример #5
0
        protected unsafe virtual bool init(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
        {
            try
            {
                if (usage == BufferUsages.Read && !isRenderTarget) Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");

                video = parent.FindParentOrSelfWithException<Video>();
                if (isRenderTarget) generateMipmaps = false;

                uint texturesTEMP = 0;
                GL.GenTextures(1, &texturesTEMP);
                Texture = texturesTEMP;
                if (Texture == 0) Debug.ThrowError("Texture2D", "Failed to Generate Texture");

                GL.BindTexture(GL.TEXTURE_2D, Texture);
                if (!generateMipmaps) GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR);
                else GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR_MIPMAP_LINEAR);
                GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MAG_FILTER, GL.LINEAR);

                hasMipmaps = false;
                if (image != null)
                {
                    var imageType = image.GetType();

                    #if NaCl
                    if (imageType == typeof(ImageBMPC))
                    #else
                    if (imageType == typeof(ImagePNG) || imageType == typeof(ImageJPG) || imageType == typeof(ImageBMP) || imageType == typeof(ImageBMPC))
                    #endif
                    {
                        uint pixelOrder, byteSizes;
                        int format = Video.surfaceFormat(surfaceFormat, out pixelOrder, out byteSizes);
                        var mipmap = image.Mipmaps[0];
                        fixed (byte* data = mipmap.Data)
                        {
                            GL.TexImage2D(GL.TEXTURE_2D, 0, format, mipmap.Size.Width, mipmap.Size.Height, 0, pixelOrder, byteSizes, data);
                            if (generateMipmaps)
                            {
                                hasMipmaps = true;
                                GL.GenerateMipmap(GL.TEXTURE_2D);
                            }
                        }
                    }
                    else if (imageType == typeof(ImageDDS) || imageType == typeof(ImagePVR))
                    {
                        if (image.Mipmaps.Length != Image.Mipmap.CalculateMipmapLvls(image.Size.Width, image.Size.Height))
                        {
                            Debug.ThrowError("Texture2D", "Compressed Textures require full mipmap chain");
                        }
                        GL.TexParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR_MIPMAP_LINEAR);
                        hasMipmaps = true;

                        bool compressed = false;
                        uint format = 0;
                        string errorType = null;
                        if (imageType == typeof(ImageDDS))
                        {
                            var imageDDS = (ImageDDS)image;
                            compressed = imageDDS.Compressed;
                            format = imageDDS.FormatGL;
                            errorType = "DDS";
                        }
                        else if (imageType == typeof(ImagePVR))
                        {
                            var imagePVR = (ImagePVR)image;
                            compressed = imagePVR.Compressed;
                            format = imagePVR.FormatGL;
                            errorType = "PVR";
                        }

                        if (compressed)
                        {
                            for (int i = 0; i < image.Mipmaps.Length; ++i)
                            {
                                var mipmap = image.Mipmaps[i];
                                fixed (byte* data = mipmap.Data)
                                {
                                    // look up:: libtxc_dxtn.so for linux with mesa
                                    GL.CompressedTexImage2D(GL.TEXTURE_2D, i, format, mipmap.Size.Width, mipmap.Size.Height, 0, mipmap.Data.Length, data);
                                }
                            }
                        }
                        else
                        {
                            Debug.ThrowError("Texture2D", "Loading uncompresed " + errorType + " textures not supported");
                        }
                    }

                    Size = image.Size;
                    PixelByteSize = image.CalculatePixelByteSize();
                }
                else
                {
                    //GL.TexImage2D(GL.TEXTURE_2D, 0, Video.surfaceFormat(surfaceFormat), width, height, 0, GL.RGBA, GL.UNSIGNED_BYTE, IntPtr.Zero.ToPointer());
                    uint pixelOrder, byteSizes;
                    int format = Video.surfaceFormat(surfaceFormat, out pixelOrder, out byteSizes);
                    GL.TexImage2D(GL.TEXTURE_2D, 0, format, width, height, 0, pixelOrder, byteSizes, IntPtr.Zero.ToPointer());
                    if (generateMipmaps)
                    {
                        hasMipmaps = true;
                        GL.GenerateMipmap(GL.TEXTURE_2D);
                    }
                    Size = new Size2(width, height);
                    PixelByteSize = Image.CalculatePixelByteSize((surfaceFormat == SurfaceFormats.Defualt ? Video.DefaultSurfaceFormat() : surfaceFormat), width, height);
                }

                SizeF = Size.ToVector2();

                uint error;
                string errorName;
                if (Video.checkForError(out error, out errorName))
                {
                    Debug.ThrowError("Texture2D", string.Format("{0} {1}: Failed to load/create texture", error, errorName));
                }
            }
            catch (Exception e)
            {
                FailedToLoad = true;
                Loader.AddLoadableException(e);
                Dispose();
                if (loadedCallback != null) loadedCallback(this, false);
                return false;
            }

            if (!isRenderTarget)
            {
                Loaded = true;
                if (loadedCallback != null) loadedCallback(this, true);
            }
            return true;
        }
Пример #6
0
        protected override bool init(DisposableI parent, string fileName, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
        {
            if (!base.init(parent, fileName, width, height, false, multiSampleType, surfaceFormat, renderTargetUsage, usage, true, loadedCallback)) return false;

            try
            {
                if (usage == BufferUsages.Write) Debug.ThrowError("RenderTarget", "Only Textures may be writable");

                frameBuffer = new G.FrameBuffer();
                frameBuffer.SetColorTarget(texture, 0);
            }
            catch (Exception e)
            {
                FailedToLoad = true;
                Loader.AddLoadableException(e);
                Dispose();
                if (loadedCallback != null) loadedCallback(this, false);
                return false;
            }

            Loaded = true;
            if (loadedCallback != null) loadedCallback(this, true);
            return true;
        }
Пример #7
0
 public RenderTarget(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
     : base(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback)
 {
     if (initSuccess) initDepthStencil(width, height, depthStencilFormat);
 }
Пример #8
0
        protected virtual bool init(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, bool lockable, Loader.LoadedCallbackMethod loadedCallback)
        {
            byte[][] mipmaps = null;
            int[] mipmapSizes = null, mipmapPitches = null;
            try
            {
                video = parent.FindParentOrSelfWithException<Video>();
                if (isRenderTarget) generateMipmaps = false;

                // load image data
                if (image != null)
                {
                    mipmaps = new byte[image.Mipmaps.Length][];
                    mipmapSizes = new int[image.Mipmaps.Length];
                    mipmapPitches = new int[image.Mipmaps.Length];
                    for (int i = 0; i != mipmaps.Length; ++i)
                    {
                        var imageMipmap = image.Mipmaps[i];
                        mipmaps[i] = image.Compressed ? imageMipmap.Data : imageMipmap.SwapRBColorChannels();
                        mipmapSizes[i] = imageMipmap.Data.Length;
                        mipmapPitches[i] = imageMipmap.Pitch;
                    }

                    Size = image.Size;
                    surfaceFormat = image.SurfaceFormat;
                    PixelByteSize = image.CalculatePixelByteSize();
                }
                else
                {
                    if (width == 0 || height == 0) Debug.ThrowError("Texture2D", "Width or Height cannot be 0");
                    Size = new Size2(width, height);
                    PixelByteSize = Image.CalculatePixelByteSize((surfaceFormat == SurfaceFormats.Defualt ? Video.DefaultSurfaceFormat() : surfaceFormat), width, height);
                }
                TexelOffset = (1 / Size.ToVector2()) * .5f;
                SizeF = Size.ToVector2();

                // init texture
                REIGN_D3DUSAGE nativeUsage = isRenderTarget ? REIGN_D3DUSAGE.RENDERTARGET : REIGN_D3DUSAGE.NONE;
                REIGN_D3DPOOL nativePool = (mipmaps != null && !video.Caps.ExDevice) ? REIGN_D3DPOOL.MANAGED : REIGN_D3DPOOL.DEFAULT;
                if (usage == BufferUsages.Read)
                {
                    if (!isRenderTarget) Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
                    // NOTE: Staging texture and states will be created in the RenderTarget
                }
                if (usage == BufferUsages.Write)
                {
                    if (mipmaps != null)
                    {
                        if (video.Caps.ExDevice) nativeUsage |= REIGN_D3DUSAGE.DYNAMIC;
                    }
                    else
                    {
                        nativeUsage |= REIGN_D3DUSAGE.DYNAMIC;
                    }
                }
                com = new Texture2DCom();
                var error = com.Init(video.com, Size.Width, Size.Height, generateMipmaps, mipmaps, mipmapSizes, mipmapPitches, 0, nativePool, nativeUsage, video.surfaceFormat(surfaceFormat), isRenderTarget);

                switch (error)
                {
                    case TextureError.Texture: Debug.ThrowError("Texture2D", "Failed to create Texture2D"); break;
                    case TextureError.SystemTexture: Debug.ThrowError("Texture2D", "Failed to create System Texture2D"); break;
                }

                if (!video.Caps.ExDevice && nativePool != REIGN_D3DPOOL.MANAGED)
                {
                    LostDevice_image = image;
                    LostDevice_width = width;
                    LostDevice_height = height;
                    LostDevice_generateMipmaps = generateMipmaps;
                    LostDevice_multiSampleType = multiSampleType;
                    LostDevice_surfaceFormat = surfaceFormat;
                    LostDevice_renderTargetUsage = renderTargetUsage;
                    LostDevice_usage = usage;
                    LostDevice_isRenderTarget = isRenderTarget;
                    LostDevice_lockable = lockable;
                    LostDevice_pool = nativePool;
                }

                if (nativePool == REIGN_D3DPOOL.DEFAULT && !video.Caps.ExDevice && !video.deviceReseting)
                {
                    video.DeviceLost += deviceLost;
                    video.DeviceReset += deviceReset;
                }
            }
            catch (Exception e)
            {
                FailedToLoad = true;
                Loader.AddLoadableException(e);
                Dispose();
                if (loadedCallback != null) loadedCallback(this, false);
                return false;
            }

            if (!isRenderTarget)
            {
                Loaded = true;
                if (loadedCallback != null) loadedCallback(this, true);
            }
            return true;
        }
Пример #9
0
		internal REIGN_DXGI_FORMAT surfaceFormat(SurfaceFormats surfaceFormat)
		{
			switch (surfaceFormat)
			{
				case SurfaceFormats.Defualt:
					#if ARM
					return REIGN_DXGI_FORMAT.B4G4R4A4_UNORM;
					#else
					return REIGN_DXGI_FORMAT.R8G8B8A8_UNORM;
					#endif

				case SurfaceFormats.DXT1: return REIGN_DXGI_FORMAT.BC1_UNORM;
				case SurfaceFormats.DXT3: return REIGN_DXGI_FORMAT.BC2_UNORM;
				case SurfaceFormats.DXT5: return REIGN_DXGI_FORMAT.BC3_UNORM;
				case SurfaceFormats.RGBx565: return REIGN_DXGI_FORMAT.B5G6R5_UNORM;
				#if WINRT || WP8
				case SurfaceFormats.RGBAx4: return REIGN_DXGI_FORMAT.B4G4R4A4_UNORM;
				#endif
				case SurfaceFormats.RGBx5_Ax1: return REIGN_DXGI_FORMAT.B5G5R5A1_UNORM;
				case SurfaceFormats.RGBAx8: return REIGN_DXGI_FORMAT.R8G8B8A8_UNORM;
				case SurfaceFormats.RGBx10_Ax2: return REIGN_DXGI_FORMAT.R10G10B10A2_UNORM;
				case SurfaceFormats.RGBAx16f: return REIGN_DXGI_FORMAT.R16G16B16A16_FLOAT;
				case SurfaceFormats.RGBAx32f: return REIGN_DXGI_FORMAT.R32G32B32A32_FLOAT;

				default:
					Debug.ThrowError("Video", "Unsuported SurfaceFormat: " + surfaceFormat);
					return REIGN_DXGI_FORMAT.R8G8B8A8_UNORM;
			}
		}
Пример #10
0
        protected override bool init(DisposableI parent, string fileName, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
        {
            if (!base.init(parent, fileName, image, width, height, false, multiSampleType, surfaceFormat, renderTargetUsage, usage, true, loadedCallback)) return false;

            try
            {
                if (usage == BufferUsages.Write) Debug.ThrowError("RenderTarget", "Only Textures may be writable");

                if (fileName == null)
                {
                    // TODO: handle multiSampleType types
                    #if SILVERLIGHT
                    var xUsage = X.RenderTargetUsage.PreserveContents;
                    #else
                    var xUsage = X.RenderTargetUsage.PlatformContents;
                    #endif
                    switch (renderTargetUsage)
                    {
                        case RenderTargetUsage.PlatformDefault:
                            #if SILVERLIGHT
                            xUsage = X.RenderTargetUsage.PreserveContents;
                            #else
                            xUsage = X.RenderTargetUsage.PlatformContents;
                            #endif
                            break;

                        case RenderTargetUsage.PreserveContents: xUsage = X.RenderTargetUsage.PreserveContents; break;
                        case RenderTargetUsage.DiscardContents: xUsage = X.RenderTargetUsage.DiscardContents; break;
                    }

                    X.DepthFormat format = X.DepthFormat.None;
                    if (initDepthStencilFormat != DepthStencilFormats.None)
                    {
                        switch (initDepthStencilFormat)
                        {
                            case DepthStencilFormats.Defualt: format = X.DepthFormat.Depth24; break;
                            case DepthStencilFormats.Depth24Stencil8: format = X.DepthFormat.Depth24Stencil8; break;
                            case DepthStencilFormats.Depth16: format = X.DepthFormat.Depth16; break;
                            case DepthStencilFormats.Depth24: format = X.DepthFormat.Depth24; break;

                            default:
                                Debug.ThrowError("RenderTarget", "Unsuported DepthStencilFormat type");
                                break;
                        }
                    }

                    renderTarget = new X.RenderTarget2D(video.Device, width, height, false, Video.surfaceFormat(surfaceFormat), format, 0, xUsage);
                }
                else
                {
                    Debug.ThrowError("RenderTarget", "(Load image data into RenderTarget Texture) -- Not implemented yet...");
                }

                texture = renderTarget;
            }
            catch (Exception e)
            {
                FailedToLoad = true;
                Loader.AddLoadableException(e);
                Dispose();
                if (loadedCallback != null) loadedCallback(this, false);
                return false;
            }

            Loaded = true;
            if (loadedCallback != null) loadedCallback(this, true);
            return true;
        }
Пример #11
0
 public RenderTarget(DisposableI parent, int width, int height, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, BufferUsages usage, RenderTargetUsage renderTargetUsage, Loader.LoadedCallbackMethod loadedCallback)
     : base(parent, width, height, surfaceFormat, usage, loadedCallback)
 {
     initDepthStencilFormat = depthStencilFormat;
 }
Пример #12
0
 public Texture2D(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
     : base(parent)
 {
     init(parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, false, loadedCallback);
 }
Пример #13
0
        protected virtual bool init(DisposableI parent, string fileName, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
        {
            try
            {
                if (usage == BufferUsages.Read && !isRenderTarget) Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");

                video = parent.FindParentOrSelfWithException<Video>();

                if (!isRenderTarget)
                {
                    if (fileName != null || image != null)
                    {
                        #if SILVERLIGHT
                        texture = new X.Texture2D(video.Device, image.Size.Width, image.Size.Height, image.Mipmaps.Length != 0, Video.surfaceFormat(surfaceFormat));
                        for (int i = 0; i != image.Mipmaps.Length; ++i)
                        {
                            var mipmap = image.Mipmaps[i];
                            texture.SetData<byte>(i, null, mipmap.Data, 0, mipmap.Data.Length);
                        }
                        #else
                        texture = parent.FindParentOrSelfWithException<RootDisposable>().Content.Load<X.Texture2D>(Streams.StripFileExt(fileName));
                        loadedFromContentManager = true;
                        #endif
                    }
                    else
                    {
                        texture = new X.Texture2D(video.Device, width, height, generateMipmaps, Video.surfaceFormat(surfaceFormat));
                    }

                    Size = new Size2(texture.Width, texture.Height);
                    PixelByteSize = Image.CalculatePixelByteSize(surfaceFormat, texture.Width, texture.Height);
                }
                else
                {
                    Size = new Size2(width, height);
                    PixelByteSize = Image.CalculatePixelByteSize(surfaceFormat, width, height);
                }

                TexelOffset = (1 / Size.ToVector2()) * .5f;
                SizeF = Size.ToVector2();
            }
            catch (Exception e)
            {
                FailedToLoad = true;
                Loader.AddLoadableException(e);
                Dispose();
                if (loadedCallback != null) loadedCallback(this, false);
                return false;
            }

            if (!isRenderTarget)
            {
                Loaded = true;
                if (loadedCallback != null) loadedCallback(this, true);
            }
            return true;
        }
Пример #14
0
 public static Texture2D New(DisposableI parent, int width, int height, SurfaceFormats surfaceFormat, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
 {
     return new Texture2D(parent, width, height, surfaceFormat, usage, loadedCallback);
 }
Пример #15
0
        protected virtual bool init(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
        {
            long[] mipmaps = null;
            int[] mipmapSizes = null, mipmapPitches = null;
            try
            {
                video = parent.FindParentOrSelfWithException<Video>();
                if (isRenderTarget) generateMipmaps = false;

                // load image data
                if (image != null)
                {
                    mipmaps = new long[image.Mipmaps.Length];
                    mipmapSizes = new int[image.Mipmaps.Length];
                    mipmapPitches = new int[image.Mipmaps.Length];
                    for (int i = 0; i != mipmaps.Length; ++i)
                    {
                        var imageMipmap = image.Mipmaps[i];
                        IntPtr mipmapPtr = Marshal.AllocHGlobal(imageMipmap.Data.Length);
                        Marshal.Copy(imageMipmap.Data, 0, mipmapPtr, imageMipmap.Data.Length);
                        mipmapSizes[i] = imageMipmap.Data.Length;
                        mipmapPitches[i] = imageMipmap.Pitch;
                        mipmaps[i] = mipmapPtr.ToInt64();
                    }

                    Size = image.Size;
                    surfaceFormat = image.SurfaceFormat;
                    PixelByteSize = image.CalculatePixelByteSize();
                }
                else
                {
                    if (width == 0 || height == 0) Debug.ThrowError("Texture2D", "Width or Height cannot be 0");
                    Size = new Size2(width, height);
                    PixelByteSize = Image.CalculatePixelByteSize((surfaceFormat == SurfaceFormats.Defualt ? Video.DefaultSurfaceFormat() : surfaceFormat), width, height);
                }
                SizeF = Size.ToVector2();

                // init texture
                REIGN_D3D11_USAGE usageType = REIGN_D3D11_USAGE.DEFAULT;
                REIGN_D3D11_CPU_ACCESS_FLAG cpuAccessFlags = (REIGN_D3D11_CPU_ACCESS_FLAG)0;
                if (usage == BufferUsages.Read)
                {
                    if (!isRenderTarget) Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");
                    // NOTE: Staging texture and states will be created in the RenderTarget
                    //usageType = REIGN_D3D11_USAGE.STAGING;
                    //cpuAccessFlags = REIGN_D3D11_CPU_ACCESS_FLAG.READ;
                }
                if (usage == BufferUsages.Write)
                {
                    usageType = REIGN_D3D11_USAGE.DYNAMIC;
                    cpuAccessFlags = REIGN_D3D11_CPU_ACCESS_FLAG.WRITE;
                }
                com = new Texture2DCom();
                var error = com.Init(video.com, Size.Width, Size.Height, generateMipmaps, mipmaps != null, mipmaps, mipmapSizes, mipmapPitches, 0, video.surfaceFormat(surfaceFormat), usageType, cpuAccessFlags, isRenderTarget);

                switch (error)
                {
                    case TextureError.Texture: Debug.ThrowError("Texture2D", "Failed to create Texture2D"); break;
                    case TextureError.ShaderResourceView: Debug.ThrowError("Texture2D", "Failed to create ShaderResourceView"); break;
                }
            }
            catch (Exception e)
            {
                FailedToLoad = true;
                Loader.AddLoadableException(e);
                Dispose();
                if (loadedCallback != null) loadedCallback(this, false);
                return false;
            }
            finally
            {
                if (mipmaps != null)
                {
                    for (int i = 0; i != mipmaps.Length; ++i)
                    {
                        if (mipmaps[i] != 0) Marshal.FreeHGlobal(new IntPtr(mipmaps[i]));
                    }
                }
            }

            if (!isRenderTarget)
            {
                Loaded = true;
                if (loadedCallback != null) loadedCallback(this, true);
            }
            return true;
        }
Пример #16
0
        protected unsafe override bool init(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
        {
            initSuccess = base.init(parent, image, width, height, false, multiSampleType, surfaceFormat, renderTargetUsage, usage, true, loadedCallback);
            if (!initSuccess) return false;

            try
            {
                if (usage == BufferUsages.Write) Debug.ThrowError("RenderTarget", "Only Textures may be writable");

                uint frameBufferTEMP = 0;
                GL.GenFramebuffers(1, &frameBufferTEMP);
                frameBuffer = frameBufferTEMP;

                uint error;
                string errorName;
                if (Video.checkForError(out error, out errorName)) Debug.ThrowError("RenderTarget", string.Format("{0} {1}: Failed to create renderTarget", error, errorName));
            }
            catch (Exception e)
            {
                FailedToLoad = true;
                Loader.AddLoadableException(e);
                Dispose();
                if (loadedCallback != null) loadedCallback(this, false);
                return false;
            }

            Loaded = true;
            if (loadedCallback != null) loadedCallback(this, true);
            return true;
        }
Пример #17
0
        protected virtual bool init(DisposableI parent, string fileName, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, bool isRenderTarget, Loader.LoadedCallbackMethod loadedCallback)
        {
            try
            {
                if (usage == BufferUsages.Read && !isRenderTarget) Debug.ThrowError("Texture2D", "Only RenderTargets may be readable");

                video = parent.FindParentOrSelfWithException<Video>();
                if (isRenderTarget) generateMipmaps = false;

                if (fileName != null)
                {
                    texture = new G.Texture2D("/Application/" + fileName, generateMipmaps);
                }
                else
                {
                    texture = new G.Texture2D(width, height, generateMipmaps, Video.surfaceFormat(surfaceFormat), isRenderTarget ? G.PixelBufferOption.Renderable : G.PixelBufferOption.None);
                }
            }
            catch (Exception e)
            {
                FailedToLoad = true;
                Loader.AddLoadableException(e);
                Dispose();
                if (loadedCallback != null) loadedCallback(this, false);
                return false;
            }

            if (!isRenderTarget)
            {
                Loaded = true;
                if (loadedCallback != null) loadedCallback(this, true);
            }
            return true;
        }
Пример #18
0
        internal static PixelFormat surfaceFormat(SurfaceFormats surfaceFormat)
        {
            switch (surfaceFormat)
            {
                case SurfaceFormats.Defualt: return PixelFormat.Rgba4444;
                case SurfaceFormats.RGBx565: return PixelFormat.Rgb565;
                case SurfaceFormats.RGBAx4: return PixelFormat.Rgba4444;
                case SurfaceFormats.RGBx5_Ax1: return PixelFormat.Rgba5551;
                case SurfaceFormats.RGBAx8: return PixelFormat.Rgba;
                case SurfaceFormats.RGBAx16f: return PixelFormat.RgbaH;

                default:
                    Debug.ThrowError("RenderTarget", "Unsuported SurfaceFormat");
                    return PixelFormat.Rgba;
            }
        }
Пример #19
0
 public static IRenderTarget New(IDisposableResource parent, int width, int height, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
 {
     return New(VideoAPI.DefaultAPI, parent, (Image)null, width, height, false, multiSampleType, surfaceFormat, depthStencilFormat, renderTargetUsage, usage, loadedCallback);
 }
Пример #20
0
 public static RenderTarget New(DisposableI parent, int width, int height, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, BufferUsages usage, RenderTargetUsage renderTargetUsage, Loader.LoadedCallbackMethod loadedCallback)
 {
     return new RenderTarget(parent, width, height, multiSampleType, surfaceFormat, depthStencilFormat, usage, renderTargetUsage, loadedCallback);
 }
Пример #21
0
 public static ITexture2D New(IDisposableResource parent, Image image, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
 {
     return New(VideoAPI.DefaultAPI, parent, image, width, height, generateMipmaps, multiSampleType, surfaceFormat, renderTargetUsage, usage, loadedCallback);
 }
Пример #22
0
        internal REIGN_D3DFORMAT surfaceFormat(SurfaceFormats surfaceFormat)
        {
            switch (surfaceFormat)
            {
                case SurfaceFormats.Defualt: return REIGN_D3DFORMAT.A8R8G8B8;
                case SurfaceFormats.DXT1: return REIGN_D3DFORMAT.DXT1;
                case SurfaceFormats.DXT3: return REIGN_D3DFORMAT.DXT3;
                case SurfaceFormats.DXT5: return REIGN_D3DFORMAT.DXT5;
                case SurfaceFormats.RGBx565: return REIGN_D3DFORMAT.R5G6B5;
                case SurfaceFormats.RGBAx4: return REIGN_D3DFORMAT.A4R4G4B4;
                case SurfaceFormats.RGBx5_Ax1: return REIGN_D3DFORMAT.A1R5G5B5;
                case SurfaceFormats.RGBAx8: return REIGN_D3DFORMAT.A8R8G8B8;
                case SurfaceFormats.RGBx10_Ax2: return REIGN_D3DFORMAT.A2R10G10B10;
                case SurfaceFormats.RGBAx16f: return REIGN_D3DFORMAT.A16B16G16R16F;
                case SurfaceFormats.RGBAx32f: return REIGN_D3DFORMAT.A32B32G32R32F;

                default:
                    Debug.ThrowError("Video", "Unsuported SurfaceFormat: " + surfaceFormat);
                    return REIGN_D3DFORMAT.A8R8G8B8;
            }
        }
Пример #23
0
        public static int CalculatePixelByteSize(SurfaceFormats surfaceFormat, int width, int height)
        {
            switch (surfaceFormat)
            {
                case SurfaceFormats.RGBx565: return width * height * 2;
                case SurfaceFormats.RGBAx4: return width * height * 2;
                case SurfaceFormats.RGBx5_Ax1: return width * height * 2;
                case SurfaceFormats.RGBAx8: return width * height * 4;
                case SurfaceFormats.RGBx10_Ax2: return width * height * 4;
                case SurfaceFormats.RGBAx16f: return (width * height * 4) * 2;
                case SurfaceFormats.RGBAx32f: return (width * height * 4) * 4;
                case SurfaceFormats.DXT1: return (width * height) / 2;
                case SurfaceFormats.DXT3: return width * height;
                case SurfaceFormats.DXT5: return width * height;
                case SurfaceFormats.ATC_RGB: return (width * height) / 2;
                case SurfaceFormats.ATC_RGBA_Explicit: return width * height;
                case SurfaceFormats.ATC_RGBA_Interpolated: return width * height;
                case SurfaceFormats.PVR_RGB_2: return (width * height) / 4;
                case SurfaceFormats.PVR_RGB_4: return (width * height) / 2;
                case SurfaceFormats.PVR_RGBA_2: return (width * height) / 4;
                case SurfaceFormats.PVR_RGBA_4: return (width * height) / 2;
                default: Debug.ThrowError("Image", string.Format("Unsuported surface format: {0}", surfaceFormat)); break;
            }

            return -1;
        }