OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
Browse Source

Non Power-of-Two DynamicCapMaps 

Epic K'veer floor is now even more epic.
Adam Johnson 12 years ago
parent
3fb5f33517
commit
f2f1bea345
5 changed files with 103 additions and 81 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 96
      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. 22
      Sources/Plasma/PubUtilLib/plPipeline/plRenderTarget.h

96
Sources/Plasma/PubUtilLib/plPipeline/plDXPipeline.cpp
Unescape View File

@ -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,19 +4477,19 @@ 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 );
if( !FAILED( fD3DDevice->CreateCubeTexture( owner->GetWidth(), 1, D3DUSAGE_RENDERTARGET, surfFormat, if( !FAILED( fD3DDevice->CreateCubeTexture( owner->GetWidth(), 1, D3DUSAGE_RENDERTARGET, surfFormat,
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;
@ -4499,7 +4509,7 @@ hsGDeviceRef *plDXPipeline::MakeRenderTargetRef( plRenderTarget *owner )
hsRefCnt_SafeUnRef( face->GetDeviceRef() ); hsRefCnt_SafeUnRef( face->GetDeviceRef() );
} }
} }
D3DSURF_MEMNEW(cTexture); D3DSURF_MEMNEW(cTexture);
ref->SetTexture( cTexture, depthSurface ); ref->SetTexture( cTexture, depthSurface );
@ -4516,12 +4526,12 @@ 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 );
if( !FAILED( fD3DDevice->CreateTexture( owner->GetWidth(), owner->GetHeight(), 1, D3DUSAGE_RENDERTARGET, surfFormat, if( !FAILED( fD3DDevice->CreateTexture( owner->GetWidth(), owner->GetHeight(), 1, D3DUSAGE_RENDERTARGET, surfFormat,
D3DPOOL_DEFAULT, (IDirect3DTexture9 **)&texture, NULL ) ) ) D3DPOOL_DEFAULT, (IDirect3DTexture9 **)&texture, NULL ) ) )
{ {
D3DSURF_MEMNEW(texture); D3DSURF_MEMNEW(texture);
@ -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 ) ) )
{ {
@ -4674,7 +4681,7 @@ hsGDeviceRef* plDXPipeline::SharedRenderTargetRef(plRenderTarget* share, plRende
ref = new plDXRenderTargetRef( surfFormat, 0, owner ); ref = new plDXRenderTargetRef( surfFormat, 0, owner );
hsAssert(!fManagedAlloced, "Alloc default with managed alloc'd"); hsAssert(!fManagedAlloced, "Alloc default with managed alloc'd");
if( !FAILED( fD3DDevice->CreateCubeTexture( owner->GetWidth(), 1, D3DUSAGE_RENDERTARGET, surfFormat, if( !FAILED( fD3DDevice->CreateCubeTexture( owner->GetWidth(), 1, D3DUSAGE_RENDERTARGET, surfFormat,
D3DPOOL_DEFAULT, (IDirect3DCubeTexture9 **)&cTexture, NULL ) ) ) D3DPOOL_DEFAULT, (IDirect3DCubeTexture9 **)&cTexture, NULL ) ) )
{ {
@ -4810,13 +4817,16 @@ 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
for( i = width >> 1, j = 0; i != 0; i >>= 1, j++ ); if (!(fSettings.fD3DCaps & kCapsNpotTextures))
if( width != ( 1 << j ) ) {
return false; for( i = width >> 1, j = 0; i != 0; i >>= 1, j++ );
if( width != ( 1 << j ) )
return false;
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
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

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

22
Sources/Plasma/PubUtilLib/plPipeline/plRenderTarget.h
Unescape View File

@ -87,9 +87,9 @@ class plRenderTarget : public plBitmap
bool fApplyTexQuality; bool fApplyTexQuality;
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; }

Write Preview
Loading…
Cancel
Save