private void _convertVertexShaderCaps( RenderSystemCapabilities rsc )
{
var major = 0xFF;
var minor = 0xFF;
var minVsCaps = new D3D9.Capabilities();
// Find the device with the lowest vertex shader caps.
foreach ( var pCurDriver in this._driverList )
{
var rkCurCaps = pCurDriver.D3D9DeviceCaps;
var currMajor = rkCurCaps.VertexShaderVersion.Major;
var currMinor = rkCurCaps.VertexShaderVersion.Minor;
if ( currMajor < major )
{
major = currMajor;
minor = currMinor;
minVsCaps = rkCurCaps;
}
else if ( currMajor == major && currMinor < minor )
{
minor = currMinor;
minVsCaps = rkCurCaps;
}
}
var vs2x = false;
var vs2a = false;
// Special case detection for vs_2_x/a support
if ( major >= 2 )
{
if ( ( minVsCaps.VS20Caps.Caps & D3D9.VertexShaderCaps.Predication ) != 0 &&
( minVsCaps.VS20Caps.DynamicFlowControlDepth > 0 ) && ( minVsCaps.VS20Caps.TempCount >= 12 ) )
{
vs2x = true;
}
if ( ( minVsCaps.VS20Caps.Caps & D3D9.VertexShaderCaps.Predication ) != 0 &&
( minVsCaps.VS20Caps.DynamicFlowControlDepth > 0 ) && ( minVsCaps.VS20Caps.TempCount >= 13 ) )
{
vs2a = true;
}
}
// Populate max param count
switch ( major )
{
case 1:
// No boolean params allowed
rsc.VertexProgramConstantBoolCount = 0;
// No integer params allowed
rsc.VertexProgramConstantIntCount = 0;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
case 2:
// 16 boolean params allowed
rsc.VertexProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.VertexProgramConstantIntCount = 16;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
case 3:
// 16 boolean params allowed
rsc.VertexProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.VertexProgramConstantIntCount = 16;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
}
// populate syntax codes in program manager (no breaks in this one so it falls through)
switch ( major )
{
case 3:
rsc.AddShaderProfile( "vs_3_0" );
goto case 2;
case 2:
if ( vs2x )
{
rsc.AddShaderProfile( "vs_2_x" );
}
if ( vs2a )
{
rsc.AddShaderProfile( "vs_2_a" );
}
rsc.AddShaderProfile( "vs_2_0" );
goto case 1;
case 1:
rsc.AddShaderProfile( "vs_1_1" );
rsc.SetCapability( Graphics.Capabilities.VertexPrograms );
break;
}
}
public override RenderSystemCapabilities CreateRenderSystemCapabilities()
{
var rsc = new RenderSystemCapabilities();
rsc.SetCategoryRelevant(CapabilitiesCategory.GL, true);
rsc.DriverVersion = driverVersion;
var deviceName = Gl.glGetString(Gl.GL_RENDERER);
var vendorName = Gl.glGetString(Gl.GL_VENDOR);
rsc.DeviceName = deviceName;
rsc.RendersystemName = Name;
// determine vendor
if (vendorName.Contains("NVIDIA"))
{
rsc.Vendor = GPUVendor.Nvidia;
}
else if (vendorName.Contains("ATI"))
{
rsc.Vendor = GPUVendor.Ati;
}
else if (vendorName.Contains("Intel"))
{
rsc.Vendor = GPUVendor.Intel;
}
else if (vendorName.Contains("S3"))
{
rsc.Vendor = GPUVendor.S3;
}
else if (vendorName.Contains("Matrox"))
{
rsc.Vendor = GPUVendor.Matrox;
}
else if (vendorName.Contains("3DLabs"))
{
rsc.Vendor = GPUVendor._3DLabs;
}
else if (vendorName.Contains("SiS"))
{
rsc.Vendor = GPUVendor.Sis;
}
else
{
rsc.Vendor = GPUVendor.Unknown;
}
rsc.SetCapability(Graphics.Capabilities.FixedFunction);
if (this.GLEW_VERSION_1_4 || this.GLEW_SGIS_generate_mipmap)
{
var disableAutoMip = false;
#if AXIOM_PLATFORM == AXIOM_PLATFORM_APPLE || AXIOM_PLATFORM == AXIOM_PLATFORM_LINUX
// Apple & Linux ATI drivers have faults in hardware mipmap generation
if (rsc.Vendor == GPUVendor.Ati)
{
disableAutoMip = true;
}
#endif
// The Intel 915G frequently corrupts textures when using hardware mip generation
// I'm not currently sure how many generations of hardware this affects,
// so for now, be safe.
if (rsc.Vendor == GPUVendor.Intel)
{
disableAutoMip = true;
}
// SiS chipsets also seem to have problems with this
if (rsc.Vendor == GPUVendor.Sis)
{
disableAutoMip = true;
}
if (!disableAutoMip)
{
rsc.SetCapability(Graphics.Capabilities.HardwareMipMaps);
}
}
// Check for blending support
if (this.GLEW_VERSION_1_3 || this.GLEW_ARB_texture_env_combine || this.GLEW_EXT_texture_env_combine)
{
rsc.SetCapability(Graphics.Capabilities.Blending);
}
// Check for Multitexturing support and set number of texture units
if (this.GLEW_VERSION_1_3 || this.GLEW_ARB_multitexture)
{
int units;
Gl.glGetIntegerv(Gl.GL_MAX_TEXTURE_UNITS, out units);
if (this.GLEW_ARB_fragment_program)
{
// Also check GL_MAX_TEXTURE_IMAGE_UNITS_ARB since NV at least
// only increased this on the FX/6x00 series
int arbUnits;
Gl.glGetIntegerv(Gl.GL_MAX_TEXTURE_IMAGE_UNITS_ARB, out arbUnits);
if (arbUnits > units)
{
units = arbUnits;
}
}
rsc.TextureUnitCount = units;
}
else
{
// If no multitexture support then set one texture unit
rsc.TextureUnitCount = 1;
}
// Check for Anisotropy support
if (this.GLEW_EXT_texture_filter_anisotropic)
{
rsc.SetCapability(Graphics.Capabilities.AnisotropicFiltering);
}
// Check for DOT3 support
if (this.GLEW_VERSION_1_3 || this.GLEW_ARB_texture_env_dot3 || this.GLEW_EXT_texture_env_dot3)
{
rsc.SetCapability(Graphics.Capabilities.Dot3);
}
// Check for cube mapping
if (this.GLEW_VERSION_1_3 || this.GLEW_ARB_texture_cube_map || this.GLEW_EXT_texture_cube_map)
{
rsc.SetCapability(Graphics.Capabilities.CubeMapping);
}
// Point sprites
if (this.GLEW_VERSION_2_0 || this.GLEW_ARB_point_sprite)
{
rsc.SetCapability(Graphics.Capabilities.PointSprites);
}
// Check for point parameters
if (this.GLEW_VERSION_1_4)
{
rsc.SetCapability(Graphics.Capabilities.PointExtendedParameters);
}
if (this.GLEW_ARB_point_parameters)
{
rsc.SetCapability(Graphics.Capabilities.PointExtendedParametersARB);
}
if (this.GLEW_EXT_point_parameters)
{
rsc.SetCapability(Graphics.Capabilities.PointExtendedParametersEXT);
}
// Check for hardware stencil support and set bit depth
int stencil;
Gl.glGetIntegerv(Gl.GL_STENCIL_BITS, out stencil);
if (stencil != 0)
{
rsc.SetCapability(Graphics.Capabilities.StencilBuffer);
rsc.StencilBufferBitCount = stencil;
}
if (this.GLEW_VERSION_1_5 || this.GLEW_ARB_vertex_buffer_object)
{
if (!this.GLEW_ARB_vertex_buffer_object)
{
rsc.SetCapability(Graphics.Capabilities.GL15NoVbo);
}
rsc.SetCapability(Graphics.Capabilities.VertexBuffer);
}
if (this.GLEW_ARB_vertex_program)
{
rsc.SetCapability(Graphics.Capabilities.VertexPrograms);
// Vertex Program Properties
rsc.VertexProgramConstantBoolCount = 0;
rsc.VertexProgramConstantIntCount = 0;
int floatConstantCount;
Gl.glGetProgramivARB(Gl.GL_VERTEX_PROGRAM_ARB, Gl.GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, out floatConstantCount);
rsc.VertexProgramConstantFloatCount = floatConstantCount;
rsc.AddShaderProfile("arbvp1");
if (this.GLEW_NV_vertex_program2_option)
{
rsc.AddShaderProfile("vp30");
}
if (this.GLEW_NV_vertex_program3)
{
rsc.AddShaderProfile("vp40");
}
if (this.GLEW_NV_vertex_program4)
{
rsc.AddShaderProfile("gp4vp");
rsc.AddShaderProfile("gpu_vp");
}
}
if (this.GLEW_NV_register_combiners2 && this.GLEW_NV_texture_shader)
{
rsc.SetCapability(Graphics.Capabilities.FragmentPrograms);
rsc.AddShaderProfile("fp20");
}
// NFZ - check for ATI fragment shader support
if (this.GLEW_ATI_fragment_shader)
{
rsc.SetCapability(Graphics.Capabilities.FragmentPrograms);
// no boolean params allowed
rsc.FragmentProgramConstantBoolCount = 0;
// no integer params allowed
rsc.FragmentProgramConstantIntCount = 0;
// only 8 Vector4 constant floats supported
rsc.FragmentProgramConstantFloatCount = 8;
rsc.AddShaderProfile("ps_1_4");
rsc.AddShaderProfile("ps_1_3");
rsc.AddShaderProfile("ps_1_2");
rsc.AddShaderProfile("ps_1_1");
}
if (this.GLEW_ARB_fragment_program)
{
rsc.SetCapability(Graphics.Capabilities.FragmentPrograms);
// Fragment Program Properties
rsc.FragmentProgramConstantBoolCount = 0;
rsc.FragmentProgramConstantIntCount = 0;
int floatConstantCount;
Gl.glGetProgramivARB(Gl.GL_FRAGMENT_PROGRAM_ARB, Gl.GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, out floatConstantCount);
rsc.FragmentProgramConstantFloatCount = floatConstantCount;
rsc.AddShaderProfile("arbfp1");
if (this.GLEW_NV_fragment_program_option)
{
rsc.AddShaderProfile("fp30");
}
if (this.GLEW_NV_fragment_program2)
{
rsc.AddShaderProfile("fp40");
}
}
// NFZ - Check if GLSL is supported
if (this.GLEW_VERSION_2_0 ||
(this.GLEW_ARB_shading_language_100 && this.GLEW_ARB_shader_objects && this.GLEW_ARB_fragment_shader &&
this.GLEW_ARB_vertex_shader))
{
rsc.AddShaderProfile("glsl");
}
// Check if geometry shaders are supported
if (this.GLEW_VERSION_2_0 && this.GLEW_EXT_geometry_shader4)
{
rsc.SetCapability(Graphics.Capabilities.GeometryPrograms);
rsc.AddShaderProfile("nvgp4");
//Also add the CG profiles
rsc.AddShaderProfile("gpu_gp");
rsc.AddShaderProfile("gp4gp");
rsc.GeometryProgramConstantBoolCount = 0;
rsc.GeometryProgramConstantIntCount = 0;
int floatConstantCount;
Gl.glGetProgramivARB(Gl.GL_GEOMETRY_PROGRAM_NV, Gl.GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, out floatConstantCount);
rsc.GeometryProgramConstantFloatCount = floatConstantCount;
int maxOutputVertices;
Gl.glGetIntegerv(Gl.GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, out maxOutputVertices);
rsc.GeometryProgramNumOutputVertices = maxOutputVertices;
}
if (this._glSupport.CheckExtension("GL_ARB_get_program_binary"))
{
// states 3.0 here: http://developer.download.nvidia.com/opengl/specs/GL_ARB_get_program_binary.txt
// but not here: http://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramBinary.xml
// and here states 4.1: http://www.geeks3d.com/20100727/opengl-4-1-allows-the-use-of-binary-shaders/
rsc.SetCapability(Graphics.Capabilities.CanGetCompiledShaderBuffer);
}
if (this.GLEW_VERSION_3_3)
{
// states 3.3 here: http://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribDivisor.xml
rsc.SetCapability(Graphics.Capabilities.VertexBufferInstanceData);
}
//Check if render to vertex buffer (transform feedback in OpenGL)
if (this.GLEW_VERSION_2_0 && this.GLEW_NV_transform_feedback)
{
rsc.SetCapability(Graphics.Capabilities.HardwareRenderToTexture);
}
// Check for texture compression
if (this.GLEW_VERSION_1_3 || this.GLEW_ARB_texture_compression)
{
rsc.SetCapability(Graphics.Capabilities.TextureCompression);
// Check for dxt compression
if (this.GLEW_EXT_texture_compression_s3tc)
{
#if __APPLE__ && __PPC__
// Apple on ATI & PPC has errors in DXT
if (_glSupport.Vendor.Contains("ATI") == false)
#endif
rsc.SetCapability(Graphics.Capabilities.TextureCompressionDXT);
}
// Check for vtc compression
if (this.GLEW_NV_texture_compression_vtc)
{
rsc.SetCapability(Graphics.Capabilities.TextureCompressionVTC);
}
}
// Scissor test is standard in GL 1.2 (is it emulated on some cards though?)
rsc.SetCapability(Graphics.Capabilities.ScissorTest);
// As are user clipping planes
rsc.SetCapability(Graphics.Capabilities.UserClipPlanes);
// 2-sided stencil?
if (this.GLEW_VERSION_2_0 || this.GLEW_EXT_stencil_two_side)
{
rsc.SetCapability(Graphics.Capabilities.TwoSidedStencil);
}
// stencil wrapping?
if (this.GLEW_VERSION_1_4 || this.GLEW_EXT_stencil_wrap)
{
rsc.SetCapability(Graphics.Capabilities.StencilWrap);
}
// Check for hardware occlusion support
if (this.GLEW_VERSION_1_5 || this.GLEW_ARB_occlusion_query)
{
// Some buggy driver claim that it is GL 1.5 compliant and
// not support ARB_occlusion_query
if (!this.GLEW_ARB_occlusion_query)
{
rsc.SetCapability(Graphics.Capabilities.GL15NoHardwareOcclusion);
}
rsc.SetCapability(Graphics.Capabilities.HardwareOcculusion);
}
else if (this.GLEW_NV_occlusion_query)
{
// Support NV extension too for old hardware
rsc.SetCapability(Graphics.Capabilities.HardwareOcculusion);
}
// UBYTE4 always supported
rsc.SetCapability(Graphics.Capabilities.VertexFormatUByte4);
// Infinite far plane always supported
rsc.SetCapability(Graphics.Capabilities.InfiniteFarPlane);
// Check for non-power-of-2 texture support
if (this.GLEW_ARB_texture_non_power_of_two)
{
rsc.SetCapability(Graphics.Capabilities.NonPowerOf2Textures);
}
// Check for Float textures
if (this.GLEW_ATI_texture_float || this.GLEW_ARB_texture_float)
{
rsc.SetCapability(Graphics.Capabilities.TextureFloat);
}
// 3D textures should be supported by GL 1.2, which is our minimum version
rsc.SetCapability(Graphics.Capabilities.Texture3D);
// Check for framebuffer object extension
if (this.GLEW_EXT_framebuffer_object)
{
// Probe number of draw buffers
// Only makes sense with FBO support, so probe here
if (this.GLEW_VERSION_2_0 || this.GLEW_ARB_draw_buffers || this.GLEW_ATI_draw_buffers)
{
int buffers;
Gl.glGetIntegerv(Gl.GL_MAX_DRAW_BUFFERS_ARB, out buffers);
rsc.MultiRenderTargetCount = Utility.Min(buffers, Config.MaxMultipleRenderTargets);
rsc.SetCapability(Graphics.Capabilities.MRTDifferentBitDepths);
if (!this.GLEW_VERSION_2_0)
{
// Before GL version 2.0, we need to get one of the extensions
if (this.GLEW_ARB_draw_buffers)
{
rsc.SetCapability(Graphics.Capabilities.FrameBufferObjectsARB);
}
if (this.GLEW_ATI_draw_buffers)
{
rsc.SetCapability(Graphics.Capabilities.FrameBufferObjectsATI);
}
}
// Set FBO flag for all 3 'subtypes'
rsc.SetCapability(Graphics.Capabilities.FrameBufferObjects);
}
rsc.SetCapability(Graphics.Capabilities.HardwareRenderToTexture);
}
// Check GLSupport for PBuffer support
if (this._glSupport.SupportsPBuffers)
{
// Use PBuffers
rsc.SetCapability(Graphics.Capabilities.HardwareRenderToTexture);
rsc.SetCapability(Graphics.Capabilities.PBuffer);
}
// Point size
if (this.GLEW_VERSION_1_4)
{
float ps;
Gl.glGetFloatv(Gl.GL_POINT_SIZE_MAX, out ps);
rsc.MaxPointSize = ps;
}
else
{
var vSize = new int[2];
Gl.glGetIntegerv(Gl.GL_POINT_SIZE_RANGE, vSize);
rsc.MaxPointSize = vSize[1];
}
// Vertex texture fetching
if (this._glSupport.CheckExtension("GL_ARB_vertex_shader"))
{
int vUnits;
Gl.glGetIntegerv(Gl.GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, out vUnits);
rsc.VertexTextureUnitCount = vUnits;
if (vUnits > 0)
{
rsc.SetCapability(Graphics.Capabilities.VertexTextureFetch);
}
// GL always shares vertex and fragment texture units (for now?)
rsc.VertexTextureUnitsShared = true;
}
// Mipmap LOD biasing?
if (this.GLEW_VERSION_1_4 || this.GLEW_EXT_texture_lod_bias)
{
rsc.SetCapability(Graphics.Capabilities.MipmapLODBias);
}
// Alpha to coverage?
if (this._glSupport.CheckExtension("GL_ARB_multisample"))
{
// Alpha to coverage always 'supported' when MSAA is available
// although card may ignore it if it doesn't specifically support A2C
rsc.SetCapability(Graphics.Capabilities.AlphaToCoverage);
}
// Advanced blending operations
if (this.GLEW_VERSION_2_0)
{
rsc.SetCapability(Graphics.Capabilities.AdvancedBlendOperations);
}
return(rsc);
}
public override RenderSystemCapabilities CreateRenderSystemCapabilities()
{
var rsc = new RenderSystemCapabilities();
rsc.SetCategoryRelevant( CapabilitiesCategory.GL, true );
rsc.DriverVersion = driverVersion;
var deviceName = Gl.glGetString( Gl.GL_RENDERER );
var vendorName = Gl.glGetString( Gl.GL_VENDOR );
rsc.DeviceName = deviceName;
rsc.RendersystemName = Name;
// determine vendor
if ( vendorName.Contains( "NVIDIA" ) )
{
rsc.Vendor = GPUVendor.Nvidia;
}
else if ( vendorName.Contains( "ATI" ) )
{
rsc.Vendor = GPUVendor.Ati;
}
else if ( vendorName.Contains( "Intel" ) )
{
rsc.Vendor = GPUVendor.Intel;
}
else if ( vendorName.Contains( "S3" ) )
{
rsc.Vendor = GPUVendor.S3;
}
else if ( vendorName.Contains( "Matrox" ) )
{
rsc.Vendor = GPUVendor.Matrox;
}
else if ( vendorName.Contains( "3DLabs" ) )
{
rsc.Vendor = GPUVendor._3DLabs;
}
else if ( vendorName.Contains( "SiS" ) )
{
rsc.Vendor = GPUVendor.Sis;
}
else
{
rsc.Vendor = GPUVendor.Unknown;
}
rsc.SetCapability( Graphics.Capabilities.FixedFunction );
if ( this.GLEW_VERSION_1_4 || this.GLEW_SGIS_generate_mipmap )
{
var disableAutoMip = false;
#if AXIOM_PLATFORM == AXIOM_PLATFORM_APPLE || AXIOM_PLATFORM == AXIOM_PLATFORM_LINUX
// Apple & Linux ATI drivers have faults in hardware mipmap generation
if ( rsc.Vendor == GPUVendor.Ati )
{
disableAutoMip = true;
}
#endif
// The Intel 915G frequently corrupts textures when using hardware mip generation
// I'm not currently sure how many generations of hardware this affects,
// so for now, be safe.
if ( rsc.Vendor == GPUVendor.Intel )
{
disableAutoMip = true;
}
// SiS chipsets also seem to have problems with this
if ( rsc.Vendor == GPUVendor.Sis )
{
disableAutoMip = true;
}
if ( !disableAutoMip )
{
rsc.SetCapability( Graphics.Capabilities.HardwareMipMaps );
}
}
// Check for blending support
if ( this.GLEW_VERSION_1_3 || this.GLEW_ARB_texture_env_combine || this.GLEW_EXT_texture_env_combine )
{
rsc.SetCapability( Graphics.Capabilities.Blending );
}
// Check for Multitexturing support and set number of texture units
if ( this.GLEW_VERSION_1_3 || this.GLEW_ARB_multitexture )
{
int units;
Gl.glGetIntegerv( Gl.GL_MAX_TEXTURE_UNITS, out units );
if ( this.GLEW_ARB_fragment_program )
{
// Also check GL_MAX_TEXTURE_IMAGE_UNITS_ARB since NV at least
// only increased this on the FX/6x00 series
int arbUnits;
Gl.glGetIntegerv( Gl.GL_MAX_TEXTURE_IMAGE_UNITS_ARB, out arbUnits );
if ( arbUnits > units )
{
units = arbUnits;
}
}
rsc.TextureUnitCount = units;
}
else
{
// If no multitexture support then set one texture unit
rsc.TextureUnitCount = 1;
}
// Check for Anisotropy support
if ( this.GLEW_EXT_texture_filter_anisotropic )
{
rsc.SetCapability( Graphics.Capabilities.AnisotropicFiltering );
}
// Check for DOT3 support
if ( this.GLEW_VERSION_1_3 || this.GLEW_ARB_texture_env_dot3 || this.GLEW_EXT_texture_env_dot3 )
{
rsc.SetCapability( Graphics.Capabilities.Dot3 );
}
// Check for cube mapping
if ( this.GLEW_VERSION_1_3 || this.GLEW_ARB_texture_cube_map || this.GLEW_EXT_texture_cube_map )
{
rsc.SetCapability( Graphics.Capabilities.CubeMapping );
}
// Point sprites
if ( this.GLEW_VERSION_2_0 || this.GLEW_ARB_point_sprite )
{
rsc.SetCapability( Graphics.Capabilities.PointSprites );
}
// Check for point parameters
if ( this.GLEW_VERSION_1_4 )
{
rsc.SetCapability( Graphics.Capabilities.PointExtendedParameters );
}
if ( this.GLEW_ARB_point_parameters )
{
rsc.SetCapability( Graphics.Capabilities.PointExtendedParametersARB );
}
if ( this.GLEW_EXT_point_parameters )
{
rsc.SetCapability( Graphics.Capabilities.PointExtendedParametersEXT );
}
// Check for hardware stencil support and set bit depth
int stencil;
Gl.glGetIntegerv( Gl.GL_STENCIL_BITS, out stencil );
if ( stencil != 0 )
{
rsc.SetCapability( Graphics.Capabilities.StencilBuffer );
rsc.StencilBufferBitCount = stencil;
}
if ( this.GLEW_VERSION_1_5 || this.GLEW_ARB_vertex_buffer_object )
{
if ( !this.GLEW_ARB_vertex_buffer_object )
{
rsc.SetCapability( Graphics.Capabilities.GL15NoVbo );
}
rsc.SetCapability( Graphics.Capabilities.VertexBuffer );
}
if ( this.GLEW_ARB_vertex_program )
{
rsc.SetCapability( Graphics.Capabilities.VertexPrograms );
// Vertex Program Properties
rsc.VertexProgramConstantBoolCount = 0;
rsc.VertexProgramConstantIntCount = 0;
int floatConstantCount;
Gl.glGetProgramivARB( Gl.GL_VERTEX_PROGRAM_ARB, Gl.GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, out floatConstantCount );
rsc.VertexProgramConstantFloatCount = floatConstantCount;
rsc.AddShaderProfile( "arbvp1" );
if ( this.GLEW_NV_vertex_program2_option )
{
rsc.AddShaderProfile( "vp30" );
}
if ( this.GLEW_NV_vertex_program3 )
{
rsc.AddShaderProfile( "vp40" );
}
if ( this.GLEW_NV_vertex_program4 )
{
rsc.AddShaderProfile( "gp4vp" );
rsc.AddShaderProfile( "gpu_vp" );
}
}
if ( this.GLEW_NV_register_combiners2 && this.GLEW_NV_texture_shader )
{
rsc.SetCapability( Graphics.Capabilities.FragmentPrograms );
rsc.AddShaderProfile( "fp20" );
}
// NFZ - check for ATI fragment shader support
if ( this.GLEW_ATI_fragment_shader )
{
rsc.SetCapability( Graphics.Capabilities.FragmentPrograms );
// no boolean params allowed
rsc.FragmentProgramConstantBoolCount = 0;
// no integer params allowed
rsc.FragmentProgramConstantIntCount = 0;
// only 8 Vector4 constant floats supported
rsc.FragmentProgramConstantFloatCount = 8;
rsc.AddShaderProfile( "ps_1_4" );
rsc.AddShaderProfile( "ps_1_3" );
rsc.AddShaderProfile( "ps_1_2" );
rsc.AddShaderProfile( "ps_1_1" );
}
if ( this.GLEW_ARB_fragment_program )
{
rsc.SetCapability( Graphics.Capabilities.FragmentPrograms );
// Fragment Program Properties
rsc.FragmentProgramConstantBoolCount = 0;
rsc.FragmentProgramConstantIntCount = 0;
int floatConstantCount;
Gl.glGetProgramivARB( Gl.GL_FRAGMENT_PROGRAM_ARB, Gl.GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, out floatConstantCount );
rsc.FragmentProgramConstantFloatCount = floatConstantCount;
rsc.AddShaderProfile( "arbfp1" );
if ( this.GLEW_NV_fragment_program_option )
{
rsc.AddShaderProfile( "fp30" );
}
if ( this.GLEW_NV_fragment_program2 )
{
rsc.AddShaderProfile( "fp40" );
}
}
// NFZ - Check if GLSL is supported
if ( this.GLEW_VERSION_2_0 ||
( this.GLEW_ARB_shading_language_100 && this.GLEW_ARB_shader_objects && this.GLEW_ARB_fragment_shader &&
this.GLEW_ARB_vertex_shader ) )
{
rsc.AddShaderProfile( "glsl" );
}
// Check if geometry shaders are supported
if ( this.GLEW_VERSION_2_0 && this.GLEW_EXT_geometry_shader4 )
{
rsc.SetCapability( Graphics.Capabilities.GeometryPrograms );
rsc.AddShaderProfile( "nvgp4" );
//Also add the CG profiles
rsc.AddShaderProfile( "gpu_gp" );
rsc.AddShaderProfile( "gp4gp" );
rsc.GeometryProgramConstantBoolCount = 0;
rsc.GeometryProgramConstantIntCount = 0;
int floatConstantCount;
Gl.glGetProgramivARB( Gl.GL_GEOMETRY_PROGRAM_NV, Gl.GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, out floatConstantCount );
rsc.GeometryProgramConstantFloatCount = floatConstantCount;
int maxOutputVertices;
Gl.glGetIntegerv( Gl.GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, out maxOutputVertices );
rsc.GeometryProgramNumOutputVertices = maxOutputVertices;
}
if ( this._glSupport.CheckExtension( "GL_ARB_get_program_binary" ) )
{
// states 3.0 here: http://developer.download.nvidia.com/opengl/specs/GL_ARB_get_program_binary.txt
// but not here: http://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramBinary.xml
// and here states 4.1: http://www.geeks3d.com/20100727/opengl-4-1-allows-the-use-of-binary-shaders/
rsc.SetCapability( Graphics.Capabilities.CanGetCompiledShaderBuffer );
}
if ( this.GLEW_VERSION_3_3 )
{
// states 3.3 here: http://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribDivisor.xml
rsc.SetCapability( Graphics.Capabilities.VertexBufferInstanceData );
}
//Check if render to vertex buffer (transform feedback in OpenGL)
if ( this.GLEW_VERSION_2_0 && this.GLEW_NV_transform_feedback )
{
rsc.SetCapability( Graphics.Capabilities.HardwareRenderToTexture );
}
// Check for texture compression
if ( this.GLEW_VERSION_1_3 || this.GLEW_ARB_texture_compression )
{
rsc.SetCapability( Graphics.Capabilities.TextureCompression );
// Check for dxt compression
if ( this.GLEW_EXT_texture_compression_s3tc )
{
#if __APPLE__ && __PPC__
// Apple on ATI & PPC has errors in DXT
if (_glSupport.Vendor.Contains("ATI") == false)
#endif
rsc.SetCapability( Graphics.Capabilities.TextureCompressionDXT );
}
// Check for vtc compression
if ( this.GLEW_NV_texture_compression_vtc )
{
rsc.SetCapability( Graphics.Capabilities.TextureCompressionVTC );
}
}
// Scissor test is standard in GL 1.2 (is it emulated on some cards though?)
rsc.SetCapability( Graphics.Capabilities.ScissorTest );
// As are user clipping planes
rsc.SetCapability( Graphics.Capabilities.UserClipPlanes );
// 2-sided stencil?
if ( this.GLEW_VERSION_2_0 || this.GLEW_EXT_stencil_two_side )
{
rsc.SetCapability( Graphics.Capabilities.TwoSidedStencil );
}
// stencil wrapping?
if ( this.GLEW_VERSION_1_4 || this.GLEW_EXT_stencil_wrap )
{
rsc.SetCapability( Graphics.Capabilities.StencilWrap );
}
// Check for hardware occlusion support
if ( this.GLEW_VERSION_1_5 || this.GLEW_ARB_occlusion_query )
{
// Some buggy driver claim that it is GL 1.5 compliant and
// not support ARB_occlusion_query
if ( !this.GLEW_ARB_occlusion_query )
{
rsc.SetCapability( Graphics.Capabilities.GL15NoHardwareOcclusion );
}
rsc.SetCapability( Graphics.Capabilities.HardwareOcculusion );
}
else if ( this.GLEW_NV_occlusion_query )
{
// Support NV extension too for old hardware
rsc.SetCapability( Graphics.Capabilities.HardwareOcculusion );
}
// UBYTE4 always supported
rsc.SetCapability( Graphics.Capabilities.VertexFormatUByte4 );
// Infinite far plane always supported
rsc.SetCapability( Graphics.Capabilities.InfiniteFarPlane );
// Check for non-power-of-2 texture support
if ( this.GLEW_ARB_texture_non_power_of_two )
{
rsc.SetCapability( Graphics.Capabilities.NonPowerOf2Textures );
}
// Check for Float textures
if ( this.GLEW_ATI_texture_float || this.GLEW_ARB_texture_float )
{
rsc.SetCapability( Graphics.Capabilities.TextureFloat );
}
// 3D textures should be supported by GL 1.2, which is our minimum version
rsc.SetCapability( Graphics.Capabilities.Texture3D );
// Check for framebuffer object extension
if ( this.GLEW_EXT_framebuffer_object )
{
// Probe number of draw buffers
// Only makes sense with FBO support, so probe here
if ( this.GLEW_VERSION_2_0 || this.GLEW_ARB_draw_buffers || this.GLEW_ATI_draw_buffers )
{
int buffers;
Gl.glGetIntegerv( Gl.GL_MAX_DRAW_BUFFERS_ARB, out buffers );
rsc.MultiRenderTargetCount = Utility.Min( buffers, Config.MaxMultipleRenderTargets );
rsc.SetCapability( Graphics.Capabilities.MRTDifferentBitDepths );
if ( !this.GLEW_VERSION_2_0 )
{
// Before GL version 2.0, we need to get one of the extensions
if ( this.GLEW_ARB_draw_buffers )
{
rsc.SetCapability( Graphics.Capabilities.FrameBufferObjectsARB );
}
if ( this.GLEW_ATI_draw_buffers )
{
rsc.SetCapability( Graphics.Capabilities.FrameBufferObjectsATI );
}
}
// Set FBO flag for all 3 'subtypes'
rsc.SetCapability( Graphics.Capabilities.FrameBufferObjects );
}
rsc.SetCapability( Graphics.Capabilities.HardwareRenderToTexture );
}
// Check GLSupport for PBuffer support
if ( this._glSupport.SupportsPBuffers )
{
// Use PBuffers
rsc.SetCapability( Graphics.Capabilities.HardwareRenderToTexture );
rsc.SetCapability( Graphics.Capabilities.PBuffer );
}
// Point size
if ( this.GLEW_VERSION_1_4 )
{
float ps;
Gl.glGetFloatv( Gl.GL_POINT_SIZE_MAX, out ps );
rsc.MaxPointSize = ps;
}
else
{
var vSize = new int[2];
Gl.glGetIntegerv( Gl.GL_POINT_SIZE_RANGE, vSize );
rsc.MaxPointSize = vSize[ 1 ];
}
// Vertex texture fetching
if ( this._glSupport.CheckExtension( "GL_ARB_vertex_shader" ) )
{
int vUnits;
Gl.glGetIntegerv( Gl.GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, out vUnits );
rsc.VertexTextureUnitCount = vUnits;
if ( vUnits > 0 )
{
rsc.SetCapability( Graphics.Capabilities.VertexTextureFetch );
}
// GL always shares vertex and fragment texture units (for now?)
rsc.VertexTextureUnitsShared = true;
}
// Mipmap LOD biasing?
if ( this.GLEW_VERSION_1_4 || this.GLEW_EXT_texture_lod_bias )
{
rsc.SetCapability( Graphics.Capabilities.MipmapLODBias );
}
// Alpha to coverage?
if ( this._glSupport.CheckExtension( "GL_ARB_multisample" ) )
{
// Alpha to coverage always 'supported' when MSAA is available
// although card may ignore it if it doesn't specifically support A2C
rsc.SetCapability( Graphics.Capabilities.AlphaToCoverage );
}
// Advanced blending operations
if ( this.GLEW_VERSION_2_0 )
{
rsc.SetCapability( Graphics.Capabilities.AdvancedBlendOperations );
}
return rsc;
}
private void _convertPixelShaderCaps( RenderSystemCapabilities rsc )
{
var major = 0xFF;
var minor = 0xFF;
var minPsCaps = new D3D9.Capabilities();
// Find the device with the lowest vertex shader caps.
foreach ( var pCurDriver in this._driverList )
{
var currCaps = pCurDriver.D3D9DeviceCaps;
var currMajor = currCaps.PixelShaderVersion.Major;
var currMinor = currCaps.PixelShaderVersion.Minor;
if ( currMajor < major )
{
major = currMajor;
minor = currMinor;
minPsCaps = currCaps;
}
else if ( currMajor == major && currMinor < minor )
{
minor = currMinor;
minPsCaps = currCaps;
}
}
var ps2a = false;
var ps2b = false;
var ps2x = false;
// Special case detection for ps_2_x/a/b support
if ( major >= 2 )
{
if ( ( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoTextureInstructionLimit ) != 0 &&
( minPsCaps.PS20Caps.TempCount >= 32 ) )
{
ps2b = true;
}
if ( ( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoTextureInstructionLimit ) != 0 &&
( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoDependentReadLimit ) != 0 &&
( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.ArbitrarySwizzle ) != 0 &&
( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.GradientInstructions ) != 0 &&
( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.Predication ) != 0 && ( minPsCaps.PS20Caps.TempCount >= 22 ) )
{
ps2a = true;
}
// Does this enough?
if ( ps2a || ps2b )
{
ps2x = true;
}
}
switch ( major )
{
case 1:
// no boolean params allowed
rsc.FragmentProgramConstantBoolCount = 0;
// no integer params allowed
rsc.FragmentProgramConstantIntCount = 0;
// float params, always 4D
// NB in ps_1_x these are actually stored as fixed point values,
// but they are entered as floats
rsc.FragmentProgramConstantFloatCount = 8;
break;
case 2:
// 16 boolean params allowed
rsc.FragmentProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.FragmentProgramConstantIntCount = 16;
// float params, always 4D
rsc.FragmentProgramConstantFloatCount = 32;
break;
case 3:
// 16 boolean params allowed
rsc.FragmentProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.FragmentProgramConstantIntCount = 16;
// float params, always 4D
rsc.FragmentProgramConstantFloatCount = 224;
break;
}
// populate syntax codes in program manager (no breaks in this one so it falls through)
switch ( major )
{
case 3:
if ( minor > 0 )
{
rsc.AddShaderProfile( "ps_3_x" );
}
rsc.AddShaderProfile( "ps_3_0" );
goto case 2;
case 2:
if ( ps2x )
{
rsc.AddShaderProfile( "ps_2_x" );
}
if ( ps2a )
{
rsc.AddShaderProfile( "ps_2_a" );
}
if ( ps2b )
{
rsc.AddShaderProfile( "ps_2_b" );
}
rsc.AddShaderProfile( "ps_2_0" );
goto case 1;
case 1:
if ( major > 1 || minor >= 4 )
{
rsc.AddShaderProfile( "ps_1_4" );
}
if ( major > 1 || minor >= 3 )
{
rsc.AddShaderProfile( "ps_1_3" );
}
if ( major > 1 || minor >= 2 )
{
rsc.AddShaderProfile( "ps_1_2" );
}
rsc.AddShaderProfile( "ps_1_1" );
rsc.SetCapability( Graphics.Capabilities.FragmentPrograms );
break;
}
}
public override RenderSystemCapabilities CreateRenderSystemCapabilities()
{
var rsc = new RenderSystemCapabilities();
rsc.SetCategoryRelevant( CapabilitiesCategory.GL, true );
rsc.DriverVersion = driverVersion;
string deviceName = GL.GetString( All.Renderer );
GLES2Config.GlCheckError( this );
string vendorName = GL.GetString( All.Vendor );
GLES2Config.GlCheckError( this );
deviceName = deviceName ?? string.Empty;
vendorName = vendorName ?? string.Empty;
if ( !string.IsNullOrEmpty( deviceName ) )
{
rsc.DeviceName = deviceName;
}
rsc.RendersystemName = this.Name;
//Determine vendor
if ( vendorName.Contains( "Imagination Technologies" ) )
{
rsc.Vendor = GPUVendor.ImaginationTechnologies;
}
else if ( vendorName.Contains( "Apple Computer, Inc." ) )
{
rsc.Vendor = GPUVendor.Apple; // iOS Simulator
}
else if ( vendorName.Contains( "NVIDIA" ) )
{
rsc.Vendor = GPUVendor.Nvidia;
}
else
{
rsc.Vendor = GPUVendor.Unknown;
}
//Multitexturing support and set number of texture units;
int units = 0;
GL.GetInteger( All.MaxTextureImageUnits, ref units );
GLES2Config.GlCheckError( this );
rsc.TextureUnitCount = units;
//check hardware stenicl support and set bit depth
int stencil = -1;
GL.GetInteger( All.StencilBits, ref stencil );
GLES2Config.GlCheckError( this );
if ( stencil != -1 )
{
rsc.SetCapability( Graphics.Capabilities.StencilBuffer );
rsc.SetCapability( Graphics.Capabilities.TwoSidedStencil );
rsc.StencilBufferBitCount = stencil;
}
// Scissor test is standard
rsc.SetCapability( Graphics.Capabilities.ScissorTest );
//Vertex buffer objects are always supported by OpenGL ES
/*Port notes: Ogre sets capability as VBO, or Vertex Buffer Objects.
VertexBuffer is closest
*/
rsc.SetCapability( Graphics.Capabilities.VertexBuffer );
//Check for hardware occlusion support
if ( this.glSupport.CheckExtension( "GL_EXT_occlusion_query_boolean" ) )
{
;
rsc.SetCapability( Graphics.Capabilities.HardwareOcculusion );
}
// OpenGL ES - Check for these extensions too
// For 2.0, http://www.khronos.org/registry/gles/api/2.0/gl2ext.h
if ( this.glSupport.CheckExtension( "GL_IMG_texture_compression_pvrtc" ) || this.glSupport.CheckExtension( "GL_EXT_texture_compression_dxt1" ) || this.glSupport.CheckExtension( "GL_EXT_texture_compression_s3tc" ) )
{
rsc.SetCapability( Graphics.Capabilities.TextureCompression );
if ( this.glSupport.CheckExtension( "GL_IMG_texture_compression_pvrtc" ) )
{
rsc.SetCapability( Graphics.Capabilities.TextureCompressionPVRTC );
}
if ( this.glSupport.CheckExtension( "GL_EXT_texture_compression_dxt1" ) && this.glSupport.CheckExtension( "GL_EXT_texture_compression_s3tc" ) )
{
rsc.SetCapability( Graphics.Capabilities.TextureCompressionDXT );
}
}
if ( this.glSupport.CheckExtension( "GL_EXT_texture_filter_anisotropic" ) )
{
rsc.SetCapability( Graphics.Capabilities.AnisotropicFiltering );
}
rsc.SetCapability( Graphics.Capabilities.FrameBufferObjects );
rsc.SetCapability( Graphics.Capabilities.HardwareRenderToTexture );
rsc.MultiRenderTargetCount = 1;
//Cube map
rsc.SetCapability( Graphics.Capabilities.CubeMapping );
//Stencil wrapping
rsc.SetCapability( Graphics.Capabilities.StencilWrap );
//GL always shares vertex and fragment texture units (for now?)
rsc.VertexTextureUnitsShared = true;
//Hardware support mipmapping
//rsc.SetCapability(Graphics.Capabilities.AutoMipMap);
//Blending support
rsc.SetCapability( Graphics.Capabilities.Blending );
rsc.SetCapability( Graphics.Capabilities.AdvancedBlendOperations );
//DOT3 support is standard
rsc.SetCapability( Graphics.Capabilities.Dot3 );
//Point size
var psRange = new float[ 2 ] { 0.0f, 0.0f };
GL.GetFloat( All.AliasedPointSizeRange, psRange );
GLES2Config.GlCheckError( this );
rsc.MaxPointSize = psRange[ 1 ];
//Point sprites
rsc.SetCapability( Graphics.Capabilities.PointSprites );
rsc.SetCapability( Graphics.Capabilities.PointExtendedParameters );
// GLSL ES is always supported in GL ES 2
rsc.AddShaderProfile( "glsles" );
LogManager.Instance.Write( "GLSL ES support detected" );
//todo: OGRE has a #if here checking for cg support
//I believe Android supports cg, but not iPhone?
rsc.AddShaderProfile( "cg" );
rsc.AddShaderProfile( "ps_2_0" );
rsc.AddShaderProfile( "vs_2_0" );
//UBYTE4 is always supported
rsc.SetCapability( Graphics.Capabilities.VertexFormatUByte4 );
//Infinite far plane always supported
rsc.SetCapability( Graphics.Capabilities.InfiniteFarPlane );
//Vertex/Fragment programs
rsc.SetCapability( Graphics.Capabilities.VertexPrograms );
rsc.SetCapability( Graphics.Capabilities.FragmentPrograms );
//Sepearte shader objects
if ( glSupport.CheckExtension( "GL_EXT_seperate_shader_objects" ) )
rsc.SetCapability( Graphics.Capabilities.SeperateShaderObjects );
float floatConstantCount = 0;
GL.GetFloat( All.MaxVertexUniformVectors, ref floatConstantCount );
GLES2Config.GlCheckError( this );
rsc.VertexProgramConstantFloatCount = (int) floatConstantCount;
rsc.VertexProgramConstantBoolCount = (int) floatConstantCount;
rsc.VertexProgramConstantIntCount = (int) floatConstantCount;
//Fragment Program Properties
floatConstantCount = 0;
GL.GetFloat( All.MaxFragmentUniformVectors, ref floatConstantCount );
GLES2Config.GlCheckError( this );
rsc.FragmentProgramConstantFloatCount = (int) floatConstantCount;
rsc.FragmentProgramConstantBoolCount = (int) floatConstantCount;
rsc.FragmentProgramConstantIntCount = (int) floatConstantCount;
//Geometry programs are not supported, report 0
rsc.GeometryProgramConstantFloatCount = 0;
rsc.GeometryProgramConstantBoolCount = 0;
rsc.GeometryProgramConstantIntCount = 0;
//Check for Float textures
rsc.SetCapability( Graphics.Capabilities.TextureFloat );
//Alpha to coverate always 'supported' when MSAA is availalbe
//although card may ignore it if it doesn't specifically support A2C
rsc.SetCapability( Graphics.Capabilities.AlphaToCoverage );
//No point sprites, so no size
rsc.MaxPointSize = 0;
if ( this.glSupport.CheckExtension( "GL_OES_get_program_binary" ) )
{
// http://www.khronos.org/registry/gles/extensions/OES/OES_get_program_binary.txt
rsc.SetCapability( Graphics.Capabilities.CanGetCompiledShaderBuffer );
}
return rsc;
}
private void _convertVertexShaderCaps(RenderSystemCapabilities rsc)
{
var major = 0xFF;
var minor = 0xFF;
var minVsCaps = new D3D9.Capabilities();
// Find the device with the lowest vertex shader caps.
foreach (var pCurDriver in this._driverList)
{
var rkCurCaps = pCurDriver.D3D9DeviceCaps;
var currMajor = rkCurCaps.VertexShaderVersion.Major;
var currMinor = rkCurCaps.VertexShaderVersion.Minor;
if (currMajor < major)
{
major = currMajor;
minor = currMinor;
minVsCaps = rkCurCaps;
}
else if (currMajor == major && currMinor < minor)
{
minor = currMinor;
minVsCaps = rkCurCaps;
}
}
var vs2x = false;
var vs2a = false;
// Special case detection for vs_2_x/a support
if (major >= 2)
{
if ((minVsCaps.VS20Caps.Caps & D3D9.VertexShaderCaps.Predication) != 0 &&
(minVsCaps.VS20Caps.DynamicFlowControlDepth > 0) && (minVsCaps.VS20Caps.TempCount >= 12))
{
vs2x = true;
}
if ((minVsCaps.VS20Caps.Caps & D3D9.VertexShaderCaps.Predication) != 0 &&
(minVsCaps.VS20Caps.DynamicFlowControlDepth > 0) && (minVsCaps.VS20Caps.TempCount >= 13))
{
vs2a = true;
}
}
// Populate max param count
switch (major)
{
case 1:
// No boolean params allowed
rsc.VertexProgramConstantBoolCount = 0;
// No integer params allowed
rsc.VertexProgramConstantIntCount = 0;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
case 2:
// 16 boolean params allowed
rsc.VertexProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.VertexProgramConstantIntCount = 16;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
case 3:
// 16 boolean params allowed
rsc.VertexProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.VertexProgramConstantIntCount = 16;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
}
// populate syntax codes in program manager (no breaks in this one so it falls through)
switch (major)
{
case 3:
rsc.AddShaderProfile("vs_3_0");
goto case 2;
case 2:
if (vs2x)
{
rsc.AddShaderProfile("vs_2_x");
}
if (vs2a)
{
rsc.AddShaderProfile("vs_2_a");
}
rsc.AddShaderProfile("vs_2_0");
goto case 1;
case 1:
rsc.AddShaderProfile("vs_1_1");
rsc.SetCapability(Graphics.Capabilities.VertexPrograms);
break;
}
}
private void _convertPixelShaderCaps(RenderSystemCapabilities rsc)
{
var major = 0xFF;
var minor = 0xFF;
var minPsCaps = new D3D9.Capabilities();
// Find the device with the lowest vertex shader caps.
foreach (var pCurDriver in this._driverList)
{
var currCaps = pCurDriver.D3D9DeviceCaps;
var currMajor = currCaps.PixelShaderVersion.Major;
var currMinor = currCaps.PixelShaderVersion.Minor;
if (currMajor < major)
{
major = currMajor;
minor = currMinor;
minPsCaps = currCaps;
}
else if (currMajor == major && currMinor < minor)
{
minor = currMinor;
minPsCaps = currCaps;
}
}
var ps2a = false;
var ps2b = false;
var ps2x = false;
// Special case detection for ps_2_x/a/b support
if (major >= 2)
{
if ((minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoTextureInstructionLimit) != 0 &&
(minPsCaps.PS20Caps.TempCount >= 32))
{
ps2b = true;
}
if ((minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoTextureInstructionLimit) != 0 &&
(minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoDependentReadLimit) != 0 &&
(minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.ArbitrarySwizzle) != 0 &&
(minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.GradientInstructions) != 0 &&
(minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.Predication) != 0 && (minPsCaps.PS20Caps.TempCount >= 22))
{
ps2a = true;
}
// Does this enough?
if (ps2a || ps2b)
{
ps2x = true;
}
}
switch (major)
{
case 1:
// no boolean params allowed
rsc.FragmentProgramConstantBoolCount = 0;
// no integer params allowed
rsc.FragmentProgramConstantIntCount = 0;
// float params, always 4D
// NB in ps_1_x these are actually stored as fixed point values,
// but they are entered as floats
rsc.FragmentProgramConstantFloatCount = 8;
break;
case 2:
// 16 boolean params allowed
rsc.FragmentProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.FragmentProgramConstantIntCount = 16;
// float params, always 4D
rsc.FragmentProgramConstantFloatCount = 32;
break;
case 3:
// 16 boolean params allowed
rsc.FragmentProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.FragmentProgramConstantIntCount = 16;
// float params, always 4D
rsc.FragmentProgramConstantFloatCount = 224;
break;
}
// populate syntax codes in program manager (no breaks in this one so it falls through)
switch (major)
{
case 3:
if (minor > 0)
{
rsc.AddShaderProfile("ps_3_x");
}
rsc.AddShaderProfile("ps_3_0");
goto case 2;
case 2:
if (ps2x)
{
rsc.AddShaderProfile("ps_2_x");
}
if (ps2a)
{
rsc.AddShaderProfile("ps_2_a");
}
if (ps2b)
{
rsc.AddShaderProfile("ps_2_b");
}
rsc.AddShaderProfile("ps_2_0");
goto case 1;
case 1:
if (major > 1 || minor >= 4)
{
rsc.AddShaderProfile("ps_1_4");
}
if (major > 1 || minor >= 3)
{
rsc.AddShaderProfile("ps_1_3");
}
if (major > 1 || minor >= 2)
{
rsc.AddShaderProfile("ps_1_2");
}
rsc.AddShaderProfile("ps_1_1");
rsc.SetCapability(Graphics.Capabilities.FragmentPrograms);
break;
}
}
private void _setCapabilitiesForReachProfile( ref RenderSystemCapabilities rsc )
{
// Fill in the Reach profile requirements.
// Texture Compression
// We always support compression, Xna will decompress if device does not support
rsc.SetCapability( Graphics.Capabilities.TextureCompression );
rsc.SetCapability( Graphics.Capabilities.TextureCompressionDXT );
// Xna uses vertex buffers for everything
rsc.SetCapability( Graphics.Capabilities.VertexBuffer );
//VertexShaderVersion = 0x200;
rsc.SetCapability( Graphics.Capabilities.VertexPrograms );
rsc.MaxVertexProgramVersion = "vs_2_0";
rsc.VertexProgramConstantIntCount = 16 * 4;
rsc.VertexProgramConstantFloatCount = 256;
rsc.AddShaderProfile( "vs_1_1" );
rsc.AddShaderProfile( "vs_2_0" );
//PixelShaderVersion = 0x200;
rsc.SetCapability( Graphics.Capabilities.FragmentPrograms );
rsc.MaxFragmentProgramVersion = "ps_2_0";
rsc.FragmentProgramConstantIntCount = 0;
rsc.FragmentProgramConstantFloatCount = 32;
rsc.AddShaderProfile( "ps_1_1" );
rsc.AddShaderProfile( "ps_1_2" );
rsc.AddShaderProfile( "ps_1_3" );
rsc.AddShaderProfile( "ps_1_4" );
rsc.AddShaderProfile( "ps_2_0" );
//SeparateAlphaBlend = false;
//DestBlendSrcAlphaSat = false;
//MaxPrimitiveCount = 65535;
//IndexElementSize32 = false;
//MaxVertexStreams = 16;
//MaxStreamStride = 255;
//MaxTextureSize = 2048;
//MaxCubeSize = 512;
//MaxVolumeExtent = 0;
//MaxTextureAspectRatio = 2048;
//MaxVertexSamplers = 0;
//MaxRenderTargets = 1;
rsc.TextureUnitCount = 16;
rsc.MultiRenderTargetCount = 1;
//NonPow2Unconditional = false;
//NonPow2Cube = false;
//NonPow2Volume = false;
//ValidTextureFormats = MakeList(STANDARD_TEXTURE_FORMATS, COMPRESSED_TEXTURE_FORMATS, SIGNED_TEXTURE_FORMATS);
//ValidCubeFormats = MakeList(STANDARD_TEXTURE_FORMATS, COMPRESSED_TEXTURE_FORMATS);
//ValidVolumeFormats = MakeList<SurfaceFormat>();
//ValidVertexTextureFormats = MakeList<SurfaceFormat>();
//InvalidFilterFormats = MakeList<SurfaceFormat>();
//InvalidBlendFormats = MakeList<SurfaceFormat>();
//ValidVertexFormats = MakeList(STANDARD_VERTEX_FORMATS);
}
private void _setCapabilitiesForHiDefProfile( ref RenderSystemCapabilities rsc )
{
// Fill in the HiDef profile requirements.
rsc.SetCapability( Graphics.Capabilities.HardwareOcculusion );
//VertexShaderVersion = 0x300;
rsc.SetCapability( Graphics.Capabilities.VertexPrograms );
rsc.MaxVertexProgramVersion = "vs_3_0";
rsc.VertexProgramConstantIntCount = 16 * 4;
rsc.VertexProgramConstantFloatCount = 256;
rsc.AddShaderProfile( "vs_1_1" );
rsc.AddShaderProfile( "vs_2_0" );
rsc.AddShaderProfile( "vs_2_x" );
rsc.AddShaderProfile( "vs_3_0" );
//PixelShaderVersion = 0x300;
rsc.SetCapability( Graphics.Capabilities.FragmentPrograms );
rsc.MaxFragmentProgramVersion = "ps_3_0";
rsc.FragmentProgramConstantIntCount = 16;
rsc.FragmentProgramConstantFloatCount = 224;
rsc.AddShaderProfile( "ps_1_1" );
rsc.AddShaderProfile( "ps_1_2" );
rsc.AddShaderProfile( "ps_1_3" );
rsc.AddShaderProfile( "ps_1_4" );
rsc.AddShaderProfile( "ps_2_0" );
rsc.AddShaderProfile( "ps_3_0" );
//SeparateAlphaBlend = true;
rsc.SetCapability( Graphics.Capabilities.AdvancedBlendOperations );
//DestBlendSrcAlphaSat = true;
//MaxPrimitiveCount = 1048575;
//IndexElementSize32 = true;
//MaxVertexStreams = 16;
//MaxStreamStride = 255;
//MaxTextureSize = 4096;
//MaxCubeSize = 4096;
//MaxVolumeExtent = 256;
//MaxTextureAspectRatio = 2048;
//MaxVertexSamplers = 4;
//MaxRenderTargets = 4;
rsc.TextureUnitCount = 16;
rsc.MultiRenderTargetCount = 4;
//NonPow2Unconditional = true;
//NonPow2Cube = true;
//NonPow2Volume = true;
//ValidTextureFormats = MakeList(STANDARD_TEXTURE_FORMATS, COMPRESSED_TEXTURE_FORMATS, SIGNED_TEXTURE_FORMATS, HIDEF_TEXTURE_FORMATS, FLOAT_TEXTURE_FORMATS);
//ValidCubeFormats = MakeList(STANDARD_TEXTURE_FORMATS, COMPRESSED_TEXTURE_FORMATS, HIDEF_TEXTURE_FORMATS, FLOAT_TEXTURE_FORMATS);
//ValidVolumeFormats = MakeList(STANDARD_TEXTURE_FORMATS, HIDEF_TEXTURE_FORMATS, FLOAT_TEXTURE_FORMATS);
//ValidVertexTextureFormats = MakeList(FLOAT_TEXTURE_FORMATS);
//InvalidFilterFormats = MakeList(FLOAT_TEXTURE_FORMATS);
//InvalidBlendFormats = MakeList(STANDARD_FLOAT_TEXTURE_FORMATS);
//ValidVertexFormats = MakeList(STANDARD_VERTEX_FORMATS, HIDEF_VERTEX_FORMATS);
}
