internal GLPBRTTManager( BaseGLSupport glSupport, RenderTarget target ) : base( glSupport ) { _glSupport = glSupport; _mainWindow = target; _mainGLContext = (GLContext)target.GetCustomAttribute( "GLCONTEXT" ); }
public override void Unbind( RenderTarget target ) { // copy on unbind object attr = target.GetCustomAttribute( "target" ); if ( attr != null ) { GLSurfaceDesc surface = (GLSurfaceDesc)attr; if ( surface.Buffer != null ) ( (GLTextureBuffer)surface.Buffer ).CopyFromFrameBuffer( surface.ZOffset ); } }
public override void Unbind( RenderTarget target ) { // Copy on unbind GLESSurfaceDescription surface; surface.Buffer = null; surface = (GLESSurfaceDescription) target[ "TARGET" ]; if ( surface.Buffer != null ) { ( (GLESTextureBuffer) surface.Buffer ).CopyFromFramebuffer( surface.ZOffset ); } }
public override void CopyContentsToMemory( PixelBox dst, RenderTarget.FrameBuffer buffer ) { if ( buffer == FrameBuffer.Auto ) buffer = FrameBuffer.Front; if ( buffer != FrameBuffer.Front ) { throw new Exception( "Invalid buffer." ); } pixelBuffer.BlitToMemory( dst ); }
private void InitializeContext(RenderTarget primary) { // Set main and current context _mainContext = (GLContext)primary["GLCONTEXT"]; _currentContext = _mainContext; // Set primary context as active if (_currentContext != null) _currentContext.SetCurrent(); // Setup GLSupport _glSupport.InitializeExtensions(); LogManager.Instance.Write("***************************"); LogManager.Instance.Write("*** GL Renderer Started ***"); LogManager.Instance.Write("***************************"); InitGLEW(); }
public CompositeTargetOperation( RenderTarget target ) { RenderQueues = new BitArray( (int)RenderQueueGroupID.Count ); Target = target; CurrentQueueGroupId = 0; RenderSystemOperations = new List<CompositorInstance.QueueIDAndOperation>(); VisibilityMask = 0xFFFFFFFF; LodBias = 1.0f; OnlyInitial = false; HasBeenRendered = false; FindVisibleObjects = false; // This fixes an issue, but seems to be wrong for some reason. MaterialScheme = string.Empty; ShadowsEnabled = true; }
public void CopyContentsToMemory( D3D9RenderWindow renderWindow, PixelBox dst, RenderTarget.FrameBuffer buffer ) { var resources = this._mapRenderWindowToResources[ renderWindow ]; var swapChain = IsSwapChainWindow( renderWindow ); if ( ( dst.Left < 0 ) || ( dst.Right > renderWindow.Width ) || ( dst.Top < 0 ) || ( dst.Bottom > renderWindow.Height ) || ( dst.Front != 0 ) || ( dst.Back != 1 ) ) { throw new AxiomException( "Invalid box." ); } var desc = new D3D9.SurfaceDescription(); DX.DataRectangle lockedRect; D3D9.Surface pTempSurf = null, pSurf = null; if ( buffer == RenderTarget.FrameBuffer.Auto ) { buffer = RenderTarget.FrameBuffer.Front; } if ( buffer == RenderTarget.FrameBuffer.Front ) { var dm = this.pDevice.GetDisplayMode( 0 ); desc.Width = dm.Width; desc.Height = dm.Height; desc.Format = D3D9.Format.A8R8G8B8; pTempSurf = D3D9.Surface.CreateOffscreenPlain( this.pDevice, desc.Width, desc.Height, desc.Format, D3D9.Pool.SystemMemory ); try { if ( swapChain ) { resources.SwapChain.GetFrontBufferData( pTempSurf ); } else { pTempSurf = this.pDevice.GetFrontBufferData( 0 ); } } catch ( DX.SharpDXException ex ) { pTempSurf.SafeDispose(); throw new AxiomException( "Can't get front buffer: {0}", ex.Message ); } if ( renderWindow.IsFullScreen ) { try { if ( ( dst.Left == 0 ) && ( dst.Right == renderWindow.Width ) && ( dst.Top == 0 ) && ( dst.Bottom == renderWindow.Height ) ) { lockedRect = pTempSurf.LockRectangle( D3D9.LockFlags.ReadOnly | D3D9.LockFlags.NoSystemLock ); } else { var rect = new System.Drawing.Rectangle( dst.Left, dst.Top, dst.Right - dst.Left, dst.Bottom - dst.Top ); lockedRect = pTempSurf.LockRectangle( rect, D3D9.LockFlags.ReadOnly | D3D9.LockFlags.NoSystemLock ); } } catch { pTempSurf.SafeDispose(); throw new AxiomException( "Can't lock rect" ); } } else { //GetClientRect(mHWnd, &srcRect); var srcRect = new System.Drawing.Rectangle( dst.Left, dst.Top, dst.Right - dst.Left, dst.Bottom - dst.Top ); var point = new System.Drawing.Point( srcRect.Left, srcRect.Top ); point = System.Windows.Forms.Control.FromHandle( renderWindow.WindowHandle ).PointToScreen( point ); srcRect = new System.Drawing.Rectangle( point.X, point.Y, srcRect.Right + point.X - srcRect.Left, srcRect.Bottom + point.Y - dst.Top ); desc.Width = srcRect.Right - srcRect.Left; desc.Height = srcRect.Bottom - srcRect.Top; try { lockedRect = pTempSurf.LockRectangle( srcRect, D3D9.LockFlags.ReadOnly | D3D9.LockFlags.NoSystemLock ); } catch { pTempSurf.SafeDispose(); throw new AxiomException( "Can't lock rect" ); } } } else { pSurf.SafeDispose(); pSurf = swapChain ? resources.SwapChain.GetBackBuffer( 0 ) : this.pDevice.GetBackBuffer( 0, 0 ); desc = pSurf.Description; pTempSurf = D3D9.Surface.CreateOffscreenPlain( this.pDevice, desc.Width, desc.Height, desc.Format, D3D9.Pool.SystemMemory ); if ( desc.MultiSampleType == D3D9.MultisampleType.None ) { var hr = this.pDevice.GetRenderTargetData( pSurf, pTempSurf ); if ( hr.Failure ) { pTempSurf.SafeDispose(); throw new AxiomException( "Can't get render target data" ); } } else { var pStretchSurf = D3D9.Surface.CreateRenderTarget( this.pDevice, desc.Width, desc.Height, desc.Format, D3D9.MultisampleType.None, 0, false ); var hr = this.pDevice.StretchRectangle( pSurf, pStretchSurf, D3D9.TextureFilter.None ); if ( hr.Failure ) { pTempSurf.SafeDispose(); pStretchSurf.SafeDispose(); throw new AxiomException( "Can't stretch rect" ); } hr = this.pDevice.GetRenderTargetData( pStretchSurf, pTempSurf ); if ( hr.Failure ) { pTempSurf.SafeDispose(); pStretchSurf.SafeDispose(); throw new AxiomException( "Can't get render target data" ); } pStretchSurf.SafeDispose(); } try { if ( ( dst.Left == 0 ) && ( dst.Right == renderWindow.Width ) && ( dst.Top == 0 ) && ( dst.Bottom == renderWindow.Height ) ) { lockedRect = pTempSurf.LockRectangle( D3D9.LockFlags.ReadOnly | D3D9.LockFlags.NoSystemLock ); } else { var rect = new System.Drawing.Rectangle( dst.Left, dst.Top, dst.Right - dst.Left, dst.Bottom - dst.Top ); lockedRect = pTempSurf.LockRectangle( rect, D3D9.LockFlags.ReadOnly | D3D9.LockFlags.NoSystemLock ); } } catch { pTempSurf.SafeDispose(); throw new AxiomException( "Can't lock rect" ); } } var format = D3D9Helper.ConvertEnum( desc.Format ); if ( format == PixelFormat.Unknown ) { pTempSurf.SafeDispose(); throw new AxiomException( "Unsupported format" ); } using ( var data = BufferBase.Wrap( lockedRect.DataPointer, lockedRect.Pitch*dst.Height ) ) { var src = new PixelBox( dst.Width, dst.Height, 1, format, data ); src.RowPitch = lockedRect.Pitch/PixelUtil.GetNumElemBytes( format ); src.SlicePitch = desc.Height*src.RowPitch; PixelConverter.BulkPixelConversion( src, dst ); } pTempSurf.SafeDispose(); pSurf.SafeDispose(); }
public override void InitializeFromRenderSystemCapabilities( RenderSystemCapabilities caps, RenderTarget primary ) { if ( caps.RendersystemName != Name ) { throw new AxiomException( "Trying to initialize GLRenderSystem from RenderSystemCapabilities that do not support OpenGL" ); } // set texture the number of texture units this._fixedFunctionTextureUnits = caps.TextureUnitCount; //In GL there can be less fixed function texture units than general //texture units. Get the minimum of the two. if ( caps.HasCapability( Graphics.Capabilities.FragmentPrograms ) ) { int maxTexCoords; Gl.glGetIntegerv( Gl.GL_MAX_TEXTURE_COORDS_ARB, out maxTexCoords ); if ( this._fixedFunctionTextureUnits > maxTexCoords ) { this._fixedFunctionTextureUnits = maxTexCoords; } } /* Axiom: assume that OpenTK/Tao does this already * otherwise we will need to use delegates for these gl calls .. * if (caps.HasCapability(Graphics.Capabilities.GL15NoVbo)) { // Assign ARB functions same to GL 1.5 version since // interface identical Gl.glBindBufferARB = Gl.glBindBuffer; Gl.glBufferDataARB = Gl.glBufferData; Gl.glBufferSubDataARB = Gl.glBufferSubData; Gl.glDeleteBuffersARB = Gl.glDeleteBuffers; Gl.glGenBuffersARB = Gl.glGenBuffers; Gl.glGetBufferParameterivARB = Gl.glGetBufferParameteriv; Gl.glGetBufferPointervARB = Gl.glGetBufferPointerv; Gl.glGetBufferSubDataARB = Gl.glGetBufferSubData; Gl.glIsBufferARB = Gl.glIsBuffer; Gl.glMapBufferARB = Gl.glMapBuffer; Gl.glUnmapBufferARB = Gl.glUnmapBuffer; } */ if ( caps.HasCapability( Graphics.Capabilities.VertexBuffer ) ) { this._hardwareBufferManager = new GLHardwareBufferManager(); } else { this._hardwareBufferManager = new GLDefaultHardwareBufferManager(); } // XXX Need to check for nv2 support and make a program manager for it // XXX Probably nv1 as well for older cards // GPU Program Manager setup this.gpuProgramMgr = new GLGpuProgramManager(); if ( caps.HasCapability( Graphics.Capabilities.VertexPrograms ) ) { if ( caps.IsShaderProfileSupported( "arbvp1" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "arbvp1", new ARBGpuProgramFactory() ); } if ( caps.IsShaderProfileSupported( "vp30" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "vp30", new ARBGpuProgramFactory() ); } if ( caps.IsShaderProfileSupported( "vp40" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "vp40", new ARBGpuProgramFactory() ); } if ( caps.IsShaderProfileSupported( "gp4vp" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "gp4vp", new ARBGpuProgramFactory() ); } if ( caps.IsShaderProfileSupported( "gpu_vp" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "gpu_vp", new ARBGpuProgramFactory() ); } } if ( caps.HasCapability( Graphics.Capabilities.GeometryPrograms ) ) { //TODO : Should these be createGLArbGpuProgram or createGLGpuNVparseProgram? if ( caps.IsShaderProfileSupported( "nvgp4" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "nvgp4", new ARBGpuProgramFactory() ); } if ( caps.IsShaderProfileSupported( "gp4gp" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "gp4gp", new ARBGpuProgramFactory() ); } if ( caps.IsShaderProfileSupported( "gpu_gp" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "gpu_gp", new ARBGpuProgramFactory() ); } } if ( caps.HasCapability( Graphics.Capabilities.FragmentPrograms ) ) { if ( caps.IsShaderProfileSupported( "fp20" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "fp20", new Nvidia.NvparseProgramFactory() ); } if ( caps.IsShaderProfileSupported( "ps_1_4" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "ps_1_4", new ATI.ATIFragmentShaderFactory() ); } if ( caps.IsShaderProfileSupported( "ps_1_3" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "ps_1_3", new ATI.ATIFragmentShaderFactory() ); } if ( caps.IsShaderProfileSupported( "ps_1_2" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "ps_1_2", new ATI.ATIFragmentShaderFactory() ); } if ( caps.IsShaderProfileSupported( "ps_1_1" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "ps_1_1", new ATI.ATIFragmentShaderFactory() ); } if ( caps.IsShaderProfileSupported( "arbfp1" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "arbfp1", new ARBGpuProgramFactory() ); } if ( caps.IsShaderProfileSupported( "fp40" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "fp40", new ARBGpuProgramFactory() ); } if ( caps.IsShaderProfileSupported( "fp30" ) ) { this.gpuProgramMgr.RegisterProgramFactory( "fp30", new ARBGpuProgramFactory() ); } } if ( caps.IsShaderProfileSupported( "glsl" ) ) { // NFZ - check for GLSL vertex and fragment shader support successful this._GLSLProgramFactory = new GLSL.GLSLProgramFactory(); HighLevelGpuProgramManager.Instance.AddFactory( this._GLSLProgramFactory ); LogManager.Instance.Write( "GLSL support detected" ); } /* Axiom: assume that OpenTK/Tao does this already * otherwise we will need to use delegates for these gl calls .. * if ( caps.HasCapability( Graphics.Capabilities.HardwareOcculusion ) ) { if ( caps.HasCapability( Graphics.Capabilities.GL15NoHardwareOcclusion ) ) { // Assign ARB functions same to GL 1.5 version since // interface identical Gl.glBeginQueryARB = Gl.glBeginQuery; Gl.glDeleteQueriesARB = Gl.glDeleteQueries; Gl.glEndQueryARB = Gl.glEndQuery; Gl.glGenQueriesARB = Gl.glGenQueries; Gl.glGetQueryObjectivARB = Gl.glGetQueryObjectiv; Gl.glGetQueryObjectuivARB = Gl.glGetQueryObjectuiv; Gl.glGetQueryivARB = Gl.glGetQueryiv; Gl.glIsQueryARB = Gl.glIsQuery; } } */ // Do this after extension function pointers are initialised as the extension // is used to probe further capabilities. ConfigOption cfi; var rttMode = 0; if ( ConfigOptions.TryGetValue( "RTT Preferred Mode", out cfi ) ) { if ( cfi.Value == "PBuffer" ) { rttMode = 1; } else if ( cfi.Value == "Copy" ) { rttMode = 2; } } // Check for framebuffer object extension if ( caps.HasCapability( Graphics.Capabilities.FrameBufferObjects ) && rttMode < 1 ) { // Before GL version 2.0, we need to get one of the extensions //if(caps.HasCapability(Graphics.Capabilities.FrameBufferObjectsARB)) // GLEW_GET_FUN(__glewDrawBuffers) = Gl.glDrawBuffersARB; //else if(caps.HasCapability(Graphics.Capabilities.FrameBufferObjectsATI)) // GLEW_GET_FUN(__glewDrawBuffers) = Gl.glDrawBuffersATI; if ( caps.HasCapability( Graphics.Capabilities.HardwareRenderToTexture ) ) { // Create FBO manager LogManager.Instance.Write( "GL: Using GL_EXT_framebuffer_object for rendering to textures (best)" ); this.rttManager = new GLFBORTTManager( this._glSupport, false ); caps.SetCapability( Graphics.Capabilities.RTTSeperateDepthBuffer ); //TODO: Check if we're using OpenGL 3.0 and add RSC_RTT_DEPTHBUFFER_RESOLUTION_LESSEQUAL flag } } else { // Check GLSupport for PBuffer support if ( caps.HasCapability( Graphics.Capabilities.PBuffer ) && rttMode < 2 ) { if ( caps.HasCapability( Graphics.Capabilities.HardwareRenderToTexture ) ) { // Use PBuffers this.rttManager = new GLPBRTTManager( this._glSupport, primary ); LogManager.Instance.Write( "GL: Using PBuffers for rendering to textures" ); //TODO: Depth buffer sharing in pbuffer is left unsupported } } else { // No pbuffer support either -- fallback to simplest copying from framebuffer this.rttManager = new GLCopyingRTTManager( this._glSupport ); LogManager.Instance.Write( "GL: Using framebuffer copy for rendering to textures (worst)" ); LogManager.Instance.Write( "GL: Warning: RenderTexture size is restricted to size of framebuffer. If you are on Linux, consider using GLX instead of SDL." ); //Copy method uses the main depth buffer but no other depth buffer caps.SetCapability( Graphics.Capabilities.RTTMainDepthbufferAttachable ); caps.SetCapability( Graphics.Capabilities.RTTDepthbufferResolutionLessEqual ); } // Downgrade number of simultaneous targets caps.MultiRenderTargetCount = 1; } var defaultLog = LogManager.Instance.DefaultLog; if ( defaultLog != null ) { caps.Log( defaultLog ); } // Create the texture manager textureManager = new GLTextureManager( this._glSupport ); this._glInitialised = true; }
/// <summary> /// Bind a certain render target if it is a FBO. If it is not a FBO, bind the main frame buffer. /// </summary> /// <param name="target"></param> public override void Bind( RenderTarget target ) { /// Check if the render target is in the rendertarget->FBO map var fbo = (GLFrameBufferObject)target[ "FBO" ]; if ( fbo != null ) { fbo.Bind(); } else { // Old style context (window/pbuffer) or copying render texture Gl.glBindFramebufferEXT( Gl.GL_FRAMEBUFFER_EXT, 0 ); } }
public override void InitializeFromRenderSystemCapabilities( RenderSystemCapabilities caps, RenderTarget primary ) { if ( caps.RendersystemName != Name ) { throw new AxiomException( "Trying to initialize D3D9RenderSystem from RenderSystemCapabilities that do not support Direct3D9" ); } if ( caps.IsShaderProfileSupported( "hlsl" ) ) { HighLevelGpuProgramManager.Instance.AddFactory( this._hlslProgramFactory ); } var defaultLog = LogManager.Instance.DefaultLog; if ( defaultLog != null ) { caps.Log( defaultLog ); } }
/// <summary> /// Unbind a certain render target. This is called before binding another RenderTarget, and before the context is switched. It can be used to do a copy, or just be a noop if direct binding is used. /// </summary> /// <param name="target"> </param> public abstract void Unbind( RenderTarget target );
private void SetRenderTarget( RenderTarget target ) { Contract.RequiresNotNull( _rttManager, "_rttManager" ); if ( activeViewport != null ) _rttManager.Unbind( activeRenderTarget ); activeRenderTarget = target; // Switch context if different from current one GLESContext newContext = null; newContext = (GLESContext)target[ "GLCONTEXT" ]; if ( newContext != null && this._currentContext != newContext ) { SwitchContext( newContext ); } // Bind frame buffer object _rttManager.Bind( target ); }
public override RenderTarget DetachRenderTarget( RenderTarget target ) { return base.DetachRenderTarget( target ); }
/// <summary> /// Detaches the render target from this render system. /// </summary> /// <param name="target">Reference to the render target to detach.</param> /// <returns>the render target that was detached</returns> public virtual RenderTarget DetachRenderTarget(RenderTarget target) { // TODO: Remove prioritized render targets? renderTargets.Remove(target); return target; }
public RenderTargetViewportEventArgs(RenderTarget source, Viewport viewport) : base(source) { this.viewport = viewport; }
public RenderTargetEventArgs(RenderTarget source) { this.source = source; }
/// <summary> /// Create global rendertextures. /// </summary> private void CreateGlobalTextures() { if (this.supportedTechniques.Count == 0) { return; } //To make sure that we are consistent, it is demanded that all composition //techniques define the same set of global textures. var globalTextureNames = new List <string>(); //Initialize global textures from first supported technique var firstTechnique = this.supportedTechniques[0]; foreach (var def in firstTechnique.TextureDefinitions) { if (def.Scope == CompositionTechnique.TextureScope.Global) { //Check that this is a legit global texture if (!string.IsNullOrEmpty(def.ReferenceCompositorName)) { throw new AxiomException("Global compositor texture definition can not be a reference."); } if (def.Width == 0 || def.Height == 0) { throw new AxiomException("Global compositor texture definition must have absolute size."); } if (def.Pooled) { LogManager.Instance.Write("Pooling global compositor textures has no effect", null); } globalTextureNames.Add(def.Name); //TODO GSOC : Heavy copy-pasting from CompositorInstance. How to we solve it? // Make the tetxure RenderTarget renderTarget = null; if (def.PixelFormats.Count > 1) { var MRTBaseName = string.Format("c{0}/{1}/{2}", autoNumber++.ToString(), _name, def.Name); var mrt = Root.Instance.RenderSystem.CreateMultiRenderTarget(MRTBaseName); this.globalMRTs.Add(def.Name, mrt); // create and bind individual surfaces var atch = 0; foreach (var p in def.PixelFormats) { var texName = string.Format("{0}/{1}", MRTBaseName, atch.ToString()); var tex = TextureManager.Instance.CreateManual(texName, ResourceGroupManager.InternalResourceGroupName, TextureType.TwoD, def.Width, def.Height, 0, 0, p, TextureUsage.RenderTarget, null, def.HwGammaWrite && !PixelUtil.IsFloatingPoint(p), def.Fsaa ? 1 : 0); var rt = tex.GetBuffer().GetRenderTarget(); rt.IsAutoUpdated = false; mrt.BindSurface(atch, rt); // Also add to local textures so we can look up var mrtLocalName = GetMRTLocalName(def.Name, atch); this.globalTextures.Add(mrtLocalName, tex); } renderTarget = mrt; } else { var texName = "c" + autoNumber++.ToString() + "/" + _name + "/" + def.Name; // space in the name mixup the cegui in the compositor demo // this is an auto generated name - so no spaces can't hart us. texName = texName.Replace(" ", "_"); var tex = TextureManager.Instance.CreateManual(texName, ResourceGroupManager.InternalResourceGroupName, TextureType.TwoD, def.Width, def.Height, 0, def.PixelFormats[0], TextureUsage.RenderTarget, null, def.HwGammaWrite && !PixelUtil.IsFloatingPoint(def.PixelFormats[0]), def.Fsaa ? 1 : 0); renderTarget = tex.GetBuffer().GetRenderTarget(); this.globalTextures.Add(def.Name, tex); } //Set DepthBuffer pool for sharing renderTarget.DepthBufferPool = def.DepthBufferId; } } //Validate that all other supported techniques expose the same set of global textures. foreach (var technique in this.supportedTechniques) { var isConsistent = true; var numGlobals = 0; foreach (var texDef in technique.TextureDefinitions) { if (texDef.Scope == CompositionTechnique.TextureScope.Global) { if (!globalTextureNames.Contains(texDef.Name)) { isConsistent = false; break; } numGlobals++; } } if (numGlobals != globalTextureNames.Count) { isConsistent = false; } if (!isConsistent) { throw new AxiomException("Different composition techniques define different global textures."); } } }
public virtual void NotifyRenderTargetAttached(RenderTarget renderTarget) { Debug.Assert(!this.attachedRenderTargets.Contains(renderTarget)); this.attachedRenderTargets.Add(renderTarget); }
public override void Bind( RenderTarget target ) { // Nothing to do here // Binding of context is done by GL subsystem, as contexts are also used for RenderWindows }
/// <summary> /// /// </summary> /// <param name="primary"></param> protected void InitializeContext( RenderTarget primary ) { // Set main and current context _mainContext = (GLESContext)primary[ "GLCONTEXT" ]; LogManager.Instance.Write( _mainContext == null ? "maincontext NULL" : "maincontext NOT NULL" ); _currentContext = _mainContext; // Set primary context as active if ( _currentContext != null ) _currentContext.SetCurrent(); // intialize GL extensions and check capabilites _glSupport.InitializeExtensions(); LogManager.Instance.Write( "***************************" ); LogManager.Instance.Write( "*** GLES Renderer Started ***" ); LogManager.Instance.Write( "***************************" ); // log hardware info LogManager.Instance.Write( "Vendor: {0}", _glSupport.Vendor ); LogManager.Instance.Write( "Video Board: {0}", _glSupport.VideoCard ); LogManager.Instance.Write( "Version: {0}", _glSupport.Version ); LogManager.Instance.Write( "Extensions supported: " ); foreach ( string ext in _glSupport.Extensions ) { LogManager.Instance.Write( ext ); } // create our special program manager this._gpuProgramManager = new GLESGpuProgramManager(); // query hardware capabilites CheckCaps( primary ); // create a specialized instance, which registers itself as the singleton instance of HardwareBufferManager // use software buffers as a fallback, which operate as regular vertex arrays if ( this._rsCapabilities.HasCapability( Capabilities.VertexBuffer ) ) { hardwareBufferManager = new GLESHardwareBufferManager(); } else { hardwareBufferManager = new GLESDefaultHardwareBufferManager(); } // by creating our texture manager, singleton TextureManager will hold our implementation textureManager = new GLESTextureManager( _glSupport ); _polygonMode = GLFill; this._glInitialized = true; }
public override DepthBuffer CreateDepthBufferFor( RenderTarget renderTarget ) { var pBack = (Surface[])renderTarget[ "DDBACKBUFFER" ]; if( pBack[0] == null ) return null; var srfDesc = pBack[ 0 ].Description; //Find an appropiarte format for this depth buffer that best matches the RenderTarget's var dsfmt = GetDepthStencilFormatFor( srfDesc.Format ); //Create the depthstencil surface var activeDevice = ActiveD3D9Device; var depthBufferSurface = Surface.CreateDepthStencil( activeDevice, srfDesc.Width, srfDesc.Height, dsfmt, srfDesc.MultisampleType, srfDesc.MultisampleQuality, true ); var newDepthBuffer = new D3D9DepthBuffer( PoolId.Default, this, activeDevice, depthBufferSurface, dsfmt, srfDesc.Width, srfDesc.Height, srfDesc.MultisampleType, srfDesc.MultisampleQuality, false ); return newDepthBuffer; }
/// <summary> /// /// </summary> /// <param name="primary"></param> private void CheckCaps( RenderTarget primary ) { _rsCapabilities = new RenderSystemCapabilities(); _rsCapabilities.DeviceName = OpenTK.Graphics.ES11.GL.GetString( All.Renderer ); _rsCapabilities.VendorName = OpenTK.Graphics.ES11.GL.GetString( All.Vendor ); _rsCapabilities.RendersystemName = Name; // GL ES 1.x is fixed function only _rsCapabilities.SetCapability( Capabilities.FixedFunction ); // Multitexturing support and set number of texture units int units = 0; OpenGL.GetInteger( All.MaxTextureUnits, ref units ); _rsCapabilities.TextureUnitCount = units; // Check for hardware stencil support and set bit depth int stencil = 0; OpenGL.GetInteger( All.StencilBits, ref stencil ); GLESConfig.GlCheckError( this ); if ( stencil != 0 ) { _rsCapabilities.SetCapability( Capabilities.StencilBuffer ); _rsCapabilities.StencilBufferBitCount = stencil; } // Scissor test is standard _rsCapabilities.SetCapability( Capabilities.ScissorTest ); // Vertex Buffer Objects are always supported by OpenGL ES _rsCapabilities.SetCapability( Capabilities.VertexBuffer ); // OpenGL ES - Check for these extensions too // For 1.1, http://www.khronos.org/registry/gles/api/1.1/glext.h // For 2.0, http://www.khronos.org/registry/gles/api/2.0/gl2ext.h if ( _glSupport.CheckExtension( "GL_IMG_texture_compression_pvrtc" ) || _glSupport.CheckExtension( "GL_AMD_compressed_3DC_texture" ) || _glSupport.CheckExtension( "GL_AMD_compressed_ATC_texture" ) || _glSupport.CheckExtension( "GL_OES_compressed_ETC1_RGB8_texture" ) || _glSupport.CheckExtension( "GL_OES_compressed_paletted_texture" ) ) { // TODO: Add support for compression types other than pvrtc _rsCapabilities.SetCapability( Capabilities.TextureCompression ); if ( _glSupport.CheckExtension( "GL_IMG_texture_compression_pvrtc" ) ) _rsCapabilities.SetCapability( Capabilities.TextureCompressionPVRTC ); } if ( _glSupport.CheckExtension( "GL_EXT_texture_filter_anisotropic" ) ) _rsCapabilities.SetCapability( Capabilities.AnisotropicFiltering ); if ( _glSupport.CheckExtension( "GL_OES_framebuffer_object" ) ) { LogManager.Instance.Write( "[GLES] Framebuffers are supported." ); _rsCapabilities.SetCapability( Capabilities.FrameBufferObjects ); _rsCapabilities.SetCapability( Capabilities.HardwareRenderToTexture ); } else { _rsCapabilities.SetCapability( Capabilities.PBuffer ); _rsCapabilities.SetCapability( Capabilities.HardwareRenderToTexture ); } // Cube map if ( _glSupport.CheckExtension( "GL_OES_texture_cube_map" ) ) _rsCapabilities.SetCapability( Capabilities.CubeMapping ); if ( _glSupport.CheckExtension( "GL_OES_stencil_wrap" ) ) _rsCapabilities.SetCapability( Capabilities.StencilWrap ); if ( _glSupport.CheckExtension( "GL_OES_blend_subtract" ) ) _rsCapabilities.SetCapability( Capabilities.AdvancedBlendOperations ); if ( _glSupport.CheckExtension( "GL_ANDROID_user_clip_plane" ) ) _rsCapabilities.SetCapability( Capabilities.UserClipPlanes ); if ( _glSupport.CheckExtension( "GL_OES_texture3D" ) ) _rsCapabilities.SetCapability( Capabilities.Texture3D ); // GL always shares vertex and fragment texture units (for now?) _rsCapabilities.VertexTextureUnitsShared = true; // Hardware support mipmapping _rsCapabilities.SetCapability( Capabilities.Automipmap ); if ( _glSupport.CheckExtension( "GL_EXT_texture_lod_bias" ) ) _rsCapabilities.SetCapability( Capabilities.MipmapLODBias ); //blending support _rsCapabilities.SetCapability( Capabilities.TextureBlending ); // DOT3 support is standard _rsCapabilities.SetCapability( Capabilities.Dot3 ); if ( _rsCapabilities.HasCapability( Capabilities.VertexBuffer ) ) { hardwareBufferManager = new GLESHardwareBufferManager(); } else { hardwareBufferManager = new GLESDefaultHardwareBufferManager(); } /// Do this after extension function pointers are initialised as the extension /// is used to probe further capabilities. int rttMode = 0; if ( ConfigOptions.ContainsKey( "RTT Preferred Mode" ) ) { ConfigOption opt = ConfigOptions[ "RTT Preferred Mode" ]; // RTT Mode: 0 use whatever available, 1 use PBuffers, 2 force use copying if ( opt.Value == "PBuffer" ) { rttMode = 1; } else if ( opt.Value == "Copy" ) { rttMode = 2; } } LogManager.Instance.Write( "[GLES] 'RTT Preferred Mode' = {0}", rttMode ); // Check for framebuffer object extension if ( _rsCapabilities.HasCapability( Capabilities.FrameBufferObjects ) && ( rttMode < 1 ) ) { if ( _rsCapabilities.HasCapability( Capabilities.HardwareRenderToTexture ) ) { // Create FBO manager LogManager.Instance.Write( "[GLES] Using GL_OES_framebuffer_object for rendering to textures (best)" ); _rttManager = new GLESFBORTTManager(); } } else { // Check GLSupport for PBuffer support if ( _rsCapabilities.HasCapability( Capabilities.PBuffer ) && rttMode < 2 ) { if ( _rsCapabilities.HasCapability( Capabilities.HardwareRenderToTexture ) ) { // Use PBuffers _rttManager = new GLESPBRTTManager(); LogManager.Instance.Write( "[GLES] Using PBuffers for rendering to textures" ); } } else { // No pbuffer support either -- fallback to simplest copying from framebuffer _rttManager = new GLESCopyingRTTManager(); LogManager.Instance.Write( "[GLES] Using framebuffer copy for rendering to textures (worst)" ); LogManager.Instance.Write( "[GLES] Warning: RenderTexture size is restricted to size of framebuffer." ); } _rsCapabilities.MultiRenderTargetCount = 1; } // Point size float ps = 0; OpenGL.GetFloat( All.PointSizeMax, ref ps ); GLESConfig.GlCheckError( this ); _rsCapabilities.MaxPointSize = ps; // Point sprites if ( _glSupport.CheckExtension( "GL_OES_point_sprite" ) ) _rsCapabilities.SetCapability( Capabilities.PointSprites ); _rsCapabilities.SetCapability( Capabilities.PointExtendedParameters ); // UBYTE4 always supported _rsCapabilities.SetCapability( Capabilities.VertexFormatUByte4 ); // Infinite far plane always supported _rsCapabilities.SetCapability( Capabilities.InfiniteFarPlane ); // hardware occlusion support _rsCapabilities.SetCapability( Capabilities.HardwareOcculusion ); //// Check for Float textures if ( _glSupport.CheckExtension( "GL_OES_texture_half_float" ) ) _rsCapabilities.SetCapability( Capabilities.TextureFloat ); // Alpha to coverage always 'supported' when MSAA is available // although card may ignore it if it doesn't specifically support A2C _rsCapabilities.SetCapability( Capabilities.AlphaToCoverage ); }
public CompositorTargetOperation(RenderTarget target) { this.target = target; currentQueueGroupID = 0; renderSystemOperations = new List<QueueIDAndOperation>(); visibilityMask = 0xFFFFFFFF; lodBias = 1.0f; onlyInitial = false; hasBeenRendered = false; findVisibleObjects = false; }
/// <summary> /// /// </summary> /// <param name="target"></param> public void DetachRenderTarget( RenderTarget target ) { if ( this.activeRenderSystem == null ) { throw new AxiomException( "Cannot detach render target - no render system has been selected." ); } this.activeRenderSystem.DetachRenderTarget( target ); }
/// <summary> /// Unbind a certain render target. No-op for FBOs. /// </summary> /// <param name="target"></param> public override void Unbind( RenderTarget target ) { // Nothing to see here, move along. }
/// <summary> /// </summary> /// <param name="pb"> </param> /// <param name="buffer"> </param> public override void CopyContentsToMemory( PixelBox pb, RenderTarget.FrameBuffer buffer ) { throw new NotImplementedException(); }
public virtual void Unbind( RenderTarget target ) {}
public void GLESRTTManager( GLESSupport support, RenderTarget mainWindow ) { _support = support; _mainWindow = mainWindow; _mainContext = (GLESContext)_mainWindow[ "glcontext" ]; }
public virtual void NotifyRenderTargetDetached(RenderTarget renderTarget) { var success = this.attachedRenderTargets.Remove(renderTarget); Debug.Assert(success); }
public override void InitializeFromRenderSystemCapabilities( RenderSystemCapabilities caps, RenderTarget primary ) { if ( caps.RendersystemName != this.Name ) { throw new AxiomException( "Trying to initialize GLES2RenderSystem from RenderSystemCapabilities that do not support OpenGL ES" ); } this.gpuProgramManager = new GLES2GpuProgramManager(); this.glslESProgramFactory = new GLSLES.GLSLESProgramFactory(); HighLevelGpuProgramManager.Instance.AddFactory( this.glslESProgramFactory ); //todo: check what can/can't support cg this.glslESCgProgramFactory = new GLSLES.GLSLESCgProgramFactory(); HighLevelGpuProgramManager.Instance.AddFactory( this.glslESCgProgramFactory ); //Set texture the number of texture units this.fixedFunctionTextureUnits = caps.TextureUnitCount; //Use VBO's by default this.hardwareBufferManager = new GLES2HardwareBufferManager(); //Create FBO manager LogManager.Instance.Write( "GL ES 2: Using FBOs for rendering to textures" ); this.rttManager = new GLES2FBOManager(); caps.SetCapability( Graphics.Capabilities.RTTSerperateDepthBuffer ); Log defaultLog = LogManager.Instance.DefaultLog; if ( defaultLog != null ) { caps.Log( defaultLog ); } textureManager = new GLES2TextureManager( this.glSupport ); this.glInitialized = true; }
public override void Bind( RenderTarget target ) { // nothing to do here }
public DepthBuffer CreateDepthBufferFor( RenderTarget renderTarget ) { GLES2DepthBuffer retVal = null; //Only FBO & ppbuffer support different depth buffers, so everything //else creates dummy (empty containers GLES2FrameBufferObject fbo = null; fbo = (GLES2FrameBufferObject) renderTarget[ "FBO" ]; if ( fbo != null ) { // Presence of an FBO means the manager is an FBO Manager, that's why it's safe to downcast // Find best depth & stencil format suited for the RT's format GLenum depthFormat = GLenum.None, stencilFormat = GLenum.None; ( this.rttManager as GLES2FBOManager ).GetBestDepthStencil( fbo.Format, ref depthFormat, ref stencilFormat ); var depthBuffer = new GLES2RenderBuffer( depthFormat, fbo.Width, fbo.Height, fbo.FSAA ); GLES2RenderBuffer stencilBuffer = depthBuffer; if ( stencilBuffer != null ) { stencilBuffer = new GLES2RenderBuffer( stencilFormat, fbo.Width, fbo.Height, fbo.FSAA ); } //No "custom-quality" multisample for now in GL retVal = new GLES2DepthBuffer( 0, this, this.currentContext, depthBuffer, stencilBuffer, fbo.Width, fbo.Height, fbo.FSAA, 0, false ); } return retVal; }
/// <summary> /// The constructor. Dimensions of the viewport are expressed as a pecentage between /// 0 and 100. This allows the dimensions to apply irrespective of /// changes in the target's size: e.g. to fill the whole area, /// values of 0,0,100,100 are appropriate. /// </summary> /// <param name="camera">Reference to the camera to be the source for the image.</param> /// <param name="target">Reference to the render target to be the destination for the rendering.</param> /// <param name="left">Left</param> /// <param name="top">Top</param> /// <param name="width">Width</param> /// <param name="height">Height</param> /// <param name="zOrder">Relative Z-order on the target. Lower = further to the front.</param> public Viewport(Camera camera, RenderTarget target, float left, float top, float width, float height, int zOrder) { Debug.Assert(camera != null, "Cannot use a null Camera to create a viewport."); Debug.Assert(target != null, "Cannor use a null RenderTarget to create a viewport."); LogManager.Instance.Write("Creating viewport rendering from camera '{0}', relative dimensions L:{1},T:{2},W:{3},H:{4}, Z-Order:{5}", camera.Name, left, top, width, height, zOrder); this.camera = camera; this.target = target; this.zOrder = zOrder; relativeLeft = left; relativeTop = top; relativeWidth = width; relativeHeight = height; backColor = ColorEx.Black; clearEveryFrame = true; clearBuffers = FrameBuffer.Color | FrameBuffer.Depth; // Calculate actual dimensions UpdateDimensions(); isUpdated = true; showOverlays = true; showSkies = true; showShadows = true; materialSchemeName = MaterialManager.DefaultSchemeName; // notify camera camera.NotifyViewport(this); }
public virtual bool IsCompatible(RenderTarget renderTarget) { return(Width >= renderTarget.Width && Height >= renderTarget.Height && Fsaa == renderTarget.FSAA); }