//-----------------------------------------------------------------------
void RenderSystemCapabilities::log(Log* pLog)
{
#if OGRE_PLATFORM != OGRE_PLATFORM_WINRT
pLog->logMessage("RenderSystem capabilities");
pLog->logMessage("-------------------------");
pLog->logMessage("RenderSystem Name: " + getRenderSystemName());
pLog->logMessage("GPU Vendor: " + vendorToString(getVendor()));
pLog->logMessage("Device Name: " + getDeviceName());
pLog->logMessage("Driver Version: " + getDriverVersion().toString());
pLog->logMessage(" * Fixed function pipeline: "
+ StringConverter::toString(hasCapability(RSC_FIXED_FUNCTION), true));
pLog->logMessage(
" * Hardware generation of mipmaps: "
+ StringConverter::toString(hasCapability(RSC_AUTOMIPMAP), true));
pLog->logMessage(
" * Texture blending: "
+ StringConverter::toString(hasCapability(RSC_BLENDING), true));
pLog->logMessage(
" * Anisotropic texture filtering: "
+ StringConverter::toString(hasCapability(RSC_ANISOTROPY), true));
pLog->logMessage(
" * Dot product texture operation: "
+ StringConverter::toString(hasCapability(RSC_DOT3), true));
pLog->logMessage(
" * Cube mapping: "
+ StringConverter::toString(hasCapability(RSC_CUBEMAPPING), true));
pLog->logMessage(
" * Hardware stencil buffer: "
+ StringConverter::toString(hasCapability(RSC_HWSTENCIL), true));
if (hasCapability(RSC_HWSTENCIL))
{
pLog->logMessage(
" - Stencil depth: "
+ StringConverter::toString(getStencilBufferBitDepth()));
pLog->logMessage(
" - Two sided stencil support: "
+ StringConverter::toString(hasCapability(RSC_TWO_SIDED_STENCIL), true));
pLog->logMessage(
" - Wrap stencil values: "
+ StringConverter::toString(hasCapability(RSC_STENCIL_WRAP), true));
}
pLog->logMessage(
" * Hardware vertex / index buffers: "
+ StringConverter::toString(hasCapability(RSC_VBO), true));
if(hasCapability(RSC_VBO))
{
pLog->logMessage(
" * 32-bit index buffers: "
+ StringConverter::toString(hasCapability(RSC_32BIT_INDEX), true));
}
pLog->logMessage(
" * Vertex programs: "
+ StringConverter::toString(hasCapability(RSC_VERTEX_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for vertex programs: "
+ StringConverter::toString(mVertexProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for vertex programs: "
+ StringConverter::toString(mVertexProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for vertex programs: "
+ StringConverter::toString(mVertexProgramConstantBoolCount));
pLog->logMessage(
" * Fragment programs: "
+ StringConverter::toString(hasCapability(RSC_FRAGMENT_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for fragment programs: "
+ StringConverter::toString(mFragmentProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for fragment programs: "
+ StringConverter::toString(mFragmentProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for fragment programs: "
+ StringConverter::toString(mFragmentProgramConstantBoolCount));
pLog->logMessage(
" * Geometry programs: "
+ StringConverter::toString(hasCapability(RSC_GEOMETRY_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for geometry programs: "
+ StringConverter::toString(mGeometryProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for geometry programs: "
+ StringConverter::toString(mGeometryProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for geometry programs: "
+ StringConverter::toString(mGeometryProgramConstantBoolCount));
pLog->logMessage(
" * Tessellation Hull programs: "
+ StringConverter::toString(hasCapability(RSC_TESSELLATION_HULL_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for tessellation hull programs: "
+ StringConverter::toString(mTessellationHullProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for tessellation hull programs: "
+ StringConverter::toString(mTessellationHullProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for tessellation hull programs: "
+ StringConverter::toString(mTessellationHullProgramConstantBoolCount));
pLog->logMessage(
" * Tessellation Domain programs: "
+ StringConverter::toString(hasCapability(RSC_TESSELLATION_DOMAIN_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for tessellation domain programs: "
+ StringConverter::toString(mTessellationDomainProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for tessellation domain programs: "
+ StringConverter::toString(mTessellationDomainProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for tessellation domain programs: "
+ StringConverter::toString(mTessellationDomainProgramConstantBoolCount));
pLog->logMessage(
" * Compute programs: "
+ StringConverter::toString(hasCapability(RSC_COMPUTE_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for compute programs: "
+ StringConverter::toString(mComputeProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for compute programs: "
+ StringConverter::toString(mComputeProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for compute programs: "
+ StringConverter::toString(mComputeProgramConstantBoolCount));
String profileList = "";
for(ShaderProfiles::iterator iter = mSupportedShaderProfiles.begin(), end = mSupportedShaderProfiles.end();
iter != end; ++iter)
{
profileList += " " + *iter;
}
pLog->logMessage(" * Supported Shader Profiles:" + profileList);
pLog->logMessage(
" * Texture Compression: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION), true));
if (hasCapability(RSC_TEXTURE_COMPRESSION))
{
pLog->logMessage(
" - DXT: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_DXT), true));
pLog->logMessage(
" - VTC: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_VTC), true));
pLog->logMessage(
" - PVRTC: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_PVRTC), true));
pLog->logMessage(
" - ATC: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_ATC), true));
pLog->logMessage(
" - ETC1: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_ETC1), true));
pLog->logMessage(
" - ETC2: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_ETC2), true));
pLog->logMessage(
" - BC4/BC5: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_BC4_BC5), true));
pLog->logMessage(
" - BC6H/BC7: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_BC6H_BC7), true));
}
pLog->logMessage(
" * Scissor Rectangle: "
+ StringConverter::toString(hasCapability(RSC_SCISSOR_TEST), true));
pLog->logMessage(
" * Hardware Occlusion Query: "
+ StringConverter::toString(hasCapability(RSC_HWOCCLUSION), true));
pLog->logMessage(
" * User clip planes: "
+ StringConverter::toString(hasCapability(RSC_USER_CLIP_PLANES), true));
pLog->logMessage(
" * VET_UBYTE4 vertex element type: "
+ StringConverter::toString(hasCapability(RSC_VERTEX_FORMAT_UBYTE4), true));
pLog->logMessage(
" * Infinite far plane projection: "
+ StringConverter::toString(hasCapability(RSC_INFINITE_FAR_PLANE), true));
pLog->logMessage(
" * Hardware render-to-texture: "
+ StringConverter::toString(hasCapability(RSC_HWRENDER_TO_TEXTURE), true));
pLog->logMessage(
" * Floating point textures: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_FLOAT), true));
pLog->logMessage(
" * Non-power-of-two textures: "
+ StringConverter::toString(hasCapability(RSC_NON_POWER_OF_2_TEXTURES), true)
+ (mNonPOW2TexturesLimited ? " (limited)" : ""));
pLog->logMessage(
" * 1d textures: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_1D), true));
pLog->logMessage(
" * Volume textures: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_3D), true));
pLog->logMessage(
" * Multiple Render Targets: "
+ StringConverter::toString(mNumMultiRenderTargets));
pLog->logMessage(
" - With different bit depths: " + StringConverter::toString(hasCapability(RSC_MRT_DIFFERENT_BIT_DEPTHS), true));
pLog->logMessage(
" * Point Sprites: "
+ StringConverter::toString(hasCapability(RSC_POINT_SPRITES), true));
pLog->logMessage(
" * Extended point parameters: "
+ StringConverter::toString(hasCapability(RSC_POINT_EXTENDED_PARAMETERS), true));
if(hasCapability(RSC_POINT_SPRITES))
{
pLog->logMessage(
" * Max Point Size: "
+ StringConverter::toString(mMaxPointSize));
}
pLog->logMessage(
" * Vertex texture fetch: "
+ StringConverter::toString(hasCapability(RSC_VERTEX_TEXTURE_FETCH), true));
pLog->logMessage(
" * Number of world matrices: "
+ StringConverter::toString(mNumWorldMatrices));
pLog->logMessage(
" * Number of texture units: "
+ StringConverter::toString(mNumTextureUnits));
pLog->logMessage(
" * Stencil buffer depth: "
+ StringConverter::toString(mStencilBufferBitDepth));
pLog->logMessage(
" * Number of vertex blend matrices: "
+ StringConverter::toString(mNumVertexBlendMatrices));
if (hasCapability(RSC_VERTEX_TEXTURE_FETCH))
{
pLog->logMessage(
" - Max vertex textures: "
+ StringConverter::toString(mNumVertexTextureUnits));
pLog->logMessage(
" - Vertex textures shared: "
+ StringConverter::toString(mVertexTextureUnitsShared, true));
}
pLog->logMessage(
" * Render to Vertex Buffer : "
+ StringConverter::toString(hasCapability(RSC_HWRENDER_TO_VERTEX_BUFFER), true));
pLog->logMessage(
" * Hardware Atomic Counters: "
+ StringConverter::toString(hasCapability(RSC_ATOMIC_COUNTERS), true));
if (mCategoryRelevant[CAPS_CATEGORY_GL])
{
pLog->logMessage(
" * GL 1.5 without VBO workaround: "
+ StringConverter::toString(hasCapability(RSC_GL1_5_NOVBO), true));
pLog->logMessage(
" * Frame Buffer objects: "
+ StringConverter::toString(hasCapability(RSC_FBO), true));
pLog->logMessage(
" * Frame Buffer objects (ARB extension): "
+ StringConverter::toString(hasCapability(RSC_FBO_ARB), true));
pLog->logMessage(
" * Frame Buffer objects (ATI extension): "
+ StringConverter::toString(hasCapability(RSC_FBO_ATI), true));
pLog->logMessage(
" * PBuffer support: "
+ StringConverter::toString(hasCapability(RSC_PBUFFER), true));
pLog->logMessage(
" * GL 1.5 without HW-occlusion workaround: "
+ StringConverter::toString(hasCapability(RSC_GL1_5_NOHWOCCLUSION), true));
pLog->logMessage(
" * Vertex Array Objects: "
+ StringConverter::toString(hasCapability(RSC_VAO), true));
pLog->logMessage(
" * Separate shader objects: "
+ StringConverter::toString(hasCapability(RSC_SEPARATE_SHADER_OBJECTS), true));
}
if (mCategoryRelevant[CAPS_CATEGORY_D3D9])
{
pLog->logMessage(
" * DirectX per stage constants: "
+ StringConverter::toString(hasCapability(RSC_PERSTAGECONSTANT), true));
}
#endif
}
//-----------------------------------------------------------------------
void RenderSystemCapabilities::log(Log* pLog)
{
pLog->logMessage("RenderSystem capabilities");
pLog->logMessage("-------------------------");
pLog->logMessage(
" * Hardware generation of mipmaps: "
+ StringConverter::toString(hasCapability(RSC_AUTOMIPMAP), true));
pLog->logMessage(
" * Texture blending: "
+ StringConverter::toString(hasCapability(RSC_BLENDING), true));
pLog->logMessage(
" * Anisotropic texture filtering: "
+ StringConverter::toString(hasCapability(RSC_ANISOTROPY), true));
pLog->logMessage(
" * Dot product texture operation: "
+ StringConverter::toString(hasCapability(RSC_DOT3), true));
pLog->logMessage(
" * Cube mapping: "
+ StringConverter::toString(hasCapability(RSC_CUBEMAPPING), true));
pLog->logMessage(
" * Hardware stencil buffer: "
+ StringConverter::toString(hasCapability(RSC_HWSTENCIL), true));
if (hasCapability(RSC_HWSTENCIL))
{
pLog->logMessage(
" - Stencil depth: "
+ StringConverter::toString(getStencilBufferBitDepth()));
pLog->logMessage(
" - Two sided stencil support: "
+ StringConverter::toString(hasCapability(RSC_TWO_SIDED_STENCIL), true));
pLog->logMessage(
" - Wrap stencil values: "
+ StringConverter::toString(hasCapability(RSC_STENCIL_WRAP), true));
}
pLog->logMessage(
" * Hardware vertex / index buffers: "
+ StringConverter::toString(hasCapability(RSC_VBO), true));
pLog->logMessage(
" * Vertex programs: "
+ StringConverter::toString(hasCapability(RSC_VERTEX_PROGRAM), true));
if (hasCapability(RSC_VERTEX_PROGRAM))
{
pLog->logMessage(
" - Max vertex program version: "
+ getMaxVertexProgramVersion());
}
pLog->logMessage(
" * Fragment programs: "
+ StringConverter::toString(hasCapability(RSC_FRAGMENT_PROGRAM), true));
if (hasCapability(RSC_FRAGMENT_PROGRAM))
{
pLog->logMessage(
" - Max fragment program version: "
+ getMaxFragmentProgramVersion());
}
pLog->logMessage(
" * Texture Compression: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION), true));
if (hasCapability(RSC_TEXTURE_COMPRESSION))
{
pLog->logMessage(
" - DXT: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_DXT), true));
pLog->logMessage(
" - VTC: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_VTC), true));
}
pLog->logMessage(
" * Scissor Rectangle: "
+ StringConverter::toString(hasCapability(RSC_SCISSOR_TEST), true));
pLog->logMessage(
" * Hardware Occlusion Query: "
+ StringConverter::toString(hasCapability(RSC_HWOCCLUSION), true));
pLog->logMessage(
" * User clip planes: "
+ StringConverter::toString(hasCapability(RSC_USER_CLIP_PLANES), true));
pLog->logMessage(
" * VET_UBYTE4 vertex element type: "
+ StringConverter::toString(hasCapability(RSC_VERTEX_FORMAT_UBYTE4), true));
pLog->logMessage(
" * Infinite far plane projection: "
+ StringConverter::toString(hasCapability(RSC_INFINITE_FAR_PLANE), true));
pLog->logMessage(
" * Hardware render-to-texture: "
+ StringConverter::toString(hasCapability(RSC_HWRENDER_TO_TEXTURE), true));
pLog->logMessage(
" * Floating point textures: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_FLOAT), true));
pLog->logMessage(
" * Non-power-of-two textures: "
+ StringConverter::toString(hasCapability(RSC_NON_POWER_OF_2_TEXTURES), true)
+ (mNonPOW2TexturesLimited ? " (limited)" : ""));
pLog->logMessage(
" * Volume textures: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_3D), true));
pLog->logMessage(
" * Multiple Render Targets: "
+ StringConverter::toString(mNumMultiRenderTargets));
pLog->logMessage(
" * Point Sprites: "
+ StringConverter::toString(hasCapability(RSC_POINT_SPRITES), true));
pLog->logMessage(
" * Extended point parameters: "
+ StringConverter::toString(hasCapability(RSC_POINT_EXTENDED_PARAMETERS), true));
pLog->logMessage(
" * Max Point Size: "
+ StringConverter::toString(mMaxPointSize));
}
void DiGfxCaps::LogCaps()
{
DI_INFO("-------------------------");
DI_INFO("--Graphics capabilities--");
DI_INFO("-------------------------");
DI_INFO("GfxDriver: %s", getRenderSystemName().c_str());
DI_INFO("GPU Vendor: %s", vendorToString(getVendor()).c_str());
DI_INFO("Device Name: %s", getDeviceName().c_str());
DI_INFO("Driver Version: %s", getDriverVersion().toString().c_str());
DI_INFO(" * Hardware generation of mipmaps: %s", _BoolToStr(hasCapability(RSC_AUTOMIPMAP)));
DI_INFO(" * Anisotropic texture filtering: %s", _BoolToStr(hasCapability(RSC_ANISOTROPY)));
DI_INFO(" * Hardware stencil buffer: %s", _BoolToStr(hasCapability(RSC_HWSTENCIL)));
if (hasCapability(RSC_HWSTENCIL))
{
DI_INFO(" - Stencil depth: %d", getStencilBufferBitDepth());
DI_INFO(" - Two sided stencil support: %s", _BoolToStr(hasCapability(RSC_TWO_SIDED_STENCIL)));
DI_INFO(" - Wrap stencil values: %s", _BoolToStr(hasCapability(RSC_STENCIL_WRAP)));
}
DI_INFO(" * 32-bit index buffers: %s", +_BoolToStr(hasCapability(RSC_32BIT_INDEX)));
DI_INFO(" * Vertex shader: %s", _BoolToStr(hasCapability(RSC_VERTEX_PROGRAM)));
DI_INFO(" * Number of float constants for vertex shader: %d", mVertexProgramConstantFloatCount);
DI_INFO(" * Number of int constants for vertex shader: %d", mVertexProgramConstantIntCount);
DI_INFO(" * Number of bool constants for vertex shader: %d", mVertexProgramConstantBoolCount);
DI_INFO(" * Fragment shader: %s", _BoolToStr(hasCapability(RSC_FRAGMENT_PROGRAM)));
DI_INFO(" * Number of float constants for fragment shader: %d", mFragmentProgramConstantFloatCount);
DI_INFO(" * Number of int constants for fragment shader: %d", mFragmentProgramConstantIntCount);
DI_INFO(" * Number of bool constants for fragment shader: %d", mFragmentProgramConstantBoolCount);
DiString profileList = "";
for(ShaderProfiles::iterator iter = mSupportedShaderProfiles.begin(), end = mSupportedShaderProfiles.end();
iter != end; ++iter)
{
profileList += " " + *iter;
}
DI_INFO(" * Supported Shader Profiles: %s", profileList.c_str());
DI_INFO(" * Texture Compression: ", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION)));
if (hasCapability(RSC_TEXTURE_COMPRESSION))
{
DI_INFO(" - DXT: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_DXT)));
DI_INFO(" - VTC: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_VTC)));
DI_INFO(" - PVRTC: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_PVRTC)));
DI_INFO(" - ATC: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_ATC)));
DI_INFO(" - ETC1: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_ETC1)));
DI_INFO(" - ETC2: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_ETC2)));
DI_INFO(" - BC4/BC5: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_BC4_BC5)));
DI_INFO(" - BC6H/BC7: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_BC6H_BC7)));
}
DI_INFO(" * Scissor Rectangle: %s", _BoolToStr(hasCapability(RSC_SCISSOR_TEST)));
DI_INFO(" * Hardware Occlusion Query: %s", _BoolToStr(hasCapability(RSC_HWOCCLUSION)));
DI_INFO(" * User clip planes: %s", _BoolToStr(hasCapability(RSC_USER_CLIP_PLANES)));
DI_INFO(" * VET_UBYTE4 vertex element type: %s", _BoolToStr(hasCapability(RSC_VERTEX_FORMAT_UBYTE4)));
DI_INFO(" * Infinite far plane projection: %s", _BoolToStr(hasCapability(RSC_INFINITE_FAR_PLANE)));
DI_INFO(" * Hardware render-to-texture: %s", _BoolToStr(hasCapability(RSC_HWRENDER_TO_TEXTURE)));
DI_INFO(" * Floating point textures: %s", _BoolToStr(hasCapability(RSC_TEXTURE_FLOAT)));
DI_INFO(" * Non-power-of-two textures: %s %s", _BoolToStr(hasCapability(RSC_NON_POWER_OF_2_TEXTURES)),(mNonPOW2TexturesLimited ? " (limited)" : ""));
DI_INFO(" * 1D textures: %s", _BoolToStr(hasCapability(RSC_TEXTURE_1D)));
DI_INFO(" * 3D textures: %s", _BoolToStr(hasCapability(RSC_TEXTURE_3D)));
DI_INFO(" * Multiple Render Targets: %d", mNumMultiRenderTargets);
DI_INFO(" - With different bit depths: %s", _BoolToStr(hasCapability(RSC_MRT_DIFFERENT_BIT_DEPTHS)));
DI_INFO(" * Vertex texture fetch: %s", _BoolToStr(hasCapability(RSC_VERTEX_TEXTURE_FETCH)));
DI_INFO(" * Number of world matrices: %d", mNumWorldMatrices);
DI_INFO(" * Number of texture units: %d", mNumTextureUnits);
DI_INFO(" * Stencil buffer depth: %d", mStencilBufferBitDepth);
DI_INFO(" * Number of vertex blend matrices: %d", mNumVertexBlendMatrices);
DI_INFO(" * Render to Vertex Buffer : %s", _BoolToStr(hasCapability(RSC_HWRENDER_TO_VERTEX_BUFFER)));
DI_INFO(" * Hardware Atomic Counters: %s", _BoolToStr(hasCapability(RSC_ATOMIC_COUNTERS)));
if (mCategoryRelevant[CAPS_CATEGORY_GL])
{
DI_INFO(" * GL 1.5 without VBO workaround: %s"
, _BoolToStr(hasCapability(RSC_GL1_5_NOVBO)));
DI_INFO(" * Frame Buffer objects: %s"
, _BoolToStr(hasCapability(RSC_FBO)));
DI_INFO(" * Frame Buffer objects (ARB extension): %s"
, _BoolToStr(hasCapability(RSC_FBO_ARB)));
DI_INFO(" * Frame Buffer objects (ATI extension): %s"
, _BoolToStr(hasCapability(RSC_FBO_ATI)));
DI_INFO(" * PBuffer support: %s"
, _BoolToStr(hasCapability(RSC_PBUFFER)));
DI_INFO(" * GL 1.5 without HW-occlusion workaround: %s"
, _BoolToStr(hasCapability(RSC_GL1_5_NOHWOCCLUSION)));
DI_INFO(" * Vertex Array Objects: %s"
, _BoolToStr(hasCapability(RSC_VAO)));
DI_INFO(" * Separate shader objects: %s"
, _BoolToStr(hasCapability(RSC_SEPARATE_SHADER_OBJECTS)));
}
if (mCategoryRelevant[CAPS_CATEGORY_D3D9])
{
DI_INFO(" * DirectX per stage constants: %s", _BoolToStr(hasCapability(RSC_PERSTAGECONSTANT)));
}
}
// -----------------------------------------------------------------------------------------
void CPepeEngineRendererCapabilities::log()
{
LOG("Renderer capabilities");
LOG("-------------------------");
LOG("RenderSystem Name: " + CPepeEngineCore::getSingleton().getRenderer()->getName());
//LOG("GPU Vendor: " + vendorToString(getVendor()));
//LOG("Device Name: " + getDeviceName());
//LOG("Driver Version: " + getDriverVersion().parseString());
LOG(" * Hardware generation of mipmaps: " + CPepeEngineConverter::parseString(hasCapability(RC_AUTOMIPMAP)));
LOG(" * Texture blending: " + CPepeEngineConverter::parseString(hasCapability(RC_BLENDING)));
LOG(" * Anisotropic texture filtering: " + CPepeEngineConverter::parseString(hasCapability(RC_ANISOTROPY)));
LOG(" * Dot product texture operation: " + CPepeEngineConverter::parseString(hasCapability(RC_DOT3)));
LOG(" * Cube mapping: " + CPepeEngineConverter::parseString(hasCapability(RC_CUBEMAPPING)));
LOG(" * Hardware stencil buffer: " + CPepeEngineConverter::parseString(hasCapability(RC_HWSTENCIL)));
if (hasCapability(RC_HWSTENCIL)) {
LOG(" - Stencil depth: " + CPepeEngineConverter::parseString((float)getStencilBufferBitDepth()));
LOG(" - Two sided stencil support: " + CPepeEngineConverter::parseString(hasCapability(RC_TWO_SIDED_STENCIL)));
LOG(" - Wrap stencil values: " + CPepeEngineConverter::parseString(hasCapability(RC_STENCIL_WRAP)));
}
LOG(" * Hardware vertex / index buffers: " + CPepeEngineConverter::parseString(hasCapability(RC_VBO)));
LOG(" * Vertex programs: " + CPepeEngineConverter::parseString(hasCapability(RC_VERTEX_PROGRAM)));
LOG(" - Max vertex program version: " + getMaxVertexProgramVersion());
LOG(" * Pixel programs: " + CPepeEngineConverter::parseString(hasCapability(RC_PIXEL_PROGRAM)));
LOG(" - Max pixel program version: " + getMaxPixelProgramVersion());
LOG(" * Texture Compression: " + CPepeEngineConverter::parseString(hasCapability(RC_TEXTURE_COMPRESSION)));
if (hasCapability(RC_TEXTURE_COMPRESSION)) {
LOG(" - DXT: " + CPepeEngineConverter::parseString(hasCapability(RC_TEXTURE_COMPRESSION_DXT)));
LOG(" - VTC: " + CPepeEngineConverter::parseString(hasCapability(RC_TEXTURE_COMPRESSION_VTC)));
}
LOG(" * Scissor Rectangle: " + CPepeEngineConverter::parseString(hasCapability(RC_SCISSOR_TEST)));
LOG(" * Hardware Occlusion Query: " + CPepeEngineConverter::parseString(hasCapability(RC_HWOCCLUSION)));
LOG(" * User clip planes: " + CPepeEngineConverter::parseString(hasCapability(RC_USER_CLIP_PLANES)));
LOG(" * VET_UBYTE4 vertex element type: " + CPepeEngineConverter::parseString(hasCapability(RC_VERTEX_FORMAT_UBYTE4)));
LOG(" * Infinite far plane projection: " + CPepeEngineConverter::parseString(hasCapability(RC_INFINITE_FAR_PLANE)));
LOG(" * Hardware render-to-texture: " + CPepeEngineConverter::parseString(hasCapability(RC_HWRENDER_TO_TEXTURE)));
LOG(" * Floating point textures: " + CPepeEngineConverter::parseString(hasCapability(RC_TEXTURE_FLOAT)));
LOG(" * Non-power-of-two textures: " + CPepeEngineConverter::parseString(hasCapability(RC_NON_POWER_OF_2_TEXTURES)) + (m_bNonPOW2TexturesLimited ? _T(" (limited)") : _T("")));
LOG(" * Volume textures: " + CPepeEngineConverter::parseString(hasCapability(RC_TEXTURE_3D)));
LOG(" * Multiple Render Targets: " + CPepeEngineConverter::parseString((float)m_nNumMultiRenderTargets));
LOG(" * Point Sprites: " + CPepeEngineConverter::parseString(hasCapability(RC_POINT_SPRITES)));
LOG(" * Extended point parameters: " + CPepeEngineConverter::parseString(hasCapability(RC_POINT_EXTENDED_PARAMETERS)));
LOG(" * Max Point Size: " + CPepeEngineConverter::parseString(m_fMaxPointSize));
LOG(" * Vertex texture fetch: " + CPepeEngineConverter::parseString(hasCapability(RC_VERTEX_TEXTURE_FETCH)));
if (hasCapability(RC_VERTEX_TEXTURE_FETCH)) {
LOG(" - Max vertex textures: " + CPepeEngineConverter::parseString((float)m_nNumVertexTextureUnits));
LOG(" - Vertex textures shared: " + CPepeEngineConverter::parseString(m_bVertexTextureUnitsShared));
}
}