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. 44
      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. 16
      Sources/Plasma/PubUtilLib/plPipeline/plRenderTarget.h

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

@ -1031,10 +1031,15 @@ void plDXPipeline::ISetCaps()
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;
@ -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);

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

@ -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