Exemple #1
0
        public DepthStencil(DisposableI parent, int width, int height, DepthStencilFormats depthStencilFormats)
            : base(parent)
        {
            try
            {
                video = parent.FindParentOrSelfWithException <Video>();

                PixelFormat format = PixelFormat.None;
                switch (depthStencilFormats)
                {
                case DepthStencilFormats.Defualt: format = PixelFormat.Depth16; break;

                case DepthStencilFormats.Depth24Stencil8: format = PixelFormat.Depth24Stencil8; break;

                case DepthStencilFormats.Depth16: format = PixelFormat.Depth16; break;

                case DepthStencilFormats.Depth24: format = PixelFormat.Depth24; break;

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

                depthBuffer = new DepthBuffer(width, height, format);
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #2
0
 private void initDepthStencil(int width, int height, DepthStencilFormats depthStencilFormat)
 {
     if (depthStencilFormat != DepthStencilFormats.None)
     {
         depthStencil = new DepthStencil(this, width, height, depthStencilFormat);
     }
 }
        public static IRenderTarget New(VideoTypes videoType, IDisposableResource parent, string filename, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
        {
            IRenderTarget api = null;

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

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

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

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

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

            if (api == null) Debug.ThrowError("RenderTargetAPI", "Unsuported InputType: " + videoType);
            return api;
        }
Exemple #4
0
        public DepthStencil(DisposableI parent, int width, int height, DepthStencilFormats depthStencilFormats)
            : base(parent)
        {
            try
            {
                video = parent.FindParentOrSelfWithException<Video>();

                PixelFormat format = PixelFormat.None;
                switch (depthStencilFormats)
                {
                    case DepthStencilFormats.Defualt: format = PixelFormat.Depth16; break;
                    case DepthStencilFormats.Depth24Stencil8: format = PixelFormat.Depth24Stencil8; break;
                    case DepthStencilFormats.Depth16: format = PixelFormat.Depth16; break;
                    case DepthStencilFormats.Depth24: format = PixelFormat.Depth24; break;

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

                depthBuffer = new DepthBuffer(width, height, format);
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #5
0
        public DepthStencil(IDisposableResource parent, int width, int height, DepthStencilFormats depthStencilFormats)
            : base(parent)
        {
            try
            {
                var video = parent.FindParentOrSelfWithException <Video>();
                Size  = new Size2(width, height);
                SizeF = Size.ToVector2();

                int depthBit = 16, stencilBit = 0;
                switch (depthStencilFormats)
                {
                case DepthStencilFormats.Defualt:
                    depthBit   = 24;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth24Stencil8:
                    depthBit   = 24;
                    stencilBit = 8;
                    break;

                case DepthStencilFormats.Depth16:
                    depthBit   = 16;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth24:
                    depthBit   = 24;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth32:
                    depthBit   = 32;
                    stencilBit = 0;
                    break;

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

                com = new DepthStencilCom();
                var error = com.Init(video.com, width, height, depthBit, stencilBit);

                switch (error)
                {
                case DepthStencilErrors.Textrue: Debug.ThrowError("DepthStencil", "Failed to create Texture2D"); break;

                case DepthStencilErrors.DepthStencilView: Debug.ThrowError("DepthStencil", "Failed to create DepthStencilView"); break;
                }
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
        public DepthStencil(IDisposableResource parent, int width, int height, DepthStencilFormats depthStencilFormats)
            : base(parent)
        {
            try
            {
                var video = parent.FindParentOrSelfWithException<Video>();
                Size = new Size2(width, height);
                SizeF = Size.ToVector2();

                int depthBit = 16, stencilBit = 0;
                switch (depthStencilFormats)
                {
                    case DepthStencilFormats.Defualt:
                        depthBit = 24;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Depth24Stencil8:
                        depthBit = 24;
                        stencilBit = 8;
                        break;

                    case DepthStencilFormats.Depth16:
                        depthBit = 16;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Depth24:
                        depthBit = 24;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Depth32:
                        depthBit = 32;
                        stencilBit = 0;
                        break;

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

                com = new DepthStencilCom();
                var error = com.Init(video.com, width, height, depthBit, stencilBit);

                switch (error)
                {
                    case DepthStencilErrors.Textrue: Debug.ThrowError("DepthStencil", "Failed to create Texture2D"); break;
                    case DepthStencilErrors.DepthStencilView: Debug.ThrowError("DepthStencil", "Failed to create DepthStencilView"); break;
                }
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #7
0
 public Video(IDisposableResource parent, IApplication application, DepthStencilFormats depthStencilFormats, bool vSync)
     : base(parent)
 {
                 #if WINRT
     var xamlApp = application as XAMLApplication;
     init(parent, application, depthStencilFormats, vSync, xamlApp != null ? ((XAMLApplication)application).SwapChainPanel : null);
                 #else
     init(parent, application, depthStencilFormats, vSync);
                 #endif
 }
Exemple #8
0
		public Video(IDisposableResource parent, IApplication application, DepthStencilFormats depthStencilFormats, bool vSync)
		: base(parent)
		{
			#if WINRT
			var xamlApp = application as XAMLApplication;
			init(parent, application, depthStencilFormats, vSync, xamlApp != null ? ((XAMLApplication)application).SwapChainPanel : null);
			#else
			init(parent, application, depthStencilFormats, vSync);
			#endif
		}
Exemple #9
0
        public Video(DisposableI parent, ApplicationI application, DepthStencilFormats depthStencilFormats, bool vSync)
            : base(parent)
        {
            try
            {
                this.application     = application;
                FileTag              = "Vita_";
                currentPixelTextures = new Texture2D[4];
                currentSamplerStates = new SamplerState[4];

                PixelFormat format = PixelFormat.None;
                switch (depthStencilFormats)
                {
                case DepthStencilFormats.None: format = PixelFormat.None; break;

                case DepthStencilFormats.Defualt: format = PixelFormat.Depth16; break;

                case DepthStencilFormats.Depth24Stencil8: format = PixelFormat.Depth24Stencil8; break;

                case DepthStencilFormats.Depth16: format = PixelFormat.Depth16; break;

                case DepthStencilFormats.Depth24: format = PixelFormat.Depth24; break;

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

                context            = new GraphicsContext(0, 0, PixelFormat.Rgba, format, MultiSampleMode.None);
                currentFrameBuffer = context.Screen;
                BackBufferSize     = new Size2(currentFrameBuffer.Width, currentFrameBuffer.Height);
                ((VitaApplication)application).Vita_SetFrameSize(currentFrameBuffer.Width, currentFrameBuffer.Height);

                currentEnableMode = EnableMode.None;
                context.Enable(currentEnableMode);
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #10
0
        public Video(DisposableI parent, ApplicationI application, DepthStencilFormats depthStencilFormats, bool vSync)
            : base(parent)
        {
            if (depthStencilFormats != DepthStencilFormats.Defualt)
            {
                Debug.ThrowError("Video", "Only a Defualt DepthStenicFormat may be used in XNA here");
            }

            this.application = application;
            Device           = application.GraphicsDevice;
            defualtStates();

                        #if SILVERLIGHT
            FileTag = "Silverlight_";
                        #else
            FileTag = "XNA_";
                        #endif
            BackBufferSize = application.FrameSize;

            backBuffers = Device.GetRenderTargets();
        }
Exemple #11
0
        public Video(DisposableI parent, ApplicationI application, DepthStencilFormats depthStencilFormats, bool vSync)
            : base(parent)
        {
            try
            {
                this.application = application;
                FileTag = "Vita_";
                currentPixelTextures = new Texture2D[4];
                currentSamplerStates = new SamplerState[4];

                PixelFormat format = PixelFormat.None;
                switch (depthStencilFormats)
                {
                    case DepthStencilFormats.None: format = PixelFormat.None; break;
                    case DepthStencilFormats.Defualt: format = PixelFormat.Depth16; break;
                    case DepthStencilFormats.Depth24Stencil8: format = PixelFormat.Depth24Stencil8; break;
                    case DepthStencilFormats.Depth16: format = PixelFormat.Depth16; break;
                    case DepthStencilFormats.Depth24: format = PixelFormat.Depth24; break;

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

                context = new GraphicsContext(0, 0, PixelFormat.Rgba, format, MultiSampleMode.None);
                currentFrameBuffer = context.Screen;
                BackBufferSize = new Size2(currentFrameBuffer.Width, currentFrameBuffer.Height);
                ((VitaApplication)application).Vita_SetFrameSize(currentFrameBuffer.Width, currentFrameBuffer.Height);

                currentEnableMode = EnableMode.None;
                context.Enable(currentEnableMode);
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #12
0
        public static IDepthStencil New(VideoTypes videoType, IDisposableResource parent, int width, int height, DepthStencilFormats format)
        {
            IDepthStencil api = null;

            #if WIN32
            if (videoType == VideoTypes.D3D9) api = new D3D9.DepthStencil(parent, width, height, format);
            #endif

            #if WIN32 || WINRT || WP8
            if (videoType == VideoTypes.D3D11) api = new D3D11.DepthStencil(parent, width, height, format);
            #endif

            #if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl
            if (videoType == VideoTypes.OpenGL) api = new OpenGL.DepthStencil(parent, width, height, format);
            #endif

            #if VITA
            if (videoType == VideoTypes.Vita) api = new Vita.DepthStencil(parent, width, height, format);
            #endif

            if (api == null) Debug.ThrowError("DepthStencilAPI", "Unsuported InputType: " + videoType);
            return api;
        }
Exemple #13
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);
 }
Exemple #14
0
        public static IVideo New(VideoTypes videoTypeFlags, out VideoTypes videoType, IDisposableResource parent, IApplication application, DepthStencilFormats depthStencilFormats, bool vSync)
        {
            bool d3d11 = (videoTypeFlags & VideoTypes.D3D11) != 0;
            bool d3d9  = (videoTypeFlags & VideoTypes.D3D9) != 0;
            bool gl    = (videoTypeFlags & VideoTypes.OpenGL) != 0;
            bool xna   = (videoTypeFlags & VideoTypes.XNA) != 0;
            bool vita  = (videoTypeFlags & VideoTypes.Vita) != 0;

            videoType = VideoTypes.None;
            Exception lastException = null;
            IVideo    video         = null;

            while (true)
            {
                try
                {
                                        #if WIN32 || WINRT || WP8
                    if (d3d11)
                    {
                        d3d11     = false;
                        videoType = VideoTypes.D3D11;
                        video     = new Reign.Video.D3D11.Video(parent, application, depthStencilFormats, vSync);
                        break;
                    }
                                        #endif

                                        #if WIN32
                    else if (d3d9)
                    {
                        d3d9      = false;
                        videoType = VideoTypes.D3D9;
                        video     = new Reign.Video.D3D9.Video(parent, application, depthStencilFormats, vSync);
                        break;
                    }
                                        #endif

                                        #if WIN32 || OSX || LINUX || NaCl || iOS || ANDROID
                    if (gl)
                    {
                        gl        = false;
                        videoType = VideoTypes.OpenGL;
                        video     = new Reign.Video.OpenGL.Video(parent, application, depthStencilFormats, vSync);
                        break;
                    }
                                        #endif

                                        #if XNA
                    if (xna)
                    {
                        xna       = false;
                        videoType = VideoTypes.XNA;
                        video     = new Reign.Video.XNA.Video(parent, application, depthStencilFormats, vSync);
                        break;
                    }
                                        #endif

                                        #if VITA
                    if (vita)
                    {
                        vita      = false;
                        videoType = VideoTypes.Vita;
                        video     = new Reign.Video.Vita.Video(parent, application, depthStencilFormats, vSync);
                        break;
                    }
                                        #endif

                    else
                    {
                        break;
                    }
                }
                catch (Exception e)
                {
                    lastException = e;
                }
            }

            // check for error
            if (lastException != null)
            {
                string ex = lastException == null ? "" : " - Exception: " + lastException.Message;
                Debug.ThrowError("VideoAPI", "Failed to create Video API" + ex);
                videoType = VideoTypes.None;
            }

            if (videoType != VideoTypes.None)
            {
                DefaultAPI = videoType;
            }
            return(video);
        }
Exemple #15
0
        private void init(IDisposableResource parent, IApplication application, DepthStencilFormats depthStencilFormats, bool vSync)
                #endif
        {
            this.application = application;

            try
            {
                FileTag = "D3D11_";
                Cap     = new Caps();

                int depthBit = 16, stencilBit = 0;
                switch (depthStencilFormats)
                {
                case DepthStencilFormats.None:
                    depthBit   = 0;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Defualt:
                    depthBit   = 24;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth24Stencil8:
                    depthBit   = 24;
                    stencilBit = 8;
                    break;

                case DepthStencilFormats.Depth16:
                    depthBit   = 16;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth24:
                    depthBit   = 24;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth32:
                    depthBit   = 32;
                    stencilBit = 0;
                    break;

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

                com = new VideoCom();
                var featureLevel = REIGN_D3D_FEATURE_LEVEL.LEVEL_9_1;
                var frame        = application.FrameSize;
                                #if WIN32
                var error = com.Init(application.Handle, vSync, frame.Width, frame.Height, depthBit, stencilBit, false, out featureLevel);
                                #elif WINRT
                var error = com.Init(application.CoreWindow, vSync, frame.Width, frame.Height, depthBit, stencilBit, out featureLevel, swapChainBackgroundPanel);
                                #else
                var error = com.Init(vSync, frame.Width, frame.Height, depthBit, stencilBit, out featureLevel, OS.UpdateAndRender);
                                #endif
                BackBufferSize = frame;

                switch (error)
                {
                case VideoError.DepthStencilTextureFailed: Debug.ThrowError("Video", "Failed to create DepthStencilTexture"); break;

                case VideoError.DepthStencilViewFailed: Debug.ThrowError("Video", "Failed to create DepthStencilView"); break;

                case VideoError.RenderTargetViewFailed: Debug.ThrowError("Video", "Failed to create RenderTargetView"); break;

                                        #if !WP8
                case VideoError.GetSwapChainFailed: Debug.ThrowError("Video", "Failed to get SwapChain"); break;
                                        #endif
                                        #if WIN32
                case VideoError.DeviceAndSwapChainFailed: Debug.ThrowError("Video", "Failed to create Device and SwapChain"); break;
                                        #else
                case VideoError.DeviceFailed: Debug.ThrowError("Video", "Failed to create Device"); break;

                                        #if !WP8
                case VideoError.SwapChainFailed: Debug.ThrowError("Video", "Failed to create SwapChain"); break;

                case VideoError.D2DFactoryFailed: Debug.ThrowError("Video", "Failed to create D2D Factory"); break;

                case VideoError.D2DDeviceFailed: Debug.ThrowError("Video", "Failed to create D2D Device"); break;

                case VideoError.D2DDeviceContextFailed: Debug.ThrowError("Video", "Failed to D2D DeviceContext"); break;

                case VideoError.NativeSwapChainPanelFailed: Debug.ThrowError("Video", "Failed to get native SwapChainPanel"); break;

                case VideoError.GetDXGIBackBufferFailed: Debug.ThrowError("Video", "Failed to create DXGI BackBuffer"); break;

                case VideoError.DXGISurfaceFailed: Debug.ThrowError("Video", "Failed to create DXGI Surface"); break;

                case VideoError.D2DBitmapFailed: Debug.ThrowError("Video", "Failed to create D2D Bitmap"); break;
                                        #else
                case VideoError.RenderTextureFailed: Debug.ThrowError("Video", "Failed to create RenderTexture"); break;
                                        #endif
                                        #endif
                }

                                #if WP8
                ((XAMLApplication)application).MainPage.Surface.SetContentProvider(com.GetProvider());
                                #endif

                switch (featureLevel)
                {
                                        #if WINRT || WP8
                case REIGN_D3D_FEATURE_LEVEL.LEVEL_11_1:
                    Cap.MaxShaderVersion = ShaderVersions.HLSL_5_0;
                    Cap.FeatureLevel     = FeatureLevels.D3D11_1;
                    break;
                                        #endif

                case REIGN_D3D_FEATURE_LEVEL.LEVEL_11_0:
                    Cap.MaxShaderVersion = ShaderVersions.HLSL_5_0;
                    Cap.FeatureLevel     = FeatureLevels.D3D11;
                    break;

                case REIGN_D3D_FEATURE_LEVEL.LEVEL_10_1:
                    Cap.MaxShaderVersion = ShaderVersions.HLSL_4_1;
                    Cap.FeatureLevel     = FeatureLevels.D3D10_1;
                    break;

                case REIGN_D3D_FEATURE_LEVEL.LEVEL_10_0:
                    Cap.MaxShaderVersion = ShaderVersions.HLSL_4_0;
                    Cap.FeatureLevel     = FeatureLevels.D3D10;
                    break;

                case REIGN_D3D_FEATURE_LEVEL.LEVEL_9_3:
                    Cap.MaxShaderVersion = ShaderVersions.HLSL_3_0;
                    Cap.FeatureLevel     = FeatureLevels.D3D9_3;
                    break;

                case REIGN_D3D_FEATURE_LEVEL.LEVEL_9_2:
                    Cap.MaxShaderVersion = ShaderVersions.HLSL_2_a;
                    Cap.FeatureLevel     = FeatureLevels.D3D9_2;
                    break;

                case REIGN_D3D_FEATURE_LEVEL.LEVEL_9_1:
                    Cap.MaxShaderVersion = ShaderVersions.HLSL_2_0;
                    Cap.FeatureLevel     = FeatureLevels.D3D9_1;
                    break;
                }
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #16
0
		private void init(IDisposableResource parent, IApplication application, DepthStencilFormats depthStencilFormats, bool vSync, Windows.UI.Xaml.Controls.SwapChainBackgroundPanel swapChainBackgroundPanel)
Exemple #17
0
        public Video(IDisposableResource parent, IApplication application, DepthStencilFormats depthStencilFormats, bool vSync)
            : base(parent)
        {
            try
            {
                int depthBit = 16, stencilBit = 0;
                switch (depthStencilFormats)
                {
                case DepthStencilFormats.None:
                    depthBit   = 0;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Defualt:
                                                #if iOS || ANDROID || NaCl || RPI
                    depthBit   = 16;
                    stencilBit = 0;
                                                #else
                    depthBit   = 24;
                    stencilBit = 0;
                                                #endif
                    break;

                case DepthStencilFormats.Depth24Stencil8:
                    depthBit   = 24;
                    stencilBit = 8;
                    break;

                case DepthStencilFormats.Depth16:
                    depthBit   = 16;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth24:
                    depthBit   = 24;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth32:
                    depthBit   = 32;
                    stencilBit = 0;
                    break;

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

                currentTextures      = new Texture2D[8];
                currentSamplerStates = new SamplerState[8];

                                #if WIN32 || OSX || LINUX || NaCl
                BackBufferSize   = application.FrameSize;
                this.application = application;
                                #else
                BackBufferSize   = application.FrameSize;
                this.application = application;
                                #endif

                                #if WIN32
                //Get DC
                handle = application.Handle;
                dc     = WGL.GetDC(handle);
                WGL.SwapBuffers(dc);

                //Set BackBuffer format
                WGL.PIXELFORMATDESCRIPTOR pfd = new WGL.PIXELFORMATDESCRIPTOR();
                WGL.ZeroPixelDescriptor(ref pfd);
                pfd.nVersion   = 1;
                pfd.dwFlags    = WGL.PFD_DRAW_TO_WINDOW | WGL.PFD_SUPPORT_OPENGL | WGL.PFD_DOUBLEBUFFER;
                pfd.iPixelType = (byte)WGL.PFD_TYPE_RGBA;
                //pfd.cColorBits = 24;
                //pfd.cAlphaBits = 8;
                pfd.cDepthBits   = (byte)depthBit;
                pfd.cStencilBits = (byte)stencilBit;
                pfd.iLayerType   = (byte)WGL.PFD_MAIN_PLANE;
                unsafe { pfd.nSize = (ushort)sizeof(WGL.PIXELFORMATDESCRIPTOR); }

                int pixelFormatIndex          = WGL.ChoosePixelFormat(dc, ref pfd);
                if (pixelFormatIndex == 0)
                {
                    Debug.ThrowError("Video", "ChoosePixelFormat failed");
                }
                if (WGL.SetPixelFormat(dc, pixelFormatIndex, ref pfd) == 0)
                {
                    Debug.ThrowError("Video", "Failed to set PixelFormat");
                }

                ctx = WGL.CreateContext(dc);
                if (ctx == IntPtr.Zero)
                {
                    Debug.ThrowError("Video", "Failed to create GL context");
                }
                if (WGL.MakeCurrent(dc, ctx) == 0)
                {
                    Debug.ThrowError("Video", "Failed to make GL context current");
                }

                WGL.Init();
                WGL.SwapInterval(vSync ? 1 : 0);                // -1 for smart vsync
                                #endif

                                #if RPI
                unsafe
                {
                    // Init Pi video
                    RaspberryPi.bcm_host_init();

                    const int piDisplay = 0;
                    uint      piWidth = 0, piHeight = 0;
                    if (RaspberryPi.graphics_get_display_size(piDisplay, &piWidth, &piHeight) < 0)
                    {
                        Debug.ThrowError("Video", "Failed to get display size");
                    }
                    Console.WriteLine("piWidth - " + piWidth);
                    Console.WriteLine("piHeight - " + piHeight);
                    BackBufferSize = new Size2((int)piWidth, (int)piHeight);

                    IntPtr dispman_display = RaspberryPi.vc_dispmanx_display_open(piDisplay);
                    if (dispman_display == IntPtr.Zero)
                    {
                        Debug.ThrowError("Video", "Failed: vc_dispmanx_display_open");
                    }

                    IntPtr dispman_update = RaspberryPi.vc_dispmanx_update_start(0);
                    if (dispman_update == IntPtr.Zero)
                    {
                        Debug.ThrowError("Video", "Failed: vc_dispmanx_update_start");
                    }

                    var dstRect = new RaspberryPi.VC_RECT_T()
                    {
                        x      = 0,
                        y      = 0,
                        width  = (int)piWidth,
                        height = (int)piHeight
                    };
                    var srcRect = new RaspberryPi.VC_RECT_T()
                    {
                        x          = 0,
                        y          = 0,
                        width      = ((int)piWidth) << 16,
                            height = ((int)piHeight) << 16
                    };
                    IntPtr dispman_element = RaspberryPi.vc_dispmanx_element_add(dispman_update, dispman_display, 0, &dstRect, IntPtr.Zero, &srcRect, RaspberryPi.DISPMANX_PROTECTION_NONE, IntPtr.Zero, IntPtr.Zero, 0);
                    if (dispman_element == IntPtr.Zero)
                    {
                        Debug.ThrowError("Video", "Failed: vc_dispmanx_element_add");
                    }

                    nativeWindow = new RaspberryPi.DISPMANX_WINDOW_T()
                    {
                        element = dispman_element,
                        width   = (int)piWidth,
                        height  = (int)piHeight
                    };
                    windowHandle = GCHandle.Alloc(nativeWindow, GCHandleType.Pinned);
                    RaspberryPi.vc_dispmanx_update_submit_sync(dispman_update);

                    // Init EGL
                    handle = application.Handle;
                    GL.GetError();                    //NOTE: THIS MUST BE HERE SO THAT libGLES LOADS BEFORE libEGL
                    dc = EGL.GetDisplay(IntPtr.Zero);

                    int major, minor;
                    if (!EGL.Initialize(dc, out major, out minor))
                    {
                        Debug.ThrowError("Video", string.Format("Failed to initialize display connection, Error {0}", EGL.GetError()));
                    }

                    int[] pixelFormat = new int[]
                    {
                        //EGL.RENDERABLE_TYPE, EGL.OPENGL_ES2_BIT,

                        //EGL.RED_SIZE, 5,
                        //EGL.GREEN_SIZE, 6,
                        //EGL.BLUE_SIZE, 5,
                        //EGL.ALPHA_SIZE, 0,//EGL.DONT_CARE,
                        EGL.SURFACE_TYPE, EGL.WINDOW_BIT,

                        EGL.DEPTH_SIZE, depthBit,
                        //EGL.STENCIL_SIZE, stencilBit,//EGL.DONT_CARE,//<<<<<<<<<< Test enabling this!

                        //EGL.SAMPLE_BUFFERS, 0,
                        //EGL.SAMPLES, 0,

                        //EGL.MIN_SWAP_INTERVAL, 0,
                        //EGL.MAX_SWAP_INTERVAL, 1,

                        EGL.NONE,
                    };

                    int num_configs;
                    var configs = new IntPtr();
                    if (EGL.ChooseConfig(dc, pixelFormat, &configs, 1, &num_configs) == 0 || num_configs == 0)
                    {
                        Debug.ThrowError("Video", string.Format("Failed to retrieve GraphicsMode, error {0}", EGL.GetError()));
                    }

                    if (EGL.BindAPI(EGL.OPENGL_ES_API) == 0)
                    {
                        Debug.ThrowError("Video", "Failed to bind GLES API");
                    }
                    ;

                    int[] attrib_list = new int[]
                    {
                        EGL.CONTEXT_CLIENT_VERSION, 2,
                        EGL.NONE
                    };

                    ctx = EGL.CreateContext(dc, configs, IntPtr.Zero, attrib_list);
                    if (ctx == IntPtr.Zero)
                    {
                        Debug.ThrowError("Video", "Failed to create context");
                    }

                    surface = EGL.CreateWindowSurface(dc, configs, windowHandle.AddrOfPinnedObject(), null);
                    //surface = EGL.CreateWindowSurface(dc, configs[0], handle, null);// <<<<<<<<<<<<<<<<<<<<<<<<<<<< used in x11
                    if (surface == IntPtr.Zero)
                    {
                        Debug.ThrowError("Video", "Failed to create window surface");
                    }

                    if (EGL.MakeCurrent(dc, surface, surface, ctx) == 0)
                    {
                        Debug.ThrowError("Video", "Failed to make EGL context current");
                    }
                    //if (EGL.SwapInterval(dc, vSync ? 1 : 0) == 0) Debug.ThrowError("Video", "Failed to set vSync");
                    checkForEGLError();
                }
                                #elif LINUX
                //Get DC
                handle = application.Handle;
                dc     = X11.XOpenDisplay(IntPtr.Zero);
                int screen = X11.XDefaultScreen(dc);

                //Set Pixel format
                int[] attrbs =
                {
                    GLX.RGBA,
                    GLX.DOUBLEBUFFER,// 1,
                    //GLX.RED_SIZE, 8,
                    //GLX.GREEN_SIZE, 8,
                    //GLX.BLUE_SIZE, 8,
                    //GLX.ALPHA_SIZE, 8,
                    GLX.DEPTH_SIZE,depthBit,
                    GLX.NONE
                };

                IntPtr visual = GLX.ChooseVisual(dc, screen, attrbs);
                if (visual == IntPtr.Zero)
                {
                    Debug.ThrowError("Video", "Failed to get visual");
                }

                ctx = GLX.CreateContext(dc, visual, new IntPtr(0), true);
                GLX.MakeCurrent(dc, handle, ctx);

                bool failed = false;
                try { GLX.SwapIntervalSGI(vSync ? 1 : 0); }
                catch { failed = true; }

                if (failed)
                {
                    GLX.Init();
                    GLX.SwapIntervalMesa(vSync ? 1 : 0);
                }
                                #endif

                                #if OSX
                var attribs = new object[]
                {
                    NSOpenGLPixelFormatAttribute.Window,
                    NSOpenGLPixelFormatAttribute.Accelerated,
                    NSOpenGLPixelFormatAttribute.NoRecovery,
                    NSOpenGLPixelFormatAttribute.DoubleBuffer,
                    NSOpenGLPixelFormatAttribute.ColorSize, 24,
                    NSOpenGLPixelFormatAttribute.AlphaSize, 8,
                    NSOpenGLPixelFormatAttribute.DepthSize, depthBit
                };

                var pixelFormat = new NSOpenGLPixelFormat(attribs);
                if (pixelFormat == null)
                {
                    Debug.ThrowError("Video", "NSOpenGLPixelFormat failed");
                }

                NSContext = new NSOpenGLContext(pixelFormat, null);
                if (NSContext == null)
                {
                    Debug.ThrowError("Video", "Failed to create GL context");
                }
                NSContext.MakeCurrentContext();
                NSContext.SwapInterval = vSync;
                NSContext.View         = application.View;
                ctx          = NSContext.CGLContext.Handle;
                OS.NSContext = NSContext;

                /*//Get DC
                 * dc = CGL.DisplayIDToOpenGLDisplayMask(CGL.MainDisplayID());
                 * if (dc == IntPtr.Zero) Debug.ThrowError("Video", "Failed to get DC");
                 *
                 * //Set BackBuffer format
                 * int[] attributes =
                 * {
                 *      //(int)CGL.PixelFormatAttribute.kCGLPFADoubleBuffer,
                 *      //(int)CGL.PixelFormatAttribute.kCGLPFADisplayMask, dc.ToInt32(),
                 *      //(int)CGL.PixelFormatAttribute.kCGLPFAWindow,
                 *      (int)CGL.PixelFormatAttribute.kCGLPFAAccelerated,
                 *      (int)CGL.PixelFormatAttribute.kCGLPFAColorSize, 32,
                 *      (int)CGL.PixelFormatAttribute.kCGLPFADepthSize, depthBit,
                 *      0
                 * };
                 *
                 * IntPtr pixelFormat = IntPtr.Zero;
                 * int pixelFormatCount = 0;
                 * int error = CGL.ChoosePixelFormat(attributes, ref pixelFormat, ref pixelFormatCount);
                 * if (error != 0 || pixelFormat == IntPtr.Zero)
                 * {
                 *      Debug.ThrowError("Video", "ChoosePixelFormat failed");
                 * }
                 *
                 * error = CGL.CreateContext(pixelFormat, IntPtr.Zero, ref ctx);
                 * if (error != 0 || ctx == IntPtr.Zero)
                 * {
                 *      Debug.ThrowError("Video", "Failed to create GL fullscreen context");
                 * }
                 *
                 * CGL.SetCurrentContext(ctx);*/
                                #endif

                                #if iOS
                // GL will be created by the Application
                                #endif

                                #if ANDROID
                // GL will be created by the Application
                                #endif

                                #if NaCl
                var   frame   = application.FrameSize;
                int[] attribs =
                {
                    (int)PPAPI.Graphics3DAttrib.PP_GRAPHICS3DATTRIB_ALPHA_SIZE,                8,// Try to disable this to see if it gets rid of alpha blending presintation issues
                    (int)PPAPI.Graphics3DAttrib.PP_GRAPHICS3DATTRIB_DEPTH_SIZE,     depthBit,
                    (int)PPAPI.Graphics3DAttrib.PP_GRAPHICS3DATTRIB_STENCIL_SIZE,   stencilBit,
                    (int)PPAPI.Graphics3DAttrib.PP_GRAPHICS3DATTRIB_SAMPLES,                   0,
                    (int)PPAPI.Graphics3DAttrib.PP_GRAPHICS3DATTRIB_SAMPLE_BUFFERS,            0,
                    (int)PPAPI.Graphics3DAttrib.PP_GRAPHICS3DATTRIB_WIDTH,          frame.Width,
                    (int)PPAPI.Graphics3DAttrib.PP_GRAPHICS3DATTRIB_HEIGHT,         frame.Height,
                    (int)PPAPI.Graphics3DAttrib.PP_GRAPHICS3DATTRIB_NONE
                };

                graphics = OS.GetGraphics();
                if (graphics == IntPtr.Zero)
                {
                    Debug.ThrowError("Video", "Failed to get Graphics object");
                }

                IntPtr pbbInstance = OS.GetPBBInstance();
                if (graphics == IntPtr.Zero)
                {
                    Debug.ThrowError("Video", "Failed to get PBBInstance object");
                }

                IntPtr gles = OS.GetGlES();
                if (gles == IntPtr.Zero)
                {
                    Debug.ThrowError("Video", "Failed to get GLES object");
                }

                context = PPAPI.InitOpenGL(OS.GetInstance(), graphics, pbbInstance, attribs, gles);
                if (context == 0)
                {
                    Debug.ThrowError("Video", "Failed to create GL context");
                }

                PPAPI.SetCurrentContextPPAPI(context);
                PPAPI.StartSwapBufferLoop(graphics, context);
                                #endif

                checkForError();

                //Setup defualt OpenGL characteristics
                GL.FrontFace(GL.CCW);

                // Get Caps
                Caps = new Caps();
                Caps.MaxShaderVersion = ShaderVersions.Unknown;
                unsafe
                {
                    int max = 0;
                    GL.GetIntegerv(GL.MAX_TEXTURE_SIZE, &max);
                    Caps.MaxTextureSize = max;

                    // SEEMS TO MESS UP ON OSX
                    //GL.GetIntegerv(GL.MAX_VERTEX_UNIFORM_VECTORS, &max);
                    //Caps.MaxVertexConstants = max;

                    //GL.GetIntegerv(GL.MAX_FRAGMENT_UNIFORM_VECTORS, &max);
                    //Caps.MaxPixelConstants = max;

                                        #if RPI
                    byte *shaderVersionPtr = null;
                                        #else
                    byte *shaderVersionPtr = GL.GetString(GL.SHADING_LANGUAGE_VERSION);
                                        #endif
                    string shaderVersion = "";
                    while (shaderVersionPtr != null && shaderVersionPtr[0] != 0)
                    {
                        shaderVersion += (char)shaderVersionPtr[0];
                        shaderVersionPtr++;
                    }

                                        #if iOS || RPI
                    shaderVersion = "1.0";
                                        #elif ANDROID
                    shaderVersion = shaderVersion.Substring(shaderVersion.Length - 4, 4);
                                        #elif NaCl
                    shaderVersion = shaderVersion.Substring(18, 3);
                                        #else
                    shaderVersion = shaderVersion.Substring(0, 4);
                                        #endif
                    float shaderValue = Convert.ToSingle(shaderVersion);

                    Caps.Version = Versions.GL1;
                    FileTag      = "";
                                        #if iOS || ANDROID || NaCl || RPI
                    if (shaderValue >= 1.0f)
                    {
                        Caps.Version          = Versions.GL2;
                        FileTag               = "GLES2_";
                        Caps.MaxShaderVersion = ShaderVersions.GLSL_1_00;
                    }
                                        #else
                    if (shaderValue >= 1.1f)
                    {
                        Caps.Version          = Versions.GL2;
                        FileTag               = "GL2_";
                        Caps.MaxShaderVersion = ShaderVersions.GLSL_1_10;
                    }
                    if (shaderValue >= 1.2f)
                    {
                        Caps.Version          = Versions.GL2;
                        FileTag               = "GL2_";
                        Caps.MaxShaderVersion = ShaderVersions.GLSL_1_20;
                    }
                    // GL3 not supported in GLSL 1.30 becuase 'gl_InstanceID' only exists in GLSL 1.40

                    /*if (shaderValue >= 1.3f)
                     * {
                     *      Caps.Version = Versions.GL3;
                     *      IShader.FileTag = "GL3_";
                     *      Caps.MaxShaderVersion = ShaderVersions.GLSL_1_30;
                     * }*/
                    if (shaderValue >= 1.4f)
                    {
                        Caps.Version          = Versions.GL3;
                        FileTag               = "GL3_";
                        Caps.MaxShaderVersion = ShaderVersions.GLSL_1_40;
                    }
                    if (shaderValue >= 1.5f)
                    {
                        Caps.Version          = Versions.GL3;
                        FileTag               = "GL3_";
                        Caps.MaxShaderVersion = ShaderVersions.GLSL_1_50;
                    }
                    if (shaderValue >= 3.3f)
                    {
                        Caps.Version          = Versions.GL3;
                        FileTag               = "GL3_";
                        Caps.MaxShaderVersion = ShaderVersions.GLSL_3_30;
                    }
                    //if (shaderValue >= 4.0f) Caps.MaxShaderVersion = ShaderVersions.GLSL_4_00;
                    //if (shaderValue >= 4.1f) Caps.MaxShaderVersion = ShaderVersions.GLSL_4_10;
                    //if (shaderValue >= 4.2f) Caps.MaxShaderVersion = ShaderVersions.GLSL_4_20;
                                        #endif

                    if (Caps.Version == Versions.GL1)
                    {
                        Debug.ThrowError("Video", "OpenGL 2 or higher is required.\nAre your video card drivers up to date?");
                    }

                    byte * extensionsPtr   = GL.GetString(GL.EXTENSIONS);
                    string extensionValues = "";
                    while (extensionsPtr != null && extensionsPtr[0] != 0)
                    {
                        extensionValues += (char)extensionsPtr[0];
                        extensionsPtr++;
                    }

                    var extensions = extensionValues.Split(' ');
                    foreach (var ext in extensions)
                    {
                        switch (ext)
                        {
                        case "GL_instanced_arrays": Caps.HardwareInstancing = true; break;

                        case "GL_ARB_instanced_arrays": Caps.HardwareInstancing = true; break;

                        case "GL_EXT_texture_compression_s3tc": Caps.TextureCompression_S3TC = true; break;

                        case "GL_AMD_compressed_ATC_texture": Caps.TextureCompression_ATC = true; break;

                        case "GL_ATI_texture_compression_atitc": Caps.TextureCompression_ATC = true; break;

                        case "GL_IMG_texture_compression_pvrtc": Caps.TextureCompression_PVR = true; break;
                        }
                        //Console.WriteLine(ext);
                    }
                }

                checkForError();

                // Init Ext
                GL.Init();
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #18
0
        public unsafe DepthStencil(IDisposableResource parent, int width, int height, DepthStencilFormats depthStencilFormats)
            : base(parent)
        {
            try
            {
                uint depthBit = GL.DEPTH_COMPONENT16, stencilBit = 0;
                switch (depthStencilFormats)
                {
                case DepthStencilFormats.Defualt:
                                                #if iOS || ANDROID || NaCl || RPI
                    depthBit   = GL.DEPTH_COMPONENT16;
                    stencilBit = 0;
                                                #else
                    depthBit   = GL.DEPTH_COMPONENT24;
                    stencilBit = 0;
                                                #endif
                    break;

                case DepthStencilFormats.Depth24Stencil8:
                    depthBit   = GL.DEPTH_COMPONENT24;
                    stencilBit = GL.STENCIL_INDEX8;
                    break;

                case DepthStencilFormats.Depth16:
                    depthBit   = GL.DEPTH_COMPONENT16;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth24:
                    depthBit   = GL.DEPTH_COMPONENT24;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth32:
                    depthBit   = GL.DEPTH_COMPONENT32;
                    stencilBit = 0;
                    break;

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

                Size  = new Size2(width, height);
                SizeF = Size.ToVector2();

                // create depth
                uint surfaceTEMP = 0;
                GL.GenRenderbuffers(1, &surfaceTEMP);
                if (surfaceTEMP == 0)
                {
                    Debug.ThrowError("DpethStencil", "Failed to create DepthBuffer");
                }
                depthBuffer = surfaceTEMP;

                GL.BindRenderbuffer(GL.RENDERBUFFER, depthBuffer);
                GL.RenderbufferStorage(GL.RENDERBUFFER, depthBit, width, height);

                // create stencil
                if (stencilBit != 0)
                {
                    surfaceTEMP = 0;
                    GL.GenRenderbuffers(1, &surfaceTEMP);
                    if (surfaceTEMP == 0)
                    {
                        Debug.ThrowError("DpethStencil", "Failed to create StencilBuffer");
                    }
                    stencilBuffer = surfaceTEMP;

                    GL.BindRenderbuffer(GL.RENDERBUFFER, stencilBuffer);
                    GL.RenderbufferStorage(GL.RENDERBUFFER, stencilBit, width, height);
                }

                uint   error;
                string errorName;
                if (Video.checkForError(out error, out errorName))
                {
                    Debug.ThrowError("DepthStencil", string.Format("{0} {1}: Failed to create DepthStencil", error, errorName));
                }
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #19
0
        public unsafe DepthStencil(IDisposableResource parent, int width, int height, DepthStencilFormats depthStencilFormats)
            : base(parent)
        {
            try
            {
                uint depthBit = GL.DEPTH_COMPONENT16, stencilBit = 0;
                switch (depthStencilFormats)
                {
                    case DepthStencilFormats.Defualt:
                        #if iOS || ANDROID || NaCl || RPI
                        depthBit = GL.DEPTH_COMPONENT16;
                        stencilBit = 0;
                        #else
                        depthBit = GL.DEPTH_COMPONENT24;
                        stencilBit = 0;
                        #endif
                        break;

                    case DepthStencilFormats.Depth24Stencil8:
                        depthBit = GL.DEPTH_COMPONENT24;
                        stencilBit = GL.STENCIL_INDEX8;
                        break;

                    case DepthStencilFormats.Depth16:
                        depthBit = GL.DEPTH_COMPONENT16;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Depth24:
                        depthBit = GL.DEPTH_COMPONENT24;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Depth32:
                        depthBit = GL.DEPTH_COMPONENT32;
                        stencilBit = 0;
                        break;

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

                Size = new Size2(width, height);
                SizeF = Size.ToVector2();

                // create depth
                uint surfaceTEMP = 0;
                GL.GenRenderbuffers(1, &surfaceTEMP);
                if (surfaceTEMP == 0) Debug.ThrowError("DpethStencil", "Failed to create DepthBuffer");
                depthBuffer = surfaceTEMP;

                GL.BindRenderbuffer(GL.RENDERBUFFER, depthBuffer);
                GL.RenderbufferStorage(GL.RENDERBUFFER, depthBit, width, height);

                // create stencil
                if (stencilBit != 0)
                {
                    surfaceTEMP = 0;
                    GL.GenRenderbuffers(1, &surfaceTEMP);
                    if (surfaceTEMP == 0) Debug.ThrowError("DpethStencil", "Failed to create StencilBuffer");
                    stencilBuffer = surfaceTEMP;

                    GL.BindRenderbuffer(GL.RENDERBUFFER, stencilBuffer);
                    GL.RenderbufferStorage(GL.RENDERBUFFER, stencilBit, width, height);
                }

                uint error;
                string errorName;
                if (Video.checkForError(out error, out errorName)) Debug.ThrowError("DepthStencil", string.Format("{0} {1}: Failed to create DepthStencil", error, errorName));
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #20
0
        private void init(IDisposableResource parent, int width, int height, DepthStencilFormats depthStencilFormats)
        {
            try
            {
                this.width  = width;
                this.height = height;
                this.depthStencilFormats = depthStencilFormats;

                video = parent.FindParentOrSelfWithException <Video>();
                Size  = new Size2(width, height);
                SizeF = Size.ToVector2();

                int depthBit = 16, stencilBit = 0;
                switch (depthStencilFormats)
                {
                case DepthStencilFormats.Defualt:
                    depthBit   = 24;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth24Stencil8:
                    depthBit   = 24;
                    stencilBit = 8;
                    break;

                case DepthStencilFormats.Depth16:
                    depthBit   = 16;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth24:
                    depthBit   = 24;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth32:
                    depthBit   = 32;
                    stencilBit = 0;
                    break;

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

                com = new DepthStencilCom();
                var error = com.Init(video.com, width, height, depthBit, stencilBit);

                switch (error)
                {
                case DepthStencilErrors.DepthStencilSurface: Debug.ThrowError("DepthStencil", "Failed to create DepthStencil Surface"); break;
                }

                if (!video.Caps.ExDevice && !video.deviceReseting)
                {
                    video.DeviceLost  += deviceLost;
                    video.DeviceReset += deviceReset;
                }
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #21
0
        public static IDepthStencil New(VideoTypes videoType, IDisposableResource parent, int width, int height, DepthStencilFormats format)
        {
            IDepthStencil api = null;

                        #if WIN32
            if (videoType == VideoTypes.D3D9)
            {
                api = new D3D9.DepthStencil(parent, width, height, format);
            }
                        #endif

                        #if WIN32 || WINRT || WP8
            if (videoType == VideoTypes.D3D11)
            {
                api = new D3D11.DepthStencil(parent, width, height, format);
            }
                        #endif

                        #if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl
            if (videoType == VideoTypes.OpenGL)
            {
                api = new OpenGL.DepthStencil(parent, width, height, format);
            }
                        #endif

                        #if VITA
            if (videoType == VideoTypes.Vita)
            {
                api = new Vita.DepthStencil(parent, width, height, format);
            }
                        #endif

            if (api == null)
            {
                Debug.ThrowError("DepthStencilAPI", "Unsuported InputType: " + videoType);
            }
            return(api);
        }
Exemple #22
0
 public static IDepthStencil New(IDisposableResource parent, int width, int height, DepthStencilFormats format)
 {
     return(New(VideoAPI.DefaultAPI, parent, width, height, format));
 }
Exemple #23
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));
 }
Exemple #24
0
        private void init(IDisposableResource parent, int width, int height, DepthStencilFormats depthStencilFormats)
        {
            try
            {
                this.width = width;
                this.height = height;
                this.depthStencilFormats = depthStencilFormats;

                video = parent.FindParentOrSelfWithException<Video>();
                Size = new Size2(width, height);
                SizeF = Size.ToVector2();

                int depthBit = 16, stencilBit = 0;
                switch (depthStencilFormats)
                {
                    case DepthStencilFormats.Defualt:
                        depthBit = 24;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Depth24Stencil8:
                        depthBit = 24;
                        stencilBit = 8;
                        break;

                    case DepthStencilFormats.Depth16:
                        depthBit = 16;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Depth24:
                        depthBit = 24;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Depth32:
                        depthBit = 32;
                        stencilBit = 0;
                        break;

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

                com = new DepthStencilCom();
                var error = com.Init(video.com, width, height, depthBit, stencilBit);

                switch (error)
                {
                    case DepthStencilErrors.DepthStencilSurface: Debug.ThrowError("DepthStencil", "Failed to create DepthStencil Surface"); break;
                }

                if (!video.Caps.ExDevice && !video.deviceReseting)
                {
                    video.DeviceLost += deviceLost;
                    video.DeviceReset += deviceReset;
                }
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #25
0
 public DepthStencil(IDisposableResource parent, int width, int height, DepthStencilFormats depthStencilFormats)
     : base(parent)
 {
     init(parent, width, height, depthStencilFormats);
 }
Exemple #26
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);
 }
Exemple #27
0
 public static IDepthStencil New(IDisposableResource parent, int width, int height, DepthStencilFormats format)
 {
     return New(VideoAPI.DefaultAPI, parent, width, height, format);
 }
Exemple #28
0
 public DepthStencil(IDisposableResource parent, int width, int height, DepthStencilFormats depthStencilFormats)
     : base(parent)
 {
     init(parent, width, height, depthStencilFormats);
 }
Exemple #29
0
 public static DepthStencilI New(DisposableI parent, int width, int height, DepthStencilFormats depthStencilFormats)
 {
     return(new DepthStencil(parent, width, height, depthStencilFormats));
 }
Exemple #30
0
 private void initDepthStencil(int width, int height, DepthStencilFormats depthStencilFormat)
 {
     if (depthStencilFormat != DepthStencilFormats.None) depthStencil = new DepthStencil(this, width, height, depthStencilFormat);
 }
Exemple #31
0
        public Video(IDisposableResource parent, IApplication application, DepthStencilFormats depthStencilFormats, bool vSync)
            : base(parent)
        {
            try
            {
                this.application      = application;
                FileTag               = "D3D9_";
                currentVertexTextures = new Texture2D[4];
                currentPixelTextures  = new Texture2D[8];
                currentRenderTargets  = new RenderTarget[4];

                int depthBit = 16, stencilBit = 0;
                switch (depthStencilFormats)
                {
                case DepthStencilFormats.None:
                    depthBit   = 0;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Defualt:
                    depthBit   = 24;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth24Stencil8:
                    depthBit   = 24;
                    stencilBit = 8;
                    break;

                case DepthStencilFormats.Depth16:
                    depthBit   = 16;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth24:
                    depthBit   = 24;
                    stencilBit = 0;
                    break;

                case DepthStencilFormats.Depth32:
                    depthBit   = 32;
                    stencilBit = 0;
                    break;

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

                com = new VideoCom();
                var frame = application.FrameSize;
                BackBufferSize = frame;
                ComponentCaps componentCaps;
                var           error = com.Init(application.Handle, vSync, frame.Width, frame.Height, depthBit, stencilBit, false, false, out componentCaps);

                switch (error)
                {
                case VideoError.Direct3DInterfaceFailed: Debug.ThrowError("Video", "Failed to create Direct3D9 interface.\nDo you have up to date graphics drivers?"); break;

                case VideoError.GetCapsFailed: Debug.ThrowError("Video", "Failed to get caps"); break;

                case VideoError.AdapterDisplayModeFailed: Debug.ThrowError("Video", "Failed to get adapter display mode"); break;

                case VideoError.VideoHardwareNotSupported: Debug.ThrowError("Video", "Your video hardware is not supported"); break;

                case VideoError.DeviceAndSwapChainFailed: Debug.ThrowError("Video", "Failed to create Device and SwapChain"); break;
                }

                Caps = new Caps()
                {
                    ExDevice               = componentCaps.ExDevice,
                    HardwareInstancing     = componentCaps.HardwareInstancing,
                    MaxTextureCount        = componentCaps.MaxTextureCount,
                    MaxVertexShaderVersion = getMaxShaderVersion(componentCaps.MaxVertexShaderVersion),
                    MaxPixelShaderVersion  = getMaxShaderVersion(componentCaps.MaxPixelShaderVersion),
                    MaxShaderVersion       = getMaxShaderVersion(componentCaps.MaxShaderVersion)
                };

                com.DeviceLost  = deviceLost;
                com.DeviceReset = deviceReset;
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #32
0
 public static DepthStencilI New(DisposableI parent, int width, int height, DepthStencilFormats depthStencilFormats)
 {
     return new DepthStencil(parent, width, height, depthStencilFormats);
 }
Exemple #33
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);
 }
Exemple #34
0
 private void init(IDisposableResource parent, IApplication application, DepthStencilFormats depthStencilFormats, bool vSync, Windows.UI.Xaml.Controls.SwapChainBackgroundPanel swapChainBackgroundPanel)
Exemple #35
0
        public static IRenderTarget New(VideoTypes videoType, IDisposableResource parent, string filename, int width, int height, bool generateMipmaps, MultiSampleTypes multiSampleType, SurfaceFormats surfaceFormat, DepthStencilFormats depthStencilFormat, RenderTargetUsage renderTargetUsage, BufferUsages usage, Loader.LoadedCallbackMethod loadedCallback)
        {
            IRenderTarget api = null;

                        #if WIN32
            if (videoType == VideoTypes.D3D9)
            {
                api = new D3D9.RenderTarget(parent, filename, width, height, generateMipmaps, multiSampleType, surfaceFormat, depthStencilFormat, renderTargetUsage, usage, loadedCallback);
            }
                        #endif

                        #if WIN32 || WINRT || WP8
            if (videoType == VideoTypes.D3D11)
            {
                api = new D3D11.RenderTarget(parent, filename, width, height, generateMipmaps, multiSampleType, surfaceFormat, depthStencilFormat, renderTargetUsage, usage, loadedCallback);
            }
                        #endif

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

                        #if XNA
            if (videoType == VideoTypes.XNA)
            {
                api = new XNA.RenderTarget(parent, filename, width, height, generateMipmaps, multiSampleType, surfaceFormat, depthStencilFormat, renderTargetUsage, usage, loadedCallback);
            }
                        #endif

                        #if VITA
            if (videoType == VideoTypes.Vita)
            {
                api = new Vita.RenderTarget(parent, filename, width, height, generateMipmaps, multiSampleType, surfaceFormat, depthStencilFormat, renderTargetUsage, usage, loadedCallback);
            }
                        #endif

            if (api == null)
            {
                Debug.ThrowError("RenderTargetAPI", "Unsuported InputType: " + videoType);
            }
            return(api);
        }
Exemple #36
0
		private void init(IDisposableResource parent, IApplication application, DepthStencilFormats depthStencilFormats, bool vSync)
		#endif
		{
			this.application = application;
			
			try
			{
				FileTag = "D3D11_";
				Cap = new Caps();

				int depthBit = 16, stencilBit = 0;
				switch (depthStencilFormats)
				{
					case DepthStencilFormats.None:
						depthBit = 0;
						stencilBit = 0;
						break;

					case DepthStencilFormats.Defualt:
						depthBit = 24;
						stencilBit = 0;
						break;

					case DepthStencilFormats.Depth24Stencil8:
						depthBit = 24;
						stencilBit = 8;
						break;

					case DepthStencilFormats.Depth16:
						depthBit = 16;
						stencilBit = 0;
						break;

					case DepthStencilFormats.Depth24:
						depthBit = 24;
						stencilBit = 0;
						break;

					case DepthStencilFormats.Depth32:
						depthBit = 32;
						stencilBit = 0;
						break;

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

				com = new VideoCom();
				var featureLevel = REIGN_D3D_FEATURE_LEVEL.LEVEL_9_1;
				var frame = application.FrameSize;
				#if WIN32
				var error = com.Init(application.Handle, vSync, frame.Width, frame.Height, depthBit, stencilBit, false, out featureLevel);
				#elif WINRT
				var error = com.Init(application.CoreWindow, vSync, frame.Width, frame.Height, depthBit, stencilBit, out featureLevel, swapChainBackgroundPanel);
				#else
				var error = com.Init(vSync, frame.Width, frame.Height, depthBit, stencilBit, out featureLevel, OS.UpdateAndRender);
				#endif
				BackBufferSize = frame;

				switch (error)
				{
					case VideoError.DepthStencilTextureFailed: Debug.ThrowError("Video", "Failed to create DepthStencilTexture"); break;
					case VideoError.DepthStencilViewFailed: Debug.ThrowError("Video", "Failed to create DepthStencilView"); break;
					case VideoError.RenderTargetViewFailed: Debug.ThrowError("Video", "Failed to create RenderTargetView"); break;
					#if !WP8
					case VideoError.GetSwapChainFailed: Debug.ThrowError("Video", "Failed to get SwapChain"); break;
					#endif
					#if WIN32
					case VideoError.DeviceAndSwapChainFailed: Debug.ThrowError("Video", "Failed to create Device and SwapChain"); break;
					#else
					case VideoError.DeviceFailed: Debug.ThrowError("Video", "Failed to create Device"); break;
					#if !WP8
					case VideoError.SwapChainFailed: Debug.ThrowError("Video", "Failed to create SwapChain"); break;
					case VideoError.D2DFactoryFailed: Debug.ThrowError("Video", "Failed to create D2D Factory"); break;
					case VideoError.D2DDeviceFailed: Debug.ThrowError("Video", "Failed to create D2D Device"); break;
					case VideoError.D2DDeviceContextFailed: Debug.ThrowError("Video", "Failed to D2D DeviceContext"); break;
					case VideoError.NativeSwapChainPanelFailed: Debug.ThrowError("Video", "Failed to get native SwapChainPanel"); break;
					case VideoError.GetDXGIBackBufferFailed: Debug.ThrowError("Video", "Failed to create DXGI BackBuffer"); break;
					case VideoError.DXGISurfaceFailed: Debug.ThrowError("Video", "Failed to create DXGI Surface"); break;
					case VideoError.D2DBitmapFailed: Debug.ThrowError("Video", "Failed to create D2D Bitmap"); break;
					#else
					case VideoError.RenderTextureFailed: Debug.ThrowError("Video", "Failed to create RenderTexture"); break;
					#endif
					#endif
				}

				#if WP8
				((XAMLApplication)application).MainPage.Surface.SetContentProvider(com.GetProvider());
				#endif

				switch (featureLevel)
				{
					#if WINRT || WP8
					case REIGN_D3D_FEATURE_LEVEL.LEVEL_11_1:
						Cap.MaxShaderVersion = ShaderVersions.HLSL_5_0;
						Cap.FeatureLevel = FeatureLevels.D3D11_1;
						break;
					#endif

					case REIGN_D3D_FEATURE_LEVEL.LEVEL_11_0:
						Cap.MaxShaderVersion = ShaderVersions.HLSL_5_0;
						Cap.FeatureLevel = FeatureLevels.D3D11;
						break;

					case REIGN_D3D_FEATURE_LEVEL.LEVEL_10_1:
						Cap.MaxShaderVersion = ShaderVersions.HLSL_4_1;
						Cap.FeatureLevel = FeatureLevels.D3D10_1;
						break;

					case REIGN_D3D_FEATURE_LEVEL.LEVEL_10_0:
						Cap.MaxShaderVersion = ShaderVersions.HLSL_4_0;
						Cap.FeatureLevel = FeatureLevels.D3D10;
						break;

					case REIGN_D3D_FEATURE_LEVEL.LEVEL_9_3:
						Cap.MaxShaderVersion = ShaderVersions.HLSL_3_0;
						Cap.FeatureLevel = FeatureLevels.D3D9_3;
						break;

					case REIGN_D3D_FEATURE_LEVEL.LEVEL_9_2:
						Cap.MaxShaderVersion = ShaderVersions.HLSL_2_a;
						Cap.FeatureLevel = FeatureLevels.D3D9_2;
						break;

					case REIGN_D3D_FEATURE_LEVEL.LEVEL_9_1:
						Cap.MaxShaderVersion = ShaderVersions.HLSL_2_0;
						Cap.FeatureLevel = FeatureLevels.D3D9_1;
						break;
				}
			}
			catch (Exception e)
			{
				Dispose();
				throw e;
			}
		}
Exemple #37
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);
     }
 }
Exemple #38
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;
 }
Exemple #39
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));
 }
Exemple #40
0
        public Video(IDisposableResource parent, IApplication application, DepthStencilFormats depthStencilFormats, bool vSync)
            : base(parent)
        {
            try
            {
                this.application = application;
                FileTag = "D3D9_";
                currentVertexTextures = new Texture2D[4];
                currentPixelTextures = new Texture2D[8];
                currentRenderTargets = new RenderTarget[4];

                int depthBit = 16, stencilBit = 0;
                switch (depthStencilFormats)
                {
                    case DepthStencilFormats.None:
                        depthBit = 0;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Defualt:
                        depthBit = 24;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Depth24Stencil8:
                        depthBit = 24;
                        stencilBit = 8;
                        break;

                    case DepthStencilFormats.Depth16:
                        depthBit = 16;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Depth24:
                        depthBit = 24;
                        stencilBit = 0;
                        break;

                    case DepthStencilFormats.Depth32:
                        depthBit = 32;
                        stencilBit = 0;
                        break;

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

                com = new VideoCom();
                var frame = application.FrameSize;
                BackBufferSize = frame;
                ComponentCaps componentCaps;
                var error = com.Init(application.Handle, vSync, frame.Width, frame.Height, depthBit, stencilBit, false, false, out componentCaps);

                switch (error)
                {
                    case VideoError.Direct3DInterfaceFailed: Debug.ThrowError("Video", "Failed to create Direct3D9 interface.\nDo you have up to date graphics drivers?"); break;
                    case VideoError.GetCapsFailed: Debug.ThrowError("Video", "Failed to get caps"); break;
                    case VideoError.AdapterDisplayModeFailed: Debug.ThrowError("Video", "Failed to get adapter display mode"); break;
                    case VideoError.VideoHardwareNotSupported: Debug.ThrowError("Video", "Your video hardware is not supported"); break;
                    case VideoError.DeviceAndSwapChainFailed: Debug.ThrowError("Video", "Failed to create Device and SwapChain"); break;
                }

                Caps = new Caps()
                {
                    ExDevice = componentCaps.ExDevice,
                    HardwareInstancing = componentCaps.HardwareInstancing,
                    MaxTextureCount = componentCaps.MaxTextureCount,
                    MaxVertexShaderVersion = getMaxShaderVersion(componentCaps.MaxVertexShaderVersion),
                    MaxPixelShaderVersion = getMaxShaderVersion(componentCaps.MaxPixelShaderVersion),
                    MaxShaderVersion = getMaxShaderVersion(componentCaps.MaxShaderVersion)
                };

                com.DeviceLost = deviceLost;
                com.DeviceReset = deviceReset;
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Exemple #41
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;
 }