Browse Source

Non Power-of-Two DynamicCapMaps

Epic K'veer floor is now even more epic.
Adam Johnson 12 years ago
parent
commit
f2f1bea345
  1. 74
      Sources/Plasma/PubUtilLib/plPipeline/plDXPipeline.cpp
  2. 49
      Sources/Plasma/PubUtilLib/plPipeline/plDXPipeline.h
  3. 16
      Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.cpp
  4. 1
      Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.h
  5. 18
      Sources/Plasma/PubUtilLib/plPipeline/plRenderTarget.h

74
Sources/Plasma/PubUtilLib/plPipeline/plDXPipeline.cpp

@ -1008,33 +1008,38 @@ void plDXPipeline::ISetCaps()
fSettings.fD3DCaps = kCapsNone; fSettings.fD3DCaps = kCapsNone;
// Set relevant caps (ones we can do something about). // Set relevant caps (ones we can do something about).
if( fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_DEPTHBIAS ) if (fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_DEPTHBIAS)
fSettings.fD3DCaps |= kCapsZBias; fSettings.fD3DCaps |= kCapsZBias;
if( fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_FOGRANGE ) if (fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_FOGRANGE)
fSettings.fD3DCaps |= kCapsRangeFog; fSettings.fD3DCaps |= kCapsRangeFog;
if( fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_FOGTABLE ) if (fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_FOGTABLE)
fSettings.fD3DCaps |= kCapsLinearFog | kCapsExpFog | kCapsExp2Fog | kCapsPixelFog; fSettings.fD3DCaps |= kCapsLinearFog | kCapsExpFog | kCapsExp2Fog | kCapsPixelFog;
else else
fSettings.fD3DCaps |= kCapsLinearFog; fSettings.fD3DCaps |= kCapsLinearFog;
if( fCurrentDevice->fDDCaps.TextureFilterCaps & D3DPTFILTERCAPS_MIPFLINEAR ) if (fCurrentDevice->fDDCaps.TextureFilterCaps & D3DPTFILTERCAPS_MIPFLINEAR)
fSettings.fD3DCaps |= kCapsMipmap; fSettings.fD3DCaps |= kCapsMipmap;
if( fCurrentDevice->fDDCaps.TextureCaps & D3DPTEXTURECAPS_MIPCUBEMAP ) if (fCurrentDevice->fDDCaps.TextureCaps & D3DPTEXTURECAPS_MIPCUBEMAP)
fSettings.fD3DCaps |= kCapsCubicMipmap; fSettings.fD3DCaps |= kCapsCubicMipmap;
if( fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_WBUFFER ) if (fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_WBUFFER)
fSettings.fD3DCaps |= kCapsWBuffer; fSettings.fD3DCaps |= kCapsWBuffer;
if( fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_DITHER ) if (fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_DITHER)
fSettings.fD3DCaps |= kCapsDither; fSettings.fD3DCaps |= kCapsDither;
if( fSettings.fNumAASamples > 0 ) if (fSettings.fNumAASamples > 0)
fSettings.fD3DCaps |= kCapsFSAntiAlias; fSettings.fD3DCaps |= kCapsFSAntiAlias;
if( fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_WFOG ) if (fCurrentDevice->fDDCaps.RasterCaps & D3DPRASTERCAPS_WFOG)
fSettings.fD3DCaps |= kCapsDoesWFog; fSettings.fD3DCaps |= kCapsDoesWFog;
if( fCurrentDevice->fDDCaps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP ) if (fCurrentDevice->fDDCaps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP)
fSettings.fD3DCaps |= kCapsCubicTextures; fSettings.fD3DCaps |= kCapsCubicTextures;
// Unconditional Non-Power of Two Textures
// To make life easy for us, we can have non POT textures or we can't
if (!(fCurrentDevice->fDDCaps.TextureCaps & D3DPTEXTURECAPS_POW2 &&
fCurrentDevice->fDDCaps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL))
fSettings.fD3DCaps |= kCapsNpotTextures;
/// New 1.5.2000 - cull out mixed vertex processing /// New 1.5.2000 - cull out mixed vertex processing
if( fCurrentDevice->fDDCaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT if (fCurrentDevice->fDDCaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT &&
&& fCurrentMode->fDDBehavior == D3DCREATE_HARDWARE_VERTEXPROCESSING fCurrentMode->fDDBehavior == D3DCREATE_HARDWARE_VERTEXPROCESSING)
)
fSettings.fD3DCaps |= kCapsHWTransform; fSettings.fD3DCaps |= kCapsHWTransform;
@ -1046,14 +1051,14 @@ void plDXPipeline::ISetCaps()
fSettings.fD3DCaps |= kCapsDoesSmallTextures; fSettings.fD3DCaps |= kCapsDoesSmallTextures;
/// Look for supported texture formats /// Look for supported texture formats
if( IFindCompressedFormats() ) if ( IFindCompressedFormats() )
fSettings.fD3DCaps |= kCapsCompressTextures; fSettings.fD3DCaps |= kCapsCompressTextures;
if( IFindLuminanceFormats() ) if ( IFindLuminanceFormats() )
fSettings.fD3DCaps |= kCapsLuminanceTextures; fSettings.fD3DCaps |= kCapsLuminanceTextures;
/// Max # of hardware lights /// Max # of hardware lights
fSettings.fMaxNumLights = fCurrentDevice->fDDCaps.MaxActiveLights; fSettings.fMaxNumLights = fCurrentDevice->fDDCaps.MaxActiveLights;
if( fSettings.fMaxNumLights > kD3DMaxTotalLights ) if ( fSettings.fMaxNumLights > kD3DMaxTotalLights )
fSettings.fMaxNumLights = kD3DMaxTotalLights; fSettings.fMaxNumLights = kD3DMaxTotalLights;
// Intel Extreme chips report 0 lights, meaning T&L is done // Intel Extreme chips report 0 lights, meaning T&L is done
@ -1062,7 +1067,7 @@ void plDXPipeline::ISetCaps()
// since the extreme can't really afford them, and record // since the extreme can't really afford them, and record
// the fact this is the extreme for other driver problem // the fact this is the extreme for other driver problem
// workarounds. // workarounds.
if( !fSettings.fMaxNumLights ) if ( !fSettings.fMaxNumLights )
{ {
fSettings.fMaxNumLights = kD3DMaxTotalLights; fSettings.fMaxNumLights = kD3DMaxTotalLights;
fSettings.fIsIntel = true; fSettings.fIsIntel = true;
@ -1071,7 +1076,7 @@ void plDXPipeline::ISetCaps()
/// Max # of textures at once /// Max # of textures at once
fSettings.fMaxLayersAtOnce = fCurrentDevice->fDDCaps.MaxSimultaneousTextures; fSettings.fMaxLayersAtOnce = fCurrentDevice->fDDCaps.MaxSimultaneousTextures;
if( fCurrentDevice->fDDCaps.DevCaps & D3DDEVCAPS_SEPARATETEXTUREMEMORIES ) if ( fCurrentDevice->fDDCaps.DevCaps & D3DDEVCAPS_SEPARATETEXTUREMEMORIES )
fSettings.fMaxLayersAtOnce = 1; fSettings.fMaxLayersAtOnce = 1;
// Alloc half our simultaneous textures to piggybacks. // Alloc half our simultaneous textures to piggybacks.
// Won't hurt us unless we try to many things at once. // Won't hurt us unless we try to many things at once.
@ -4390,14 +4395,20 @@ hsGDeviceRef *plDXPipeline::MakeRenderTargetRef( plRenderTarget *owner )
IDirect3DCubeTexture9 *cTexture = nil; IDirect3DCubeTexture9 *cTexture = nil;
D3DFORMAT surfFormat = D3DFMT_UNKNOWN, depthFormat = D3DFMT_UNKNOWN; D3DFORMAT surfFormat = D3DFMT_UNKNOWN, depthFormat = D3DFMT_UNKNOWN;
D3DRESOURCETYPE resType; D3DRESOURCETYPE resType;
int i;
plCubicRenderTarget *cubicRT; plCubicRenderTarget *cubicRT;
uint16_t width, height;
hsAssert(!fManagedAlloced, "Allocating non-managed resource with managed resources alloc'd"); hsAssert(!fManagedAlloced, "Allocating non-managed resource with managed resources alloc'd");
// If we have Shader Model 3 and support non-POT textures, let's make reflections the pipe size
plDynamicCamMap* camMap = plDynamicCamMap::ConvertNoRef(owner);
if (camMap)
{
if ((plQuality::GetCapability() > plQuality::kPS_2) && fSettings.fD3DCaps & kCapsNpotTextures)
camMap->ResizeViewport(IGetViewTransform());
}
/// Check--is this renderTarget really a child of a cubicRenderTarget? /// Check--is this renderTarget really a child of a cubicRenderTarget?
if( owner->GetParent() != nil ) if( owner->GetParent() )
{ {
/// This'll create the deviceRefs for all of its children as well /// This'll create the deviceRefs for all of its children as well
MakeRenderTargetRef( owner->GetParent() ); MakeRenderTargetRef( owner->GetParent() );
@ -4405,7 +4416,7 @@ hsGDeviceRef *plDXPipeline::MakeRenderTargetRef( plRenderTarget *owner )
} }
// If we already have a rendertargetref, we just need it filled out with D3D resources. // If we already have a rendertargetref, we just need it filled out with D3D resources.
if( owner->GetDeviceRef() != nil ) if( owner->GetDeviceRef() )
ref = (plDXRenderTargetRef *)owner->GetDeviceRef(); ref = (plDXRenderTargetRef *)owner->GetDeviceRef();
// Look for supported format. Note that the surfFormat and depthFormat are // Look for supported format. Note that the surfFormat and depthFormat are
@ -4417,7 +4428,6 @@ hsGDeviceRef *plDXPipeline::MakeRenderTargetRef( plRenderTarget *owner )
return nil; return nil;
} }
/// Create the render target now /// Create the render target now
// Start with the depth surface. // Start with the depth surface.
// Note that we only ever give a cubic rendertarget a single shared depth buffer, // Note that we only ever give a cubic rendertarget a single shared depth buffer,
@ -4467,10 +4477,10 @@ hsGDeviceRef *plDXPipeline::MakeRenderTargetRef( plRenderTarget *owner )
// See if it's a cubic render target. // See if it's a cubic render target.
// Primary consumer here is the vertex/pixel shader water. // Primary consumer here is the vertex/pixel shader water.
cubicRT = plCubicRenderTarget::ConvertNoRef( owner ); cubicRT = plCubicRenderTarget::ConvertNoRef( owner );
if( cubicRT != nil ) if( cubicRT )
{ {
/// And create the ref (it'll know how to set all the flags) /// And create the ref (it'll know how to set all the flags)
if( ref != nil ) if( ref )
ref->Set( surfFormat, 0, owner ); ref->Set( surfFormat, 0, owner );
else else
ref = new plDXRenderTargetRef( surfFormat, 0, owner ); ref = new plDXRenderTargetRef( surfFormat, 0, owner );
@ -4479,7 +4489,7 @@ hsGDeviceRef *plDXPipeline::MakeRenderTargetRef( plRenderTarget *owner )
D3DPOOL_DEFAULT, (IDirect3DCubeTexture9 **)&cTexture, NULL ) ) ) D3DPOOL_DEFAULT, (IDirect3DCubeTexture9 **)&cTexture, NULL ) ) )
{ {
/// Create a CUBIC texture /// Create a CUBIC texture
for( i = 0; i < 6; i++ ) for( int i = 0; i < 6; i++ )
{ {
plRenderTarget *face = cubicRT->GetFace( i ); plRenderTarget *face = cubicRT->GetFace( i );
plDXRenderTargetRef *fRef; plDXRenderTargetRef *fRef;
@ -4516,7 +4526,7 @@ hsGDeviceRef *plDXPipeline::MakeRenderTargetRef( plRenderTarget *owner )
else if( owner->GetFlags() & plRenderTarget::kIsTexture ) else if( owner->GetFlags() & plRenderTarget::kIsTexture )
{ {
/// Create a normal texture /// Create a normal texture
if( ref != nil ) if( ref )
ref->Set( surfFormat, 0, owner ); ref->Set( surfFormat, 0, owner );
else else
ref = new plDXRenderTargetRef( surfFormat, 0, owner ); ref = new plDXRenderTargetRef( surfFormat, 0, owner );
@ -4546,19 +4556,16 @@ hsGDeviceRef *plDXPipeline::MakeRenderTargetRef( plRenderTarget *owner )
else if( owner->GetFlags() & plRenderTarget::kIsOffscreen ) else if( owner->GetFlags() & plRenderTarget::kIsOffscreen )
{ {
/// Create a blank surface /// Create a blank surface
if( ref != nil ) if( ref )
ref->Set( surfFormat, 0, owner ); ref->Set( surfFormat, 0, owner );
else else
ref = new plDXRenderTargetRef( surfFormat, 0, owner ); ref = new plDXRenderTargetRef( surfFormat, 0, owner );
width = owner->GetWidth();
height = owner->GetHeight();
// Specify true for lockable, otherwise I'm not sure what we'd do with it. I guess we // Specify true for lockable, otherwise I'm not sure what we'd do with it. I guess we
// could copyrect to another surface, presumably a texture. But right now the only // could copyrect to another surface, presumably a texture. But right now the only
// thing we use this for is to render a snapshot and copy it to sysmem, which implies // thing we use this for is to render a snapshot and copy it to sysmem, which implies
// lockable. // lockable.
if( !FAILED( fD3DDevice->CreateRenderTarget( width, height, surfFormat, if( !FAILED( fD3DDevice->CreateRenderTarget( owner->GetWidth(), owner->GetHeight(), surfFormat,
D3DMULTISAMPLE_NONE, 0, D3DMULTISAMPLE_NONE, 0,
TRUE, &surface, NULL ) ) ) TRUE, &surface, NULL ) ) )
{ {
@ -4810,6 +4817,8 @@ bool plDXPipeline::IPrepRenderTargetInfo( plRenderTarget *owner, D3DFORMAT &sur
if( flags & plRenderTarget::kIsTexture ) if( flags & plRenderTarget::kIsTexture )
{ {
/// Do an extra check for width and height here /// Do an extra check for width and height here
if (!(fSettings.fD3DCaps & kCapsNpotTextures))
{
for( i = width >> 1, j = 0; i != 0; i >>= 1, j++ ); for( i = width >> 1, j = 0; i != 0; i >>= 1, j++ );
if( width != ( 1 << j ) ) if( width != ( 1 << j ) )
return false; return false;
@ -4817,6 +4826,7 @@ bool plDXPipeline::IPrepRenderTargetInfo( plRenderTarget *owner, D3DFORMAT &sur
for( i = height >> 1, j = 0; i != 0; i >>= 1, j++ ); for( i = height >> 1, j = 0; i != 0; i >>= 1, j++ );
if( height!= ( 1 << j ) ) if( height!= ( 1 << j ) )
return false; return false;
}
resType = D3DRTYPE_TEXTURE; resType = D3DRTYPE_TEXTURE;
} }

49
Sources/Plasma/PubUtilLib/plPipeline/plDXPipeline.h

@ -177,30 +177,31 @@ class plDXPipeline : public plPipeline
{ {
protected: protected:
enum { enum {
kCapsNone = 0x0, kCapsNone = 0x00000000,
kCapsCompressTextures = 0x1, kCapsCompressTextures = 0x00000001,
kCapsMipmap = 0x2, kCapsMipmap = 0x00000002,
kCapsHWTransform = 0x4, kCapsHWTransform = 0x00000004,
kCapsHWLighting = 0x8, kCapsHWLighting = 0x00000008,
kCapsZBias = 0x10, kCapsZBias = 0x00000010,
kCapsLinearFog = 0x20, kCapsLinearFog = 0x00000020,
kCapsExpFog = 0x40, kCapsExpFog = 0x00000040,
kCapsExp2Fog = 0x80, kCapsExp2Fog = 0x00000080,
kCapsRangeFog = 0x100, kCapsRangeFog = 0x00000100,
kCapsWBuffer = 0x200, kCapsWBuffer = 0x00000200,
kCapsTexBoundToStage = 0x400, kCapsTexBoundToStage = 0x00000400,
kCapsDither = 0x800, kCapsDither = 0x00000800,
kCapsLODWatch = 0x1000, kCapsLODWatch = 0x00001000,
kCapsFSAntiAlias = 0x2000, kCapsFSAntiAlias = 0x00002000,
kCapsLuminanceTextures = 0x4000, kCapsLuminanceTextures = 0x00004000,
kCapsDoesSmallTextures = 0x8000, kCapsDoesSmallTextures = 0x00008000,
kCapsDoesWFog = 0x10000, kCapsDoesWFog = 0x00010000,
kCapsPixelFog = 0x20000, kCapsPixelFog = 0x00020000,
kCapsHasBadYonStuff = 0x40000, kCapsHasBadYonStuff = 0x00040000,
kCapsNoKindaSmallTexs = 0x80000, kCapsNoKindaSmallTexs = 0x00080000,
kCapsNpotTextures = 0x00100000,
kCapsCubicTextures = 0x200000,
kCapsCubicMipmap = 0x400000 kCapsCubicTextures = 0x00200000,
kCapsCubicMipmap = 0x00400000
}; };
enum { enum {
kKNone = 0x0, kKNone = 0x0,

16
Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.cpp

@ -537,6 +537,22 @@ void plDynamicCamMap::Init()
plgDispatch::Dispatch()->RegisterForExactType(plRenderMsg::Index(), GetKey()); plgDispatch::Dispatch()->RegisterForExactType(plRenderMsg::Index(), GetKey());
} }
void plDynamicCamMap::ResizeViewport(const plViewTransform& vt)
{
if (!fProportionalViewport)
{
fWidth = vt.GetViewPortWidth();
fHeight = vt.GetViewPortHeight();
fViewport.fAbsolute.fBottom = vt.GetViewPortBottom();
fViewport.fAbsolute.fLeft = vt.GetViewPortLeft();
fViewport.fAbsolute.fRight = vt.GetViewPortRight();
fViewport.fAbsolute.fTop = vt.GetViewPortTop();
fReq.SetViewTransform(vt);
}
}
void plDynamicCamMap::SetRefreshRate(float secs) void plDynamicCamMap::SetRefreshRate(float secs)
{ {
fRefreshRate = secs; fRefreshRate = secs;

1
Sources/Plasma/PubUtilLib/plPipeline/plDynamicEnvMap.h

@ -210,6 +210,7 @@ public:
void ReRender(); void ReRender();
void Init(); void Init();
void ResizeViewport(const plViewTransform& vt);
void SetIncludeCharacters(bool b); void SetIncludeCharacters(bool b);
void SetRefreshRate(float secs); void SetRefreshRate(float secs);

18
Sources/Plasma/PubUtilLib/plPipeline/plRenderTarget.h

@ -89,7 +89,7 @@ class plRenderTarget : public plBitmap
bool fProportionalViewport; bool fProportionalViewport;
uint8_t fZDepth, fStencilDepth; uint8_t fZDepth, fStencilDepth;
plCubicRenderTarget *fParent; plCubicRenderTarget* fParent;
virtual void SetKey(plKey k); virtual void SetKey(plKey k);
@ -101,18 +101,12 @@ class plRenderTarget : public plBitmap
GETINTERFACE_ANY( plRenderTarget, plBitmap ); GETINTERFACE_ANY( plRenderTarget, plBitmap );
plRenderTarget() plRenderTarget()
: fWidth(0), fHeight(0), fZDepth(0), fStencilDepth(0), fApplyTexQuality(false),
fProportionalViewport(true), fParent(nullptr)
{ {
fWidth = 0; fFlags = 0;
fHeight = 0;
fPixelSize = 0; fPixelSize = 0;
fZDepth = 0;
fStencilDepth = 0;
fApplyTexQuality = false;
fProportionalViewport = true;
SetViewport( 0, 0, 1.f, 1.f ); SetViewport( 0, 0, 1.f, 1.f );
fFlags = 0;
fParent = nil;
plPipeResReq::Request(); plPipeResReq::Request();
} }
@ -175,8 +169,8 @@ class plRenderTarget : public plBitmap
fViewport.fProportional.fBottom = bottom; fViewport.fProportional.fBottom = bottom;
} }
uint16_t GetWidth( void ) { return fWidth; } uint16_t GetWidth( void ) const { return fWidth; }
uint16_t GetHeight( void ) { return fHeight; } uint16_t GetHeight( void ) const { return fHeight; }
uint8_t GetZDepth( void ) { return fZDepth; } uint8_t GetZDepth( void ) { return fZDepth; }
uint8_t GetStencilDepth( void ) { return fStencilDepth; } uint8_t GetStencilDepth( void ) { return fStencilDepth; }

Loading…
Cancel
Save