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 RenderTargetEventArgs(RenderTarget source)
{
this.source = source;
}
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 RenderTargetViewportEventArgs(RenderTarget source, Viewport viewport)
: base(source)
{
this.viewport = viewport;
}
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);
}
