//========== Copyright (c) Valve Corporation, All rights reserved. ======== // // Purpose: // //============================================================================= #include "pch_materialsystem.h" #ifndef _PS3 #define MATSYS_INTERNAL #endif #include "cmatlightmaps.h" #include "colorspace.h" #include "IHardwareConfigInternal.h" #include "cmaterialsystem.h" // NOTE: This must be the last file included!!! #include "tier0/memdbgon.h" #include "bitmap/floatbitmap.h" static ConVar mat_lightmap_pfms( "mat_lightmap_pfms", "0", FCVAR_MATERIAL_SYSTEM_THREAD, "Outputs .pfm files containing lightmap data for each lightmap page when a level exits." ); // Write PFM files for each lightmap page in the game directory when exiting a level // Turning off 32 bit lightmaps for Portal 2, to save shader perf --Thorsten //#define USE_32BIT_LIGHTMAPS_ON_360 //uncomment to use 32bit lightmaps, be sure to keep this in sync with the same #define in stdshaders/lightmappedgeneric_ps2_3_x.h #ifdef _X360 // 7LS - fixup support for lightmap alpha channel data for csm's, definitely do this when/if turning dynamic lightmaps back on // #define X360_USE_SIMD_LIGHTMAP #endif //----------------------------------------------------------------------------- inline IMaterialInternal* CMatLightmaps::GetCurrentMaterialInternal() const { return GetMaterialSystem()->GetRenderContextInternal()->GetCurrentMaterialInternal(); } inline void CMatLightmaps::SetCurrentMaterialInternal(IMaterialInternal* pCurrentMaterial) { return GetMaterialSystem()->GetRenderContextInternal()->SetCurrentMaterialInternal( pCurrentMaterial ); } inline IMaterialInternal *CMatLightmaps::GetMaterialInternal( MaterialHandle_t idx ) const { return GetMaterialSystem()->GetMaterialInternal( idx ); } inline const IMatRenderContextInternal *CMatLightmaps::GetRenderContextInternal() const { return GetMaterialSystem()->GetRenderContextInternal(); } inline IMatRenderContextInternal *CMatLightmaps::GetRenderContextInternal() { return GetMaterialSystem()->GetRenderContextInternal(); } inline const CMaterialDict *CMatLightmaps::GetMaterialDict() const { return GetMaterialSystem()->GetMaterialDict(); } inline CMaterialDict *CMatLightmaps::GetMaterialDict() { return GetMaterialSystem()->GetMaterialDict(); } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- CMatLightmaps::CMatLightmaps() { m_currentWhiteLightmapMaterial = NULL; m_pLightmapPages = NULL; m_NumLightmapPages = 0; m_numSortIDs = 0; m_nUpdatingLightmapsStackDepth = 0; m_nLockedLightmap = -1; m_pLightmapDataPtrArray = NULL; m_eLightmapsState = STATE_DEFAULT; } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void CMatLightmaps::Shutdown( ) { // Clean up all lightmaps CleanupLightmaps(); } //----------------------------------------------------------------------------- // Assign enumeration IDs to all materials //----------------------------------------------------------------------------- void CMatLightmaps::EnumerateMaterials( void ) { // iterate in sorted order int id = 0; for (MaterialHandle_t i = GetMaterialDict()->FirstMaterial(); i != GetMaterialDict()->InvalidMaterial(); i = GetMaterialDict()->NextMaterial(i) ) { GetMaterialInternal(i)->SetEnumerationID( id ); ++id; } } //----------------------------------------------------------------------------- // Gets the maximum lightmap page size... //----------------------------------------------------------------------------- int CMatLightmaps::GetMaxLightmapPageWidth() const { // FIXME: It's unclear which we want here. // It doesn't drastically increase primitives per DrawIndexedPrimitive // call at the moment to increase it, so let's not for now. // If we're using dynamic textures though, we want bigger that's for sure. // The tradeoff here is how much memory we waste if we don't fill the lightmap // We need to go to 512x256 textures because that's the only way bumped // lighting on displacements can work given the 128x128 allowance.. int nWidth = 512; if ( nWidth > HardwareConfig()->MaxTextureWidth() ) nWidth = HardwareConfig()->MaxTextureWidth(); return nWidth; } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- int CMatLightmaps::GetMaxLightmapPageHeight() const { int nHeight = 256; if ( nHeight > HardwareConfig()->MaxTextureHeight() ) nHeight = HardwareConfig()->MaxTextureHeight(); return nHeight; } //----------------------------------------------------------------------------- // Returns the lightmap page size //----------------------------------------------------------------------------- void CMatLightmaps::GetLightmapPageSize( int lightmapPageID, int *pWidth, int *pHeight ) const { switch( lightmapPageID ) { default: Assert( lightmapPageID >= 0 && lightmapPageID < GetNumLightmapPages() ); *pWidth = m_pLightmapPages[lightmapPageID].m_Width; *pHeight = m_pLightmapPages[lightmapPageID].m_Height; break; case MATERIAL_SYSTEM_LIGHTMAP_PAGE_USER_DEFINED: *pWidth = *pHeight = 1; AssertOnce( !"Can't use CMatLightmaps to get properties of MATERIAL_SYSTEM_LIGHTMAP_PAGE_USER_DEFINED" ); break; case MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE: case MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP: *pWidth = *pHeight = 1; break; } } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- int CMatLightmaps::GetLightmapWidth( int lightmapPageID ) const { switch( lightmapPageID ) { default: Assert( lightmapPageID >= 0 && lightmapPageID < GetNumLightmapPages() ); return m_pLightmapPages[lightmapPageID].m_Width; case MATERIAL_SYSTEM_LIGHTMAP_PAGE_USER_DEFINED: AssertOnce( !"Can't use CMatLightmaps to get properties of MATERIAL_SYSTEM_LIGHTMAP_PAGE_USER_DEFINED" ); return 1; case MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE: case MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP: return 1; } } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- int CMatLightmaps::GetLightmapHeight( int lightmapPageID ) const { switch( lightmapPageID ) { default: Assert( lightmapPageID >= 0 && lightmapPageID < GetNumLightmapPages() ); return m_pLightmapPages[lightmapPageID].m_Height; case MATERIAL_SYSTEM_LIGHTMAP_PAGE_USER_DEFINED: AssertOnce( !"Can't use CMatLightmaps to get properties of MATERIAL_SYSTEM_LIGHTMAP_PAGE_USER_DEFINED" ); return 1; case MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE: case MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP: return 1; } } //----------------------------------------------------------------------------- // Clean up lightmap pages. //----------------------------------------------------------------------------- void CMatLightmaps::CleanupLightmaps() { GetMaterialSystem()->GetPaintmaps()->CleanupPaintmaps(); if ( mat_lightmap_pfms.GetBool()) { // Write PFM files containing lightmap data for this page for (int lightmap = 0; lightmap < GetNumLightmapPages(); lightmap++) { if ((NULL != m_pLightmapDataPtrArray) && (NULL != m_pLightmapDataPtrArray[lightmap])) { char szPFMFileName[MAX_PATH]; sprintf(szPFMFileName, "Lightmap-Page-%d.pfm", lightmap); m_pLightmapDataPtrArray[lightmap]->WritePFM(szPFMFileName); } } } // Remove the lightmap data bitmap representations if (m_pLightmapDataPtrArray) { int i; for( i = 0; i < GetNumLightmapPages(); i++ ) { delete m_pLightmapDataPtrArray[i]; } delete [] m_pLightmapDataPtrArray; m_pLightmapDataPtrArray = NULL; } // delete old lightmap pages if( m_pLightmapPages ) { int i; for( i = 0; i < GetNumLightmapPages(); i++ ) { g_pShaderAPI->DeleteTexture( m_LightmapPageTextureHandles[i] ); } delete [] m_pLightmapPages; m_pLightmapPages = 0; } m_NumLightmapPages = 0; } //----------------------------------------------------------------------------- // Resets the lightmap page info for each material //----------------------------------------------------------------------------- void CMatLightmaps::ResetMaterialLightmapPageInfo( void ) { for (MaterialHandle_t i = GetMaterialDict()->FirstMaterial(); i != GetMaterialDict()->InvalidMaterial(); i = GetMaterialDict()->NextMaterial(i) ) { IMaterialInternal *pMaterial = GetMaterialInternal(i); pMaterial->SetMinLightmapPageID( 9999 ); pMaterial->SetMaxLightmapPageID( -9999 ); pMaterial->SetNeedsWhiteLightmap( false ); } } //----------------------------------------------------------------------------- // This is called before any lightmap allocations take place //----------------------------------------------------------------------------- void CMatLightmaps::BeginLightmapAllocation() { // we clean up lightmaps on console right before we load the next map if ( IsPC() ) { CleanupLightmaps(); } m_ImagePackers.RemoveAll(); int i = m_ImagePackers.AddToTail(); m_ImagePackers[i].Reset( 0, GetMaxLightmapPageWidth(), GetMaxLightmapPageHeight() ); SetCurrentMaterialInternal(0); m_currentWhiteLightmapMaterial = 0; m_numSortIDs = 0; // need to set the min and max sorting id number for each material to // a default value that basically means that it hasn't been used yet. ResetMaterialLightmapPageInfo(); EnumerateMaterials(); } //----------------------------------------------------------------------------- // Allocates space in the lightmaps; must be called after BeginLightmapAllocation //----------------------------------------------------------------------------- int CMatLightmaps::AllocateLightmap( int width, int height, int offsetIntoLightmapPage[2], IMaterial *iMaterial ) { IMaterialInternal *pMaterial = static_cast( iMaterial ); if ( !pMaterial ) { Warning( "Programming error: CMatRenderContext::AllocateLightmap: NULL material\n" ); return m_numSortIDs; } pMaterial = pMaterial->GetRealTimeVersion(); //always work with the real time versions of materials internally // material change int i; int nPackCount = m_ImagePackers.Count(); if ( GetCurrentMaterialInternal() != pMaterial ) { // If this happens, then we need to close out all image packers other than // the last one so as to produce as few sort IDs as possible for ( i = nPackCount - 1; --i >= 0; ) { // NOTE: We *must* use the order preserving one here so the remaining one // is the last lightmap m_ImagePackers.Remove( i ); --nPackCount; } // If it's not the first material, increment the sort id if (GetCurrentMaterialInternal()) { m_ImagePackers[0].IncrementSortId( ); ++m_numSortIDs; } SetCurrentMaterialInternal(pMaterial); // This assertion guarantees we don't see the same material twice in this loop. Assert( pMaterial->GetMinLightmapPageID( ) > pMaterial->GetMaxLightmapPageID() ); // NOTE: We may not use this lightmap page, but we might // we won't know for sure until the next material is passed in. // So, for now, we're going to forcibly add the current lightmap // page to this material so the sort IDs work out correctly. GetCurrentMaterialInternal()->SetMinLightmapPageID( GetNumLightmapPages() ); GetCurrentMaterialInternal()->SetMaxLightmapPageID( GetNumLightmapPages() ); } // Try to add it to any of the current images... bool bAdded = false; for ( i = 0; i < nPackCount; ++i ) { bAdded = m_ImagePackers[i].AddBlock( width, height, &offsetIntoLightmapPage[0], &offsetIntoLightmapPage[1] ); if ( bAdded ) break; } if ( !bAdded ) { ++m_numSortIDs; i = m_ImagePackers.AddToTail(); m_ImagePackers[i].Reset( m_numSortIDs, GetMaxLightmapPageWidth(), GetMaxLightmapPageHeight() ); ++m_NumLightmapPages; if ( !m_ImagePackers[i].AddBlock( width, height, &offsetIntoLightmapPage[0], &offsetIntoLightmapPage[1] ) ) { Error( "MaterialSystem_Interface_t::AllocateLightmap: lightmap (%dx%d) too big to fit in page (%dx%d)\n", width, height, GetMaxLightmapPageWidth(), GetMaxLightmapPageHeight() ); } // Add this lightmap to the material... GetCurrentMaterialInternal()->SetMaxLightmapPageID( GetNumLightmapPages() ); } return m_ImagePackers[i].GetSortId(); } // UNDONE: This needs testing, but it appears as though creating these textures managed // results in huge stalls whenever they are locked for modify. // That makes sense given the d3d docs, but these have been flagged as managed for quite some time. #define DYNAMIC_TEXTURES_NO_BACKING 1 void CMatLightmaps::EndLightmapAllocation() { // count the last page that we were on.if it wasn't // and count the last sortID that we were on m_NumLightmapPages++; m_numSortIDs++; m_firstDynamicLightmap = m_NumLightmapPages; // UNDONE: Until we start using the separate dynamic lighting textures don't allocate them // NOTE: Enable this if we want to stop locking the base lightmaps and instead only lock update // these completely dynamic pages // m_NumLightmapPages += COUNT_DYNAMIC_LIGHTMAP_PAGES; m_dynamic.Init(); // Compute the dimensions of the last lightmap int lastLightmapPageWidth, lastLightmapPageHeight; int nLastIdx = m_ImagePackers.Count(); m_ImagePackers[nLastIdx - 1].GetMinimumDimensions( &lastLightmapPageWidth, &lastLightmapPageHeight ); m_ImagePackers.Purge(); m_pLightmapPages = new LightmapPageInfo_t[GetNumLightmapPages()]; Assert( m_pLightmapPages ); if ( mat_lightmap_pfms.GetBool()) { // This array will be used to write PFM files full of lightmap data m_pLightmapDataPtrArray = new FloatBitMap_t*[GetNumLightmapPages()]; } if( GetMaterialSystem()->GetPaintmaps()->IsEnabled() ) { GetMaterialSystem()->GetPaintmaps()->BeginPaintTextureAllocation( GetNumLightmapPages() ); } int i; m_LightmapPageTextureHandles.EnsureCapacity( GetNumLightmapPages() ); for ( i = 0; i < GetNumLightmapPages(); i++ ) { // Compute lightmap dimensions bool lastStaticLightmap = ( i == (m_firstDynamicLightmap-1)); m_pLightmapPages[i].m_Width = (unsigned short)(lastStaticLightmap ? lastLightmapPageWidth : GetMaxLightmapPageWidth()); m_pLightmapPages[i].m_Height = (unsigned short)(lastStaticLightmap ? lastLightmapPageHeight : GetMaxLightmapPageHeight()); m_pLightmapPages[i].m_Flags = 0; AllocateLightmapTexture( i ); if ( GetMaterialSystem()->GetPaintmaps()->IsEnabled() ) { GetMaterialSystem()->GetPaintmaps()->AllocatePaintmap( i, GetLightmapWidth(i), GetLightmapHeight(i) ); } if ( mat_lightmap_pfms.GetBool()) { // Initialize the pointers to lightmap data m_pLightmapDataPtrArray[i] = NULL; } } if( GetMaterialSystem()->GetPaintmaps()->IsEnabled() ) { GetMaterialSystem()->GetPaintmaps()->EndPaintTextureAllocation(); } } ConVar mat_dynamiclightmaps( "mat_dynamiclightmaps", "0", FCVAR_CHEAT ); //----------------------------------------------------------------------------- // Allocate lightmap textures //----------------------------------------------------------------------------- void CMatLightmaps::AllocateLightmapTexture( int lightmap ) { bool bUseDynamicTextures = HardwareConfig()->PreferDynamicTextures() && mat_dynamiclightmaps.GetBool(); int flags = 0; if ( bUseDynamicTextures || IsPS3() ) // On PS3, we need the dynamic flag as a hint that we're going to update this texture incrementally in the future { flags |= TEXTURE_CREATE_DYNAMIC; } else { flags |= TEXTURE_CREATE_MANAGED; } int nPreviousTextureHandles = m_LightmapPageTextureHandles.Count(); m_LightmapPageTextureHandles.EnsureCount( lightmap + 1 ); for ( int nLightmap = nPreviousTextureHandles; nLightmap <= lightmap; ++nLightmap ) { m_LightmapPageTextureHandles[ nLightmap ] = INVALID_SHADERAPI_TEXTURE_HANDLE; } char debugName[256]; Q_snprintf( debugName, sizeof( debugName ), "[lightmap %d]", lightmap ); ImageFormat imageFormat; switch ( HardwareConfig()->GetHDRType() ) { default: Assert( 0 ); // fall through. case HDR_TYPE_NONE: #if !defined( _X360 ) imageFormat = IMAGE_FORMAT_RGBA8888; flags |= TEXTURE_CREATE_SRGB; #else imageFormat = IMAGE_FORMAT_LINEAR_RGBA8888; #endif break; case HDR_TYPE_INTEGER: #if !defined( _X360 ) imageFormat = IMAGE_FORMAT_RGBA16161616; #else # if ( defined( USE_32BIT_LIGHTMAPS_ON_360 ) ) imageFormat = IMAGE_FORMAT_LINEAR_RGBA8888; # else imageFormat = IMAGE_FORMAT_LINEAR_RGBA16161616; # endif #endif break; case HDR_TYPE_FLOAT: imageFormat = IMAGE_FORMAT_RGBA16161616F; break; } #ifdef _PS3 // PS3 needs 16F textures...but the HDR_TYPE_FLOAT codepath has a lot of other baggage with it. Just lie here. imageFormat = IMAGE_FORMAT_RGBA16161616F; #endif // _PS3 switch ( m_eLightmapsState ) { case STATE_DEFAULT: // Allow allocations in default state { int iWidth = GetLightmapWidth(lightmap); int iHeight = GetLightmapHeight(lightmap); m_LightmapPageTextureHandles[lightmap] = g_pShaderAPI->CreateTexture( iWidth, iHeight, 1, imageFormat, 1, 1, flags, debugName, TEXTURE_GROUP_LIGHTMAP ); // don't mipmap lightmaps // Load up the texture data g_pShaderAPI->ModifyTexture( m_LightmapPageTextureHandles[lightmap] ); g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR ); g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR ); if ( !bUseDynamicTextures ) { g_pShaderAPI->TexSetPriority( 1 ); } // Blat out the lightmap bits InitLightmapBits( lightmap ); } break; case STATE_RELEASED: // Not assigned m_LightmapPageTextureHandles[lightmap]; DevMsg( "AllocateLightmapTexture(%d) in released lightmap state (STATE_RELEASED), delayed till \"Restore\".\n", lightmap ); return; default: // Not assigned m_LightmapPageTextureHandles[lightmap]; Warning( "AllocateLightmapTexture(%d) in unknown lightmap state (%d), skipped.\n", lightmap, m_eLightmapsState ); Assert( !"AllocateLightmapTexture(?) in unknown lightmap state (?)" ); return; } } int CMatLightmaps::AllocateWhiteLightmap( IMaterial *iMaterial ) { IMaterialInternal *pMaterial = static_cast( iMaterial ); if( !pMaterial ) { Warning( "Programming error: CMatRenderContext::AllocateWhiteLightmap: NULL material\n" ); return m_numSortIDs; } pMaterial = pMaterial->GetRealTimeVersion(); //always work with the real time versions of materials internally if ( !m_currentWhiteLightmapMaterial || ( m_currentWhiteLightmapMaterial != pMaterial ) ) { if ( !GetCurrentMaterialInternal() && !m_currentWhiteLightmapMaterial ) { // don't increment if this is the very first material (ie. no lightmaps // allocated with AllocateLightmap // Assert( 0 ); } else { // material change m_numSortIDs++; #if 0 char buf[128]; Q_snprintf( buf, sizeof( buf ), "AllocateWhiteLightmap: m_numSortIDs = %d %s\n", m_numSortIDs, pMaterial->GetName() ); OutputDebugString( buf ); #endif } // Warning( "%d material: \"%s\" lightmapPageID: -1\n", m_numSortIDs, pMaterial->GetName() ); m_currentWhiteLightmapMaterial = pMaterial; pMaterial->SetNeedsWhiteLightmap( true ); } return m_numSortIDs; } //----------------------------------------------------------------------------- // Releases/restores lightmap pages //----------------------------------------------------------------------------- void CMatLightmaps::ReleaseLightmapPages() { switch ( m_eLightmapsState ) { case STATE_DEFAULT: // Allow release in default state only break; default: Warning( "ReleaseLightmapPages is expected in STATE_DEFAULT, current state = %d, discarded.\n", m_eLightmapsState ); Assert( !"ReleaseLightmapPages is expected in STATE_DEFAULT" ); return; } for( int i = 0; i < GetNumLightmapPages(); i++ ) { g_pShaderAPI->DeleteTexture( m_LightmapPageTextureHandles[i] ); } GetMaterialSystem()->GetPaintmaps()->ReleasePaintmaps(); // We are now in released state m_eLightmapsState = STATE_RELEASED; } void CMatLightmaps::RestoreLightmapPages() { switch ( m_eLightmapsState ) { case STATE_RELEASED: // Allow restore in released state only break; default: Warning( "RestoreLightmapPages is expected in STATE_RELEASED, current state = %d, discarded.\n", m_eLightmapsState ); Assert( !"RestoreLightmapPages is expected in STATE_RELEASED" ); return; } // Switch to default state to allow allocations m_eLightmapsState = STATE_DEFAULT; if( GetMaterialSystem()->GetPaintmaps()->IsEnabled() ) { GetMaterialSystem()->GetPaintmaps()->RestorePaintmaps( GetNumLightmapPages() ); } for( int i = 0; i < GetNumLightmapPages(); i++ ) { AllocateLightmapTexture( i ); } } //----------------------------------------------------------------------------- // This initializes the lightmap bits //----------------------------------------------------------------------------- void CMatLightmaps::InitLightmapBits( int lightmap ) { VPROF_( "CMatLightmaps::InitLightmapBits", 1, VPROF_BUDGETGROUP_DLIGHT_RENDERING, false, 0 ); int width = GetLightmapWidth(lightmap); int height = GetLightmapHeight(lightmap); CPixelWriter writer; g_pShaderAPI->ModifyTexture( m_LightmapPageTextureHandles[lightmap] ); if ( !g_pShaderAPI->TexLock( 0, 0, 0, 0, width, height, writer ) ) return; // Debug mode, make em green checkerboard if ( writer.IsUsingFloatFormat() ) { for ( int j = 0; j < height; ++j ) { writer.Seek( 0, j ); for ( int k = 0; k < width; ++k ) { #ifndef _DEBUG writer.WritePixel( 1.0f, 1.0f, 1.0f ); #else // _DEBUG if( ( j + k ) & 1 ) { writer.WritePixelF( 0.0f, 1.0f, 0.0f ); } else { writer.WritePixelF( 0.0f, 0.0f, 0.0f ); } #endif // _DEBUG } } } else { #if defined( _X360 ) && defined( _DEBUG ) float vGreenData[4] = { 0.0f, 2.0f, 0.0f, 0.0f }; fltx4 vGreen = LoadUnalignedSIMD( vGreenData ); #endif for ( int j = 0; j < height; ++j ) { writer.Seek( 0, j ); for ( int k = 0; k < width; ++k ) { #ifndef _DEBUG // note: make this white to find multisample centroid sampling problems. // writer.WritePixel( 255, 255, 255 ); #ifdef _X360 { writer.WritePixel( Four_Zeros ); } #else { writer.WritePixel( 0, 0, 0 ); } #endif #else // _DEBUG #ifdef _X360 { if ( ( j + k ) & 1 ) { writer.WritePixel( vGreen ); } else { writer.WritePixel( Four_Zeros ); } } #else { if ( ( j + k ) & 1 ) { writer.WritePixel( 0, 255, 0 ); } else { writer.WritePixel( 0, 0, 0 ); } } #endif // _X360 #endif // _DEBUG } } } g_pShaderAPI->TexUnlock(); } bool CMatLightmaps::LockLightmap( int lightmap ) { // Warning( "locking lightmap page: %d\n", lightmap ); VPROF_INCREMENT_COUNTER( "lightmap fullpage texlock", 1 ); if( m_nLockedLightmap != -1 ) { g_pShaderAPI->TexUnlock(); } g_pShaderAPI->ModifyTexture( m_LightmapPageTextureHandles[lightmap] ); int pageWidth = m_pLightmapPages[lightmap].m_Width; int pageHeight = m_pLightmapPages[lightmap].m_Height; if (!g_pShaderAPI->TexLock( 0, 0, 0, 0, pageWidth, pageHeight, m_LightmapPixelWriter )) { Assert( 0 ); return false; } m_nLockedLightmap = lightmap; return true; } Vector4D ConvertLightmapColorToRGBScale( const float *lightmapColor ) { Vector4D result; float fScale = lightmapColor[0]; for( int i = 1; i != 3; ++i ) { if( lightmapColor[i] > fScale ) fScale = lightmapColor[i]; } fScale = ceil( fScale * (255.0f/16.0f) ) * (16.0f/255.0f); fScale = MIN( fScale, 16.0f ); float fInvScale = 1.0f / fScale; for( int i = 0; i != 3; ++i ) { result[i] = lightmapColor[i] * fInvScale; result[i] = ceil( result[i] * 255.0f ) * (1.0f/255.0f); result[i] = MIN( result[i], 1.0f ); } fScale /= 16.0f; result.w = fScale; return result; } #ifdef _X360 // SIMD version of above // input numbers from pSrc are on the domain [0..16] // output is RGBA // ignores contents of w channel of input // the shader does this: rOut = Rin * Ain * 16.0f // where Rin is [0..1], a float computed from a byte value [0..255] // Ain is therefore the brightest channel (say R) divided by 16 and quantized // Rin is computed from pSrc->r by dividing by Ain // this outputs RGBa where RGB are [0..255] and a is the shader's scaling factor (also 0..255) // // WARNING - this code appears to be vulnerable to a compiler bug. Be very careful modifying and be // sure to test fltx4 ConvertLightmapColorToRGBScale( FLTX4 lightmapColor ) { static const fltx4 vTwoFiftyFive = {255.0f, 255.0f, 255.0f, 255.0f}; static const fltx4 FourPoint1s = { 0.1, 0.1, 0.1, 0.1 }; static const fltx4 vTwoFiftyFiveOverSixteen = {255.0f / 16.0f, 255.0f / 16.0f, 255.0f / 16.0f, 255.0f / 16.0f}; // static const fltx4 vSixteenOverTwoFiftyFive = { 16.0f / 255.0f, 16.0f / 255.0f, 16.0f / 255.0f, 16.0f / 255.0f }; // find the highest color value in lightmapColor and replicate it fltx4 scale = FindHighestSIMD3( lightmapColor ); fltx4 minscale = FindLowestSIMD3( lightmapColor ); fltx4 fl4OutofRange = OrSIMD( CmpGeSIMD( scale, Four_Ones ), CmpLeSIMD( scale, FourPoint1s ) ); fl4OutofRange = OrSIMD( fl4OutofRange, CmpGtSIMD( minscale, MulSIMD( Four_PointFives, scale ) ) ); // scale needs to be divided by 16 (because the shader multiplies it by 16) // then mapped to 0..255 and quantized. scale = __vrfip(MulSIMD(scale, vTwoFiftyFiveOverSixteen)); // scale = ceil(scale * 255/16) fltx4 result = MulSIMD(vTwoFiftyFive, lightmapColor); // start the scale cooking on the final result fltx4 invScale = ReciprocalEstSIMD(scale); // invScale = (16/255)(1/scale). may be +inf invScale = MulSIMD(invScale, vTwoFiftyFiveOverSixteen); // take the quantizing factor back out // of the inverse scale (one less // dependent op if you do it this way) // scale the input channels // compute so the numbers are all 0..255 ints. (if one happens to // be 256 due to numerical error in the reciprocation, the unsigned-saturate // store we'll use later on will bake it back down to 255) result = MulSIMD(result, invScale); // now, output -- // if the input color was nonzero, slip the scale into return value's w // component and return. If the input was zero, return zero. result = MaskedAssign( fl4OutofRange, SetWSIMD( result, scale ), SetWSIMD( MulSIMD( lightmapColor, vTwoFiftyFive ), vTwoFiftyFiveOverSixteen ) ); return result; } #endif // write bumped lightmap update to LDR 8-bit lightmap void CMatLightmaps::BumpedLightmapBitsToPixelWriter_LDR( float* pFloatImage, float *pFloatImageBump1, float *pFloatImageBump2, float *pFloatImageBump3, int pLightmapSize[2], int pOffsetIntoLightmapPage[2], FloatBitMap_t *pfmOut ) { const int nLightmapSize0 = pLightmapSize[0]; const int nLightmap0WriterSizeBytes = nLightmapSize0 * m_LightmapPixelWriter.GetPixelSize(); const int nRewindToNextPixel = -( ( nLightmap0WriterSizeBytes * 3 ) - m_LightmapPixelWriter.GetPixelSize() ); for( int t = 0; t < pLightmapSize[1]; t++ ) { int srcTexelOffset = ( sizeof( Vector4D ) / sizeof( float ) ) * ( 0 + t * nLightmapSize0 ); m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); for( int s = 0; s < nLightmapSize0; s++, m_LightmapPixelWriter.SkipBytes(nRewindToNextPixel),srcTexelOffset += (sizeof(Vector4D)/sizeof(float))) { unsigned char color[4][4]; ColorSpace::LinearToBumpedLightmap( &pFloatImage[srcTexelOffset], &pFloatImageBump1[srcTexelOffset], &pFloatImageBump2[srcTexelOffset], &pFloatImageBump3[srcTexelOffset], color[0], color[1], color[2], color[3] ); if ( HardwareConfig()->GetCSMAccurateBlending() ) { ColorSpace::LinearToBumpedLightmapAlpha( &pFloatImage[srcTexelOffset + 3], &pFloatImageBump1[srcTexelOffset + 3], &pFloatImageBump2[srcTexelOffset + 3], &pFloatImageBump3[srcTexelOffset + 3], &color[0][3], &color[1][3], &color[2][3], &color[3][3] ); } else { unsigned char alpha = RoundFloatToByte( pFloatImage[srcTexelOffset+3] * 255.0f ); color[0][3] = alpha; color[1][3] = alpha; color[2][3] = alpha; color[3][3] = alpha; } m_LightmapPixelWriter.WritePixelNoAdvance( color[0][0], color[0][1], color[0][2], color[0][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvance( color[1][0], color[1][1], color[1][2], color[1][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvance( color[2][0], color[2][1], color[2][2], color[2][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvance( color[3][0], color[3][1], color[3][2], color[3][3] ); } } if ( pfmOut ) { for( int t = 0; t < pLightmapSize[1]; t++ ) { int srcTexelOffset = ( sizeof( Vector4D ) / sizeof( float ) ) * ( 0 + t * nLightmapSize0 ); for( int s = 0; s < nLightmapSize0; s++,srcTexelOffset += (sizeof(Vector4D)/sizeof(float))) { unsigned char color[4][4]; ColorSpace::LinearToBumpedLightmap( &pFloatImage[srcTexelOffset], &pFloatImageBump1[srcTexelOffset], &pFloatImageBump2[srcTexelOffset], &pFloatImageBump3[srcTexelOffset], color[0], color[1], color[2], color[3] ); unsigned char alpha = RoundFloatToByte( pFloatImage[srcTexelOffset+3] * 255.0f ); // Write data to the bitmapped represenations so that PFM files can be written PixRGBAF pixelData; pixelData.Red = color[0][0]; pixelData.Green = color[0][1]; pixelData.Blue = color[0][2]; pixelData.Alpha = alpha; pfmOut->WritePixelRGBAF( pOffsetIntoLightmapPage[0] + s, pOffsetIntoLightmapPage[1] + t, 0, pixelData); } } } } // write bumped lightmap update to HDR float lightmap void CMatLightmaps::BumpedLightmapBitsToPixelWriter_HDRF( float* pFloatImage, float *pFloatImageBump1, float *pFloatImageBump2, float *pFloatImageBump3, int pLightmapSize[2], int pOffsetIntoLightmapPage[2], FloatBitMap_t *pfmOut ) { if ( IsX360() ) { // 360 does not support HDR float mode Assert( 0 ); return; } Assert( !pfmOut ); // unsupported in this mode const int nLightmapSize0 = pLightmapSize[0]; const int nLightmap0WriterSizeBytes = nLightmapSize0 * m_LightmapPixelWriter.GetPixelSize(); const int nRewindToNextPixel = -( ( nLightmap0WriterSizeBytes * 3 ) - m_LightmapPixelWriter.GetPixelSize() ); for( int t = 0; t < pLightmapSize[1]; t++ ) { int srcTexelOffset = ( sizeof( Vector4D ) / sizeof( float ) ) * ( 0 + t * nLightmapSize0 ); m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); // if it's anything but 4 x float16 on a PPC... /* // The 'else' path uses ConvertFourFloatsTo16BitsAtOnce which is entirely broken // so we need to always use the main path. if ( !IsGameConsole() || !(m_LightmapPixelWriter.GetPixelSize() == 4*sizeof(unsigned short)) || !(m_LightmapPixelWriter.IsUsing16BitFloatFormat()) )*/ { for( int s = 0; s < nLightmapSize0; s++, m_LightmapPixelWriter.SkipBytes(nRewindToNextPixel),srcTexelOffset += (sizeof(Vector4D)/sizeof(float))) { float color[4][4]; // [mariod] - LinearToBumpedLightmap() was entirely missing in the float path as of September '11 // looks like this only affected PS3 (PC/X360 use linear 16bit tex formats) ColorSpace::LinearToBumpedLightmap( &pFloatImage[srcTexelOffset], &pFloatImageBump1[srcTexelOffset], &pFloatImageBump2[srcTexelOffset], &pFloatImageBump3[srcTexelOffset], color[0], color[1], color[2], color[3] ); if ( HardwareConfig()->GetCSMAccurateBlending() ) { ColorSpace::LinearToBumpedLightmapAlpha( &pFloatImage[srcTexelOffset + 3], &pFloatImageBump1[srcTexelOffset + 3], &pFloatImageBump2[srcTexelOffset + 3], &pFloatImageBump3[srcTexelOffset + 3], &color[0][3], &color[1][3], &color[2][3], &color[3][3] ); } else { float alpha = pFloatImage[srcTexelOffset+3]; color[0][3] = alpha; color[1][3] = alpha; color[2][3] = alpha; color[3][3] = alpha; } m_LightmapPixelWriter.WritePixelNoAdvanceF( color[0][0], color[0][1], color[0][2], color[0][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvanceF( color[1][0], color[1][1], color[1][2], color[1][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvanceF( color[2][0], color[2][1], color[2][2], color[2][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvanceF( color[3][0], color[3][1], color[3][2], color[3][3] ); } } /* else // use a faster technique on PPC cores for float16 lightmaps, that's not so branchy and load-hit-store-y { for( int s = 0; s < nLightmapSize0; s++, m_LightmapPixelWriter.SkipBytes(nRewindToNextPixel),srcTexelOffset += (sizeof(Vector4D)/sizeof(float))) { float color[4][4]; // [mariod] - LinearToBumpedLightmap() was entirely missing in the float path as of September '11 // looks like this only affected PS3 (PC/X360 use linear 16bit tex formats) ColorSpace::LinearToBumpedLightmap( &pFloatImage[srcTexelOffset], &pFloatImageBump1[srcTexelOffset], &pFloatImageBump2[srcTexelOffset], &pFloatImageBump3[srcTexelOffset], color[0], color[1], color[2], color[3] ); float alpha = pFloatImage[srcTexelOffset+3]; float16::ConvertFourFloatsTo16BitsAtOnce( (float16*) m_LightmapPixelWriter.GetCurrentPixel(), &color[0][0], &color[0][1], &color[0][2], &alpha ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); float16::ConvertFourFloatsTo16BitsAtOnce( (float16*) m_LightmapPixelWriter.GetCurrentPixel(), &color[1][0], &color[1][1], &color[1][2], &alpha ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); float16::ConvertFourFloatsTo16BitsAtOnce( (float16*) m_LightmapPixelWriter.GetCurrentPixel(), &color[2][0], &color[2][1], &color[2][2], &alpha ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); float16::ConvertFourFloatsTo16BitsAtOnce( (float16*) m_LightmapPixelWriter.GetCurrentPixel(), &color[3][0], &color[3][1], &color[3][2], &alpha ); } } */ } } #ifdef _X360 #pragma optimize("u", on) #endif #ifdef _X360 namespace { // pack a pixel into BGRA8888 and return it with the data packed into the w component FORCEINLINE fltx4 PackPixel_BGRA8888( FLTX4 rgba ) { // this happens to be in an order such that we can use the handy builtin packing op // clamp to 0..255 (coz it might have leaked over) static const fltx4 vTwoFiftyFive = {255.0f, 255.0f, 255.0f, 255.0f}; // the magic number such that when mul-accummulated against rbga, // gets us a representation 3.0 + (r)*2^-22 -- puts the bits at // the bottom of the float static const XMVECTOR PackScale = { (1.0f / (FLOAT)(1 << 22)), (1.0f / (FLOAT)(1 << 22)), (1.0f / (FLOAT)(1 << 22)), (1.0f / (FLOAT)(1 << 22))}; // 255.0f / (FLOAT)(1 << 22) static const XMVECTOR Three = {3.0f, 3.0f, 3.0f, 3.0f}; fltx4 N = MinSIMD(vTwoFiftyFive, rgba); N = __vmaddfp(N, PackScale, Three); N = __vpkd3d(N, N, VPACK_D3DCOLOR, VPACK_32, 0); // pack into w word return N; } // A small store-gather buffer used in the // BumpedLightmapBitsToPixelWriter_HDRI_BGRA_X360(). // The store-gather buffers. Hopefully these will live in the L1 // cache, which will make writing to them, then to memory, faster // than just using __stvewx to write directly into WC memory // one noncontiguous float at a time. (If there weren't a huge // compiler bug with __stvewx in the Apr07 XDK, that might not // be the case.) struct ALIGN128 CPixelWriterStoreGather { enum { kRows = 4, kWordsPerRow = 32, }; ALIGN128 uint32 m_data[kRows][kWordsPerRow]; // four rows of bgra data, aligned to 4 cache lines. dwords so memcpy works better. int m_wordsGathered; int m_bytesBetweenWriterRows; // the number of bytes spacing the maps inside the writer from each other // if we weren't gathering, we'd SkipBytes this many between the base map, bump1, etc. // write four rows, as SIMD registers, into the buffers inline void write( CPixelWriter * RESTRICT pLightmapPixelWriter, FLTX4 row0, FLTX4 row1, FLTX4 row2, FLTX4 row3 ) RESTRICT { // if full, commit Assert(m_wordsGathered <= kWordsPerRow); AssertMsg((m_wordsGathered & 3) == 0, "Don't call CPixelWriterStoreGather::write after ::writeJustX"); // single-word writes have misaligned me if (m_wordsGathered >= kWordsPerRow) { commitWhenFull(pLightmapPixelWriter); } XMStoreVector4A( &m_data[0][m_wordsGathered], row0 ); XMStoreVector4A( &m_data[1][m_wordsGathered], row1 ); XMStoreVector4A( &m_data[2][m_wordsGathered], row2 ); XMStoreVector4A( &m_data[3][m_wordsGathered], row3 ); m_wordsGathered += 4 ; // four words per simd vec } // pluck the w component out of each of the rows, and store it into the gather buffer. Don't // call the other write function after calling this. inline void writeJustW( CPixelWriter * RESTRICT pLightmapPixelWriter, FLTX4 row0, FLTX4 row1, FLTX4 row2, FLTX4 row3 ) RESTRICT { // if full, commit Assert(m_wordsGathered <= kWordsPerRow); if (m_wordsGathered >= kWordsPerRow) { commitWhenFull(pLightmapPixelWriter); } // for each fltx4, splat out x and then use the __stvewx to store // whichever word happens to align with the float pointer through // that pointer. __stvewx(__vspltw(row0, 3), &m_data[0][m_wordsGathered], 0 ); __stvewx(__vspltw(row1, 3), &m_data[1][m_wordsGathered], 0 ); __stvewx(__vspltw(row2, 3), &m_data[2][m_wordsGathered], 0 ); __stvewx(__vspltw(row3, 3), &m_data[3][m_wordsGathered], 0 ); m_wordsGathered += 1 ; // only stored one word } // Commit my buffers to the pixelwriter's memory, and advance its // pointer. void commit(CPixelWriter * RESTRICT pLightmapPixelWriter) RESTRICT { if (m_wordsGathered > 0) { unsigned char* RESTRICT pWriteInto = pLightmapPixelWriter->GetCurrentPixel(); // we have to use memcpy because we're writing to non-cacheable memory, // but we can't even assume that the addresses we're writing to are // vector-aligned. #ifdef memcpy // if someone's overriden the intrinsic, complain #pragma error("You have overridden memcpy(), which is an XBOX360 intrinsic. This function will not behave optimally.") #endif memcpy(pWriteInto, m_data[0], m_wordsGathered * sizeof(uint32)); pWriteInto += m_bytesBetweenWriterRows; memcpy(pWriteInto, m_data[1], m_wordsGathered * sizeof(uint32)); pWriteInto += m_bytesBetweenWriterRows; memcpy(pWriteInto, m_data[2], m_wordsGathered * sizeof(uint32)); pWriteInto += m_bytesBetweenWriterRows; memcpy(pWriteInto, m_data[3], m_wordsGathered * sizeof(uint32)); pLightmapPixelWriter->SkipBytes(m_wordsGathered * sizeof(uint32)); m_wordsGathered = 0; } } // like commit, but the version we use when we know we're full. // Takes advantage of better compile-time generation for // memcpy. void commitWhenFull(CPixelWriter * RESTRICT pLightmapPixelWriter) RESTRICT { unsigned char* RESTRICT pWriteInto = pLightmapPixelWriter->GetCurrentPixel(); // we have to use memcpy because we're writing to non-cacheable memory, // but we can't even assume that the addresses we're writing to are // vector-aligned. #ifdef memcpy // if someone's overriden the intrinsic, complain #pragma error("You have overridden memcpy(), which is an XBOX360 intrinsic. This function will not behave optimally.") #endif // if we're full, use compile-time known version of // mempcy to take advantage of its ability to generate // inline code. In fact, use the dword-aligned // version so that we use the 64-bit writing funcs. Assert( m_wordsGathered == kWordsPerRow ); COMPILE_TIME_ASSERT((kWordsPerRow & 3) == 0); // the number of words per row has to be a multiple of four memcpy(pWriteInto, reinterpret_cast(m_data[0]), kWordsPerRow * sizeof(uint32)); pWriteInto += m_bytesBetweenWriterRows; memcpy(pWriteInto, reinterpret_cast(m_data[1]), kWordsPerRow * sizeof(uint32)); pWriteInto += m_bytesBetweenWriterRows; memcpy(pWriteInto, reinterpret_cast(m_data[2]), kWordsPerRow * sizeof(uint32)); pWriteInto += m_bytesBetweenWriterRows; memcpy(pWriteInto, reinterpret_cast(m_data[3]), kWordsPerRow * sizeof(uint32)); pLightmapPixelWriter->SkipBytes(m_wordsGathered * sizeof(uint32)); m_wordsGathered = 0; } // parameter: space between bump pages in the pixelwriter CPixelWriterStoreGather(int writerSizeBytes) : m_wordsGathered(0), m_bytesBetweenWriterRows(writerSizeBytes) {}; }; } // this is a function for specifically writing bumped BGRA lightmaps -- in order for it // to be properly scheduled, I needed to break out the inline functions. Also, // to make the write-combined memory more efficient (and work around a bug in the // April 2007 XDK), we need to store-gather our writes on the cache before blasting // them out to write-combined memory. We can't simply write from the SIMD registers // into the pixelwriter's data, because the difference between the output rows, // eg nLightmap0WriterSizeBytes[0], might not be a multiple of 16. Unaligned stores // to non-cacheable memory cause an alignment exception. static void BumpedLightmapBitsToPixelWriter_HDRI_BGRA_X360( float* RESTRICT pFloatImage, float * RESTRICT pFloatImageBump1, float * RESTRICT pFloatImageBump2, float * RESTRICT pFloatImageBump3, int pLightmapSize[2], int pOffsetIntoLightmapPage[2], FloatBitMap_t *pfmOut, CPixelWriter * RESTRICT m_LightmapPixelWriter) { AssertMsg(m_LightmapPixelWriter->GetPixelSize() == 4, "BGRA format is no longer four bytes long? This is unsupported on 360, and probably immoral as well."); const int nLightmap0WriterSizeBytes = pLightmapSize[0] * 4 /*m_LightmapPixelWriter->GetPixelSize()*/; // const int nRewindToNextPixel = -( ( nLightmap0WriterSizeBytes * 3 ) - 4 ); // assert that 1 * 4 = 4 COMPILE_TIME_ASSERT(sizeof( Vector4D ) == sizeof(float) * 4); AssertMsg(!pfmOut, "Runtime conversion of lightmaps to files is no longer supported on 360.\n"); // The store-gather buffers. Hopefully these will live in the L1 // cache, which will make writing to them, then to memory, faster // than just using __stvewx to write directly into WC memory // one noncontiguous float at a time. (If there weren't a huge // compiler bug with __stvewx in the Apr07 XDK, that might not // be the case.) CPixelWriterStoreGather storeGather(nLightmap0WriterSizeBytes); for( int t = 0; t < pLightmapSize[1]; t++ ) { #define FOUR (sizeof( Vector4D ) / sizeof( float )) // make explicit when we're incrementing by length of a 4dvec int srcTexelOffset = ( FOUR ) * ( 0 + t * pLightmapSize[0] ); m_LightmapPixelWriter->Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); // Our code works best when we can process luxels in groups of four. So, // figure out how many four-luxel groups we can process, // then do them in groups, then process the remainder. unsigned int groupsOfFourLimit = (((unsigned int)pLightmapSize[0]) & ~3); // we want to hang on to this index when we're done with groups so we can do the remainder. unsigned int s; // counts the number of luxels processed for( s = 0; s < groupsOfFourLimit; s += 4, srcTexelOffset += 4 * ( FOUR )) { static const fltx4 vSixteen = {16.0f, 16.0f, 16.0f, 16.0f}; // the store-gather simds fltx4 outBaseMap = Four_Zeros, outBump1 = Four_Zeros, outBump2 = Four_Zeros, outBump3 = Four_Zeros; // we'll read four at a time fltx4 vFloatImage[4], vFloatImageBump1[4], vFloatImageBump2[4], vFloatImageBump3[4]; // stripe these loads to cause less ERAT thrashing vFloatImage[0] = LoadUnalignedSIMD(pFloatImage + srcTexelOffset ); vFloatImage[1] = LoadUnalignedSIMD(pFloatImage + srcTexelOffset + 4 ); vFloatImage[2] = LoadUnalignedSIMD(pFloatImage + srcTexelOffset + 8 ); vFloatImage[3] = LoadUnalignedSIMD(pFloatImage + srcTexelOffset + 12 ); vFloatImageBump1[0] = LoadUnalignedSIMD(pFloatImageBump1 + srcTexelOffset ); vFloatImageBump1[1] = LoadUnalignedSIMD(pFloatImageBump1 + srcTexelOffset + 4 ); vFloatImageBump1[2] = LoadUnalignedSIMD(pFloatImageBump1 + srcTexelOffset + 8 ); vFloatImageBump1[3] = LoadUnalignedSIMD(pFloatImageBump1 + srcTexelOffset + 12 ); vFloatImageBump2[0] = LoadUnalignedSIMD(pFloatImageBump2 + srcTexelOffset ); vFloatImageBump2[1] = LoadUnalignedSIMD(pFloatImageBump2 + srcTexelOffset + 4 ); vFloatImageBump2[2] = LoadUnalignedSIMD(pFloatImageBump2 + srcTexelOffset + 8 ); vFloatImageBump2[3] = LoadUnalignedSIMD(pFloatImageBump2 + srcTexelOffset + 12 ); vFloatImageBump3[0] = LoadUnalignedSIMD(pFloatImageBump3 + srcTexelOffset ); vFloatImageBump3[1] = LoadUnalignedSIMD(pFloatImageBump3 + srcTexelOffset + 4 ); vFloatImageBump3[2] = LoadUnalignedSIMD(pFloatImageBump3 + srcTexelOffset + 8 ); vFloatImageBump3[3] = LoadUnalignedSIMD(pFloatImageBump3 + srcTexelOffset + 12 ); // perform an arcane averaging operation upon the bump map values // (todo: make this not an inline so it will schedule better -- inlining is // done by the linker, which is too late for operation scheduling) ColorSpace::LinearToBumpedLightmap( vFloatImage[0], vFloatImageBump1[0], vFloatImageBump2[0], vFloatImageBump3[0], // transform "in place": vFloatImage[0], vFloatImageBump1[0], vFloatImageBump2[0], vFloatImageBump3[0] ); ColorSpace::LinearToBumpedLightmap( vFloatImage[1], vFloatImageBump1[1], vFloatImageBump2[1], vFloatImageBump3[1], // transform "in place": vFloatImage[1], vFloatImageBump1[1], vFloatImageBump2[1], vFloatImageBump3[1] ); ColorSpace::LinearToBumpedLightmap( vFloatImage[2], vFloatImageBump1[2], vFloatImageBump2[2], vFloatImageBump3[2], // transform "in place": vFloatImage[2], vFloatImageBump1[2], vFloatImageBump2[2], vFloatImageBump3[2] ); ColorSpace::LinearToBumpedLightmap( vFloatImage[3], vFloatImageBump1[3], vFloatImageBump2[3], vFloatImageBump3[3], // transform "in place": vFloatImage[3], vFloatImageBump1[3], vFloatImageBump2[3], vFloatImageBump3[3] ); // convert each color to RGB scaled. // DO NOT! make this into a for loop. The (April07 XDK) compiler // in fact DOES NOT unroll them, and will perform very naive // scheduling if you try. // clamp to 0..16 float vFloatImage[0] = MinSIMD(vFloatImage[0], vSixteen); vFloatImageBump1[0] = MinSIMD(vFloatImageBump1[0], vSixteen); vFloatImageBump2[0] = MinSIMD(vFloatImageBump2[0], vSixteen); vFloatImageBump3[0] = MinSIMD(vFloatImageBump3[0], vSixteen); vFloatImage[1] = MinSIMD(vFloatImage[1], vSixteen); vFloatImageBump1[1] = MinSIMD(vFloatImageBump1[1], vSixteen); vFloatImageBump2[1] = MinSIMD(vFloatImageBump2[1], vSixteen); vFloatImageBump3[1] = MinSIMD(vFloatImageBump3[1], vSixteen); vFloatImage[2] = MinSIMD(vFloatImage[2], vSixteen); vFloatImageBump1[2] = MinSIMD(vFloatImageBump1[2], vSixteen); vFloatImageBump2[2] = MinSIMD(vFloatImageBump2[2], vSixteen); vFloatImageBump3[2] = MinSIMD(vFloatImageBump3[2], vSixteen); vFloatImage[3] = MinSIMD(vFloatImage[3], vSixteen); vFloatImageBump1[3] = MinSIMD(vFloatImageBump1[3], vSixteen); vFloatImageBump2[3] = MinSIMD(vFloatImageBump2[3], vSixteen); vFloatImageBump3[3] = MinSIMD(vFloatImageBump3[3], vSixteen); // compute the scaling factor, place it in w, and // scale the rest by it. Obliterates whatever was // already in alpha. // This code is why it is important to not use a for // loop: you need to let the compiler keep the value // on registers (which it can't do if you use a // variable indexed array) and interleave the // inlined instructions. vFloatImage[0] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImage[0]) ); vFloatImageBump1[0] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump1[0]) ); vFloatImageBump2[0] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump2[0]) ); vFloatImageBump3[0] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump3[0]) ); vFloatImage[1] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImage[1]) ); vFloatImageBump1[1] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump1[1]) ); vFloatImageBump2[1] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump2[1]) ); vFloatImageBump3[1] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump3[1]) ); vFloatImage[2] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImage[2]) ); vFloatImageBump1[2] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump1[2]) ); vFloatImageBump2[2] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump2[2]) ); vFloatImageBump3[2] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump3[2]) ); vFloatImage[3] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImage[3]) ); vFloatImageBump1[3] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump1[3]) ); vFloatImageBump2[3] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump2[3]) ); vFloatImageBump3[3] = PackPixel_BGRA8888( ConvertLightmapColorToRGBScale(vFloatImageBump3[3]) ); // Each of the registers above contains one RGBA 32-bit struct // in their w word. So, combine them such that each of the assignees // below contains four RGBAs, in xyzw order (big-endian). outBaseMap = __vrlimi(outBaseMap, vFloatImage[0], 8, 3 ); // insert into x outBump1 = __vrlimi(outBump1, vFloatImageBump1[0], 8, 3 ); // insert into x outBump2 = __vrlimi(outBump2, vFloatImageBump2[0], 8, 3 ); // insert into x outBump3 = __vrlimi(outBump3, vFloatImageBump3[0], 8, 3 ); // insert into x outBaseMap = __vrlimi(outBaseMap, vFloatImage[1], 4, 2 ); // insert into y outBump1 = __vrlimi(outBump1, vFloatImageBump1[1], 4, 2 ); // insert into y outBump2 = __vrlimi(outBump2, vFloatImageBump2[1], 4, 2 ); // insert into y outBump3 = __vrlimi(outBump3, vFloatImageBump3[1], 4, 2 ); // insert into y outBaseMap = __vrlimi(outBaseMap, vFloatImage[2], 2, 1 ); // insert into z outBump1 = __vrlimi(outBump1, vFloatImageBump1[2], 2, 1 ); // insert into z outBump2 = __vrlimi(outBump2, vFloatImageBump2[2], 2, 1 ); // insert into z outBump3 = __vrlimi(outBump3, vFloatImageBump3[2], 2, 1 ); // insert into z outBaseMap = __vrlimi(outBaseMap, vFloatImage[3], 1, 0 ); // insert into w outBump1 = __vrlimi(outBump1, vFloatImageBump1[3], 1, 0 ); // insert into w outBump2 = __vrlimi(outBump2, vFloatImageBump2[3], 1, 0 ); // insert into w outBump3 = __vrlimi(outBump3, vFloatImageBump3[3], 1, 0 ); // insert into w // push the data through the store-gather buffer. storeGather.write(m_LightmapPixelWriter, outBaseMap, outBump1, outBump2, outBump3); } // Once here, make sure we've committed any leftover changes, then process // the remainders singly. storeGather.commit(m_LightmapPixelWriter); for( ; // s is where it should be from the loop above s < (unsigned int) pLightmapSize[0]; s++, // m_LightmapPixelWriter->SkipBytes(nRewindToNextPixel), // now handled by store-gather srcTexelOffset += ( FOUR )) { static const fltx4 vSixteen = {16.0f, 16.0f, 16.0f, 16.0f}; fltx4 vColor[4]; fltx4 vFloatImage = LoadUnalignedSIMD(&pFloatImage[srcTexelOffset]); fltx4 vFloatImageBump1 = LoadUnalignedSIMD(&pFloatImageBump1[srcTexelOffset]); fltx4 vFloatImageBump2 = LoadUnalignedSIMD(&pFloatImageBump2[srcTexelOffset]); fltx4 vFloatImageBump3 = LoadUnalignedSIMD(&pFloatImageBump3[srcTexelOffset]); // perform an arcane averaging operation upon the bump map values ColorSpace::LinearToBumpedLightmap( vFloatImage, vFloatImageBump1, vFloatImageBump2, vFloatImageBump3, vColor[0], vColor[1], vColor[2], vColor[3] ); // convert each color to RGB scaled. // DO NOT! make this into a for loop. The (April07 XDK) compiler // in fact DOES NOT unroll them, and will perform very naive // scheduling if you try. // clamp to 0..16 float vColor[0] = MinSIMD(vColor[0], vSixteen); vColor[1] = MinSIMD(vColor[1], vSixteen); vColor[2] = MinSIMD(vColor[2], vSixteen); vColor[3] = MinSIMD(vColor[3], vSixteen); // compute the scaling factor, place it in w, and // scale the rest by it. Obliterates whatever was // already in alpha. // This code is why it is important to not use a for // loop: you need to let the compiler interleave the // inlined instructions. vColor[0] = ConvertLightmapColorToRGBScale( vColor[0] ); vColor[1] = ConvertLightmapColorToRGBScale( vColor[1] ); vColor[2] = ConvertLightmapColorToRGBScale( vColor[2] ); vColor[3] = ConvertLightmapColorToRGBScale( vColor[3] ); #ifdef X360_DOUBLECHECK_LIGHTMAPS unsigned short color[4][4]; ColorSpace::LinearToBumpedLightmap( &pFloatImage[srcTexelOffset], &pFloatImageBump1[srcTexelOffset], &pFloatImageBump2[srcTexelOffset], &pFloatImageBump3[srcTexelOffset], color[0], color[1], color[2], color[3] ); unsigned short alpha = ColorSpace::LinearToUnsignedShort( pFloatImage[srcTexelOffset+3], 16 ); color[0][3] = color[1][3] = color[2][3] = color[3][3] = alpha; if( IsX360() ) { for( int i = 0; i != 4; ++i ) { Vector4D vRGBScale; vRGBScale.x = color[i][0] * (16.0f / 65535.0f); vRGBScale.y = color[i][1] * (16.0f / 65535.0f); vRGBScale.z = color[i][2] * (16.0f / 65535.0f); vRGBScale = ConvertLightmapColorToRGBScale( &vRGBScale.x ); color[i][0] = RoundFloatToByte( vRGBScale.x * 255.0f ); color[i][1] = RoundFloatToByte( vRGBScale.y * 255.0f ); color[i][2] = RoundFloatToByte( vRGBScale.z * 255.0f ); color[i][3] = RoundFloatToByte( vRGBScale.w * 255.0f ); } } /* for (int ii = 0; ii < 4; ++ii) { uint32 pack = (PackPixel_BGRA8888( vColor[ii] ).u[3]); if (color[ii][3] != 0) Assert( color[ii][0] == (pack & 0xFF0000) >> 16 && color[ii][1] == (pack & 0xFF00) >> 8 && color[ii][2] == (pack & 0xFF) && color[ii][3] == (pack & 0xFF000000) >> 24 ); } */ #endif vColor[0] = PackPixel_BGRA8888( vColor[0] ); vColor[1] = PackPixel_BGRA8888( vColor[1] ); vColor[2] = PackPixel_BGRA8888( vColor[2] ); vColor[3] = PackPixel_BGRA8888( vColor[3] ); storeGather.writeJustW(m_LightmapPixelWriter, vColor[0], vColor[1], vColor[2], vColor[3] ); /* // here is the old way of writing pixels: // now we store-gather this m_LightmapPixelWriter->WritePixelNoAdvance_BGRA8888( vColor[0] ); Assert(*reinterpret_cast(m_LightmapPixelWriter->GetCurrentPixel()) == PackPixel_BGRA8888( vColor[0] ).u[3] ); void * RESTRICT pBits = m_LightmapPixelWriter->SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter->WritePixelNoAdvance_BGRA8888( vColor[1], pBits ); Assert(*reinterpret_cast(m_LightmapPixelWriter->GetCurrentPixel()) == PackPixel_BGRA8888( vColor[1] ).u[3] ); pBits = m_LightmapPixelWriter->SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter->WritePixelNoAdvance_BGRA8888( vColor[2], pBits ); Assert(*reinterpret_cast(m_LightmapPixelWriter->GetCurrentPixel()) == PackPixel_BGRA8888( vColor[2] ).u[3] ); pBits = m_LightmapPixelWriter->SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter->WritePixelNoAdvance_BGRA8888( vColor[3], pBits ); Assert(*reinterpret_cast(m_LightmapPixelWriter->GetCurrentPixel()) == PackPixel_BGRA8888( vColor[3] ).u[3] ); m_LightmapPixelWriter->SkipBytes(nRewindToNextPixel); */ } storeGather.commit(m_LightmapPixelWriter); } } #endif //_X360 // write bumped lightmap update to HDR integer lightmap void CMatLightmaps::BumpedLightmapBitsToPixelWriter_HDRI( float* RESTRICT pFloatImage, float * RESTRICT pFloatImageBump1, float * RESTRICT pFloatImageBump2, float * RESTRICT pFloatImageBump3, int pLightmapSize[2], int pOffsetIntoLightmapPage[2], FloatBitMap_t *pfmOut ) RESTRICT { const int nLightmapSize0 = pLightmapSize[0]; const int nLightmap0WriterSizeBytes = nLightmapSize0 * m_LightmapPixelWriter.GetPixelSize(); const int nRewindToNextPixel = -( ( nLightmap0WriterSizeBytes * 3 ) - m_LightmapPixelWriter.GetPixelSize() ); if( m_LightmapPixelWriter.IsUsingFloatFormat() ) { AssertMsg(!IsX360(), "Tried to use a floating-point pixel format for lightmaps on 360, which is not supported."); if (!IsX360()) { for( int t = 0; t < pLightmapSize[1]; t++ ) { int srcTexelOffset = ( sizeof( Vector4D ) / sizeof( float ) ) * ( 0 + t * nLightmapSize0 ); m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); for( int s = 0; s < nLightmapSize0; s++, m_LightmapPixelWriter.SkipBytes(nRewindToNextPixel),srcTexelOffset += (sizeof(Vector4D)/sizeof(float))) { unsigned short color[4][4]; ColorSpace::LinearToBumpedLightmap( &pFloatImage[srcTexelOffset], &pFloatImageBump1[srcTexelOffset], &pFloatImageBump2[srcTexelOffset], &pFloatImageBump3[srcTexelOffset], color[0], color[1], color[2], color[3] ); float alpha = pFloatImage[srcTexelOffset+3]; Assert( alpha >= 0.0f && alpha <= 1.0f ); if ( HardwareConfig()->GetCSMAccurateBlending() ) { float alphaF[4]; ColorSpace::LinearToBumpedLightmapAlpha( &pFloatImage[srcTexelOffset + 3], &pFloatImageBump1[srcTexelOffset + 3], &pFloatImageBump2[srcTexelOffset + 3], &pFloatImageBump3[srcTexelOffset + 3], &alphaF[0], &alphaF[1], &alphaF[2], &alphaF[3] ); unsigned short alphaUS[4]; alphaUS[0] = ColorSpace::LinearToUnsignedShort( alphaF[0], 16 ); alphaUS[1] = ColorSpace::LinearToUnsignedShort( alphaF[1], 16 ); alphaUS[2] = ColorSpace::LinearToUnsignedShort( alphaF[2], 16 ); alphaUS[3] = ColorSpace::LinearToUnsignedShort( alphaF[3], 16 ); color[0][3] = alphaUS[0]; color[1][3] = alphaUS[1]; color[2][3] = alphaUS[2]; color[3][3] = alphaUS[3]; } else { color[0][3] = color[1][3] = color[2][3] = color[3][3] = alpha; } float toFloat = ( 1.0f / ( float )( 1 << 16 ) ); /* // This code is now a can't-happen, because we do not allow float formats on 360. #if ( defined( USE_32BIT_LIGHTMAPS_ON_360 ) ) if( IsX360() ) { for( int i = 0; i != 4; ++i ) { Vector4D vRGBScale; vRGBScale.x = color[i][0] * (16.0f / 65535.0f); vRGBScale.y = color[i][1] * (16.0f / 65535.0f); vRGBScale.z = color[i][2] * (16.0f / 65535.0f); vRGBScale = ConvertLightmapColorToRGBScale( &vRGBScale.x ); color[i][0] = RoundFloatToByte( vRGBScale.x * 255.0f ); color[i][1] = RoundFloatToByte( vRGBScale.y * 255.0f ); color[i][2] = RoundFloatToByte( vRGBScale.z * 255.0f ); color[i][3] = RoundFloatToByte( vRGBScale.w * 255.0f ); } toFloat = ( 1.0f / ( float )( 1 << 8 ) ); } #endif */ m_LightmapPixelWriter.WritePixelNoAdvanceF( toFloat * color[0][0], toFloat * color[0][1], toFloat * color[0][2], toFloat * color[0][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvanceF( toFloat * color[1][0], toFloat * color[1][1], toFloat * color[1][2], toFloat * color[1][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvanceF( toFloat * color[2][0], toFloat * color[2][1], toFloat * color[2][2], toFloat * color[2][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvanceF( toFloat * color[3][0], toFloat * color[3][1], toFloat * color[3][2], toFloat * color[3][3] ); } } } } else { #ifndef X360_USE_SIMD_LIGHTMAP for( int t = 0; t < pLightmapSize[1]; t++ ) { int srcTexelOffset = ( sizeof( Vector4D ) / sizeof( float ) ) * ( 0 + t * nLightmapSize0 ); m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); for( int s = 0; s < nLightmapSize0; s++, m_LightmapPixelWriter.SkipBytes(nRewindToNextPixel),srcTexelOffset += (sizeof(Vector4D)/sizeof(float))) { unsigned short color[4][4]; ColorSpace::LinearToBumpedLightmap( &pFloatImage[srcTexelOffset], &pFloatImageBump1[srcTexelOffset], &pFloatImageBump2[srcTexelOffset], &pFloatImageBump3[srcTexelOffset], color[0], color[1], color[2], color[3] ); if ( HardwareConfig()->GetCSMAccurateBlending() ) { float alpha[4]; ColorSpace::LinearToBumpedLightmapAlpha( &pFloatImage[srcTexelOffset + 3], &pFloatImageBump1[srcTexelOffset + 3], &pFloatImageBump2[srcTexelOffset + 3], &pFloatImageBump3[srcTexelOffset + 3], &alpha[0], &alpha[1], &alpha[2], &alpha[3] ); unsigned short alphaUS[4]; alphaUS[0] = ColorSpace::LinearToUnsignedShort( alpha[0], 16 ); alphaUS[1] = ColorSpace::LinearToUnsignedShort( alpha[1], 16 ); alphaUS[2] = ColorSpace::LinearToUnsignedShort( alpha[2], 16 ); alphaUS[3] = ColorSpace::LinearToUnsignedShort( alpha[3], 16 ); color[0][3] = alphaUS[0]; color[1][3] = alphaUS[1]; color[2][3] = alphaUS[2]; color[3][3] = alphaUS[3]; } else { unsigned short alpha = ColorSpace::LinearToUnsignedShort( pFloatImage[srcTexelOffset+3], 16 ); color[0][3] = color[1][3] = color[2][3] = color[3][3] = alpha; } #if ( defined( USE_32BIT_LIGHTMAPS_ON_360 ) ) if( IsX360() ) { for( int i = 0; i != 4; ++i ) { Vector4D vRGBScale; vRGBScale.x = color[i][0] * (16.0f / 65535.0f); vRGBScale.y = color[i][1] * (16.0f / 65535.0f); vRGBScale.z = color[i][2] * (16.0f / 65535.0f); vRGBScale = ConvertLightmapColorToRGBScale( &vRGBScale.x ); color[i][0] = RoundFloatToByte( vRGBScale.x * 255.0f ); color[i][1] = RoundFloatToByte( vRGBScale.y * 255.0f ); color[i][2] = RoundFloatToByte( vRGBScale.z * 255.0f ); color[i][3] = RoundFloatToByte( vRGBScale.w * 255.0f ); } } #endif m_LightmapPixelWriter.WritePixelNoAdvance( color[0][0], color[0][1], color[0][2], color[0][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvance( color[1][0], color[1][1], color[1][2], color[1][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvance( color[2][0], color[2][1], color[2][2], color[2][3] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvance( color[3][0], color[3][1], color[3][2], color[3][3] ); // Write data to the bitmapped represenations so that PFM files can be written if ( pfmOut ) { PixRGBAF pixelData; pixelData.Red = color[0][0]; pixelData.Green = color[0][1]; pixelData.Blue = color[0][2]; pixelData.Alpha = color[0][3]; pfmOut->WritePixelRGBAF(pOffsetIntoLightmapPage[0] + s, pOffsetIntoLightmapPage[1] + t, 0, pixelData); } } } #else // this is an optimized XBOX implementation. For a clearer // presentation of the algorithm, see the PC implementation // above. // First check for the most common case, using an efficient // branch rather than a switch: if (m_LightmapPixelWriter.GetFormat() == IMAGE_FORMAT_LINEAR_BGRA8888) { // broken out into a static to make things more readable // and be nicer to the instruction cache BumpedLightmapBitsToPixelWriter_HDRI_BGRA_X360( pFloatImage, pFloatImageBump1, pFloatImageBump2, pFloatImageBump3, pLightmapSize, pOffsetIntoLightmapPage, pfmOut, &m_LightmapPixelWriter ); } else { // This case is used in Portal 2 to fill RGBA16161616 lightmaps Assert( m_LightmapPixelWriter.GetPixelSize() == 8 ); for( int t = 0; t < pLightmapSize[1]; t++ ) { // assert that 1 * 4 = 4 COMPILE_TIME_ASSERT(sizeof( Vector4D ) == sizeof(float) * 4); #define FOUR (sizeof( Vector4D ) / sizeof( float )) // in case this ever changes int srcTexelOffset = ( FOUR ) * ( 0 + t * nLightmapSize0 ); m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); for( int s = 0; s < nLightmapSize0; s++, m_LightmapPixelWriter.SkipBytes(nRewindToNextPixel),srcTexelOffset += ( FOUR )) { static const fltx4 vSixteen = {16.0f, 16.0f, 16.0f, 16.0f}; fltx4 vColor[4]; fltx4 vFloatImage = LoadUnalignedSIMD(&pFloatImage[srcTexelOffset]); fltx4 vFloatImageBump1 = LoadUnalignedSIMD(&pFloatImageBump1[srcTexelOffset]); fltx4 vFloatImageBump2 = LoadUnalignedSIMD(&pFloatImageBump2[srcTexelOffset]); fltx4 vFloatImageBump3 = LoadUnalignedSIMD(&pFloatImageBump3[srcTexelOffset]); // perform an arcane averaging operation upon the bump map values ColorSpace::LinearToBumpedLightmap( vFloatImage, vFloatImageBump1, vFloatImageBump2, vFloatImageBump3, vColor[0], vColor[1], vColor[2], vColor[3] ); // convert each color to RGB scaled. // DO NOT! make this into a for loop. The (April07 XDK) compiler // in fact DOES NOT unroll them, and will perform very naive // scheduling if you try. // clamp to 0..16 float vColor[0] = MinSIMD(vColor[0], vSixteen); vColor[1] = MinSIMD(vColor[1], vSixteen); vColor[2] = MinSIMD(vColor[2], vSixteen); vColor[3] = MinSIMD(vColor[3], vSixteen); // Not doing the following anymore. This path is for writing 16161616 int lightmaps. /* // compute the scaling factor, transform the RGB, // and place the scale in w. Obliterates whatever was // already in alpha. // This code is why it is important to not use a for // loop: you need to let the compiler interleave the // inlined instructions. vColor[0] = ConvertLightmapColorToRGBScale( vColor[0] ); vColor[1] = ConvertLightmapColorToRGBScale( vColor[1] ); vColor[2] = ConvertLightmapColorToRGBScale( vColor[2] ); vColor[3] = ConvertLightmapColorToRGBScale( vColor[3] ); */ m_LightmapPixelWriter.WritePixelNoAdvance( vColor[0] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvance( vColor[1] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvance( vColor[2] ); m_LightmapPixelWriter.SkipBytes( nLightmap0WriterSizeBytes ); m_LightmapPixelWriter.WritePixelNoAdvance( vColor[3] ); AssertMsg(!pfmOut, "Runtime conversion of lightmaps to files is no longer supported on 360.\n"); // Write data to the bitmapped represenations so that PFM files can be written if ( pfmOut ) { Warning("**************************************************\n" "Lightmap output to files on 360 HAS BEEN DISABLED.\n" "A grave error has just occurred.\n" "**************************************************\n"); DebuggerBreakIfDebugging(); /* PixRGBAF pixelData; pixelData.Red = color[0][0]; pixelData.Green = color[0][1]; pixelData.Blue = color[0][2]; pixelData.Alpha = alpha; pfmOut->WritePixelRGBAF(pOffsetIntoLightmapPage[0] + s, pOffsetIntoLightmapPage[1] + t, pixelData); */ } } } } #endif } } void CMatLightmaps::LightmapBitsToPixelWriter_LDR( float* pFloatImage, int pLightmapSize[2], int pOffsetIntoLightmapPage[2], FloatBitMap_t *pfmOut ) { // non-HDR lightmap processing float *pSrc = pFloatImage; for( int t = 0; t < pLightmapSize[1]; ++t ) { m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); for( int s = 0; s < pLightmapSize[0]; ++s, pSrc += (sizeof(Vector4D)/sizeof(*pSrc)) ) { unsigned char color[4]; ColorSpace::LinearToLightmap( color, pSrc ); if ( HardwareConfig()->GetCSMAccurateBlending() ) { ColorSpace::LinearToLightmapAlpha( &color[3], pSrc[3] ); } else { color[3] = RoundFloatToByte( pSrc[3] * 255.0f ); } m_LightmapPixelWriter.WritePixel( color[0], color[1], color[2], color[3] ); if ( pfmOut ) { // Write data to the bitmapped represenations so that PFM files can be written PixRGBAF pixelData; pixelData.Red = color[0]; pixelData.Green = color[1]; pixelData.Blue = color[2]; pixelData.Alpha = color[3]; pfmOut->WritePixelRGBAF( pOffsetIntoLightmapPage[0] + s, pOffsetIntoLightmapPage[1] + t, 0, pixelData ); } } } } void CMatLightmaps::LightmapBitsToPixelWriter_HDRF( float* pFloatImage, int pLightmapSize[2], int pOffsetIntoLightmapPage[2], FloatBitMap_t *pfmOut ) { if ( IsX360() ) { // 360 does not support HDR float Assert( 0 ); return; } // float HDR lightmap processing float *pSrc = pFloatImage; for ( int t = 0; t < pLightmapSize[1]; ++t ) { m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); if ( HardwareConfig()->GetCSMAccurateBlending() ) { ColorSpace::LinearToLightmapAlpha( &pSrc[3] ); } for ( int s = 0; s < pLightmapSize[0]; ++s, pSrc += (sizeof(Vector4D)/sizeof(*pSrc)) ) { m_LightmapPixelWriter.WritePixelF( pSrc[0], pSrc[1], pSrc[2], pSrc[3] ); } } } // numbers come in on the domain [0..16] void CMatLightmaps::LightmapBitsToPixelWriter_HDRI( float* RESTRICT pFloatImage, int pLightmapSize[2], int pOffsetIntoLightmapPage[2], FloatBitMap_t * RESTRICT pfmOut ) { #ifndef X360_USE_SIMD_LIGHTMAP // PC code (and old, pre-SIMD xbox version -- unshippably slow) if ( m_LightmapPixelWriter.IsUsingFloatFormat() ) { // integer HDR lightmap processing float *pSrc = pFloatImage; for ( int t = 0; t < pLightmapSize[1]; ++t ) { m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); for ( int s = 0; s < pLightmapSize[0]; ++s, pSrc += (sizeof(Vector4D)/sizeof(*pSrc)) ) { int r, g, b, a; r = ColorSpace::LinearFloatToCorrectedShort( pSrc[0] ); g = ColorSpace::LinearFloatToCorrectedShort( pSrc[1] ); b = ColorSpace::LinearFloatToCorrectedShort( pSrc[2] ); if ( HardwareConfig()->GetCSMAccurateBlending() ) { ColorSpace::LinearToLightmapAlpha( &a, pSrc[3] ); } else { a = ColorSpace::LinearToUnsignedShort( pSrc[3], 16 ); } float toFloat = ( 1.0f / ( float )( 1 << 16 ) ); #if ( defined( USE_32BIT_LIGHTMAPS_ON_360 ) ) if( IsX360() ) { Vector4D vRGBScale; vRGBScale.x = r * (16.0f / 65535.0f); vRGBScale.y = g * (16.0f / 65535.0f); vRGBScale.z = b * (16.0f / 65535.0f); vRGBScale = ConvertLightmapColorToRGBScale( &vRGBScale.x ); r = RoundFloatToByte( vRGBScale.x * 255.0f ); g = RoundFloatToByte( vRGBScale.y * 255.0f ); b = RoundFloatToByte( vRGBScale.z * 255.0f ); a = RoundFloatToByte( vRGBScale.w * 255.0f ); toFloat = ( 1.0f / ( float )( 1 << 8 ) ); } #endif Assert( pSrc[3] >= 0.0f && pSrc[3] <= 1.0f ); m_LightmapPixelWriter.WritePixelF( r * toFloat, g * toFloat, b * toFloat, pSrc[3] ); } } } else { // integer HDR lightmap processing float *pSrc = pFloatImage; for ( int t = 0; t < pLightmapSize[1]; ++t ) { m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); for ( int s = 0; s < pLightmapSize[0]; ++s, pSrc += (sizeof(Vector4D)/sizeof(*pSrc)) ) { int r, g, b, a; r = ColorSpace::LinearFloatToCorrectedShort( pSrc[0] ); g = ColorSpace::LinearFloatToCorrectedShort( pSrc[1] ); b = ColorSpace::LinearFloatToCorrectedShort( pSrc[2] ); if ( HardwareConfig()->GetCSMAccurateBlending() ) { ColorSpace::LinearToLightmapAlpha( &a, pSrc[3] ); } else { a = ColorSpace::LinearToUnsignedShort( pSrc[3], 16 ); } #if ( defined( USE_32BIT_LIGHTMAPS_ON_360 ) ) if( IsX360() ) { Vector4D vRGBScale; vRGBScale.x = r * (16.0f / 65535.0f); vRGBScale.y = g * (16.0f / 65535.0f); vRGBScale.z = b * (16.0f / 65535.0f); vRGBScale = ConvertLightmapColorToRGBScale( &vRGBScale.x ); r = RoundFloatToByte( vRGBScale.x * 255.0f ); g = RoundFloatToByte( vRGBScale.y * 255.0f ); b = RoundFloatToByte( vRGBScale.z * 255.0f ); a = RoundFloatToByte( vRGBScale.w * 255.0f ); } #endif m_LightmapPixelWriter.WritePixel( r, g, b, a ); if ( pfmOut ) { // Write data to the bitmapped represenations so that PFM files can be written PixRGBAF pixelData; pixelData.Red = pSrc[0]; pixelData.Green = pSrc[1]; pixelData.Blue = pSrc[2]; pixelData.Alpha = pSrc[3]; pfmOut->WritePixelRGBAF( pOffsetIntoLightmapPage[0] + s, pOffsetIntoLightmapPage[1] + t, 0, pixelData ); } } } } #else // XBOX360 code if ( m_LightmapPixelWriter.IsUsingFloatFormat() ) { if( IsX360() ) { AssertMsg( false, "Float-format pixel writers do not exist on x360." ); } else { // This code is here as an example only, in case floating point // format is restored to 360. // integer HDR lightmap processing float * RESTRICT pSrc = pFloatImage; for ( int t = 0; t < pLightmapSize[1]; ++t ) { m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); for ( int s = 0; s < pLightmapSize[0]; ++s, pSrc += (sizeof(Vector4D)/sizeof(*pSrc)) ) { int r, g, b, a; r = ColorSpace::LinearFloatToCorrectedShort( pSrc[0] ); g = ColorSpace::LinearFloatToCorrectedShort( pSrc[1] ); b = ColorSpace::LinearFloatToCorrectedShort( pSrc[2] ); a = ColorSpace::LinearToUnsignedShort( pSrc[3], 16 ); float toFloat = ( 1.0f / ( float )( 1 << 16 ) ); #if ( defined( USE_32BIT_LIGHTMAPS_ON_360 ) ) if( IsX360() ) { Vector4D vRGBScale; vRGBScale.x = r * (16.0f / 65535.0f); vRGBScale.y = g * (16.0f / 65535.0f); vRGBScale.z = b * (16.0f / 65535.0f); vRGBScale = ConvertLightmapColorToRGBScale( &vRGBScale.x ); r = RoundFloatToByte( vRGBScale.x * 255.0f ); g = RoundFloatToByte( vRGBScale.y * 255.0f ); b = RoundFloatToByte( vRGBScale.z * 255.0f ); a = RoundFloatToByte( vRGBScale.w * 255.0f ); toFloat = ( 1.0f / ( float )( 1 << 8 ) ); } #endif Assert( pSrc[3] >= 0.0f && pSrc[3] <= 1.0f ); m_LightmapPixelWriter.WritePixelF( r * toFloat, g * toFloat, b * toFloat, pSrc[3] ); } } } } else { // This is the fast X360 pathway. // integer HDR lightmap processing float * RESTRICT pSrc = pFloatImage; // Assert((reinterpret_cast(pSrc) & 15) == 0); // 16-byte aligned? COMPILE_TIME_ASSERT(sizeof(Vector4D)/sizeof(*pSrc) == 4); // assert that 1 * 4 = 4 // input numbers from pSrc are on the domain [0..+inf] // we clamp them to the range [0..16] // output is RGBA // the shader does this: rOut = Rin * Ain * 16.0f // where Rin is [0..1], a float computed from a byte value [0..255] // Ain is therefore the brightest channel (say R) divided by 16 and quantized // Rin is computed from pSrc->r by dividing by Ain // rather than switching inside WritePixel for each different format, // thus causing a 23-cycle pipeline clear for every pixel, we'll // branch on the format here. That will allow us to unroll the inline // pixel write functions differently depending on their different // latencies. Assert(!pfmOut); // should never happen on 360. #ifndef ALLOW_PFM_OUTPUT_ON_360 if ( pfmOut ) { Warning("*****************************************\n" "Lightmap output on 360 HAS BEEN DISABLED.\n" "A grave error has just occurred.\n" "*****************************************\n"); } #endif // switch once, here, outside the loop, rather than // switching inside each pixel. Switches are not fast // on x360: they are usually implemented as jumps // through function tables, which have a 24-cycle // stall. switch (m_LightmapPixelWriter.GetFormat()) { // note: format names are low-order-byte first. case IMAGE_FORMAT_RGBA8888: case IMAGE_FORMAT_LINEAR_RGBA8888: { for ( int t = 0; t < pLightmapSize[1]; ++t ) { m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); for ( int s = 0; s < pLightmapSize[0]; ++s, pSrc += 4 ) { static const fltx4 vSixteen = {16.0f, 16.0f, 16.0f, 16.0f}; fltx4 rgba = LoadUnalignedSIMD(pSrc); // clamp to 0..16 float rgba = MinSIMD(rgba, vSixteen); // compute the scaling factor, place it in w, and // scale the rest by it. rgba = ConvertLightmapColorToRGBScale( rgba ); // rgba is now float 0..255 in each component m_LightmapPixelWriter.WritePixelNoAdvance_RGBA8888(rgba); /* // not supported on X360 if ( pfmOut ) { // Write data to the bitmapped represenations so that PFM files can be written PixRGBAF pixelData; XMStoreVector4(&pixelData,rgba); pfmOut->WritePixelRGBAF( pOffsetIntoLightmapPage[0] + s, pOffsetIntoLightmapPage[1] + t, pixelData ); } */ } } break; } case IMAGE_FORMAT_BGRA8888: // NOTE! : the low order bits are first in this naming convention. case IMAGE_FORMAT_LINEAR_BGRA8888: { for ( int t = 0; t < pLightmapSize[1]; ++t ) { m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); for ( int s = 0; s < pLightmapSize[0]; ++s, pSrc += 4 ) { static const fltx4 vSixteen = {16.0f, 16.0f, 16.0f, 16.0f}; fltx4 rgba = LoadUnalignedSIMD(pSrc); // clamp to 0..16 float rgba = MinSIMD(rgba, vSixteen); // compute the scaling factor, place it in w, and // scale the rest by it. rgba = ConvertLightmapColorToRGBScale( rgba ); // rgba is now float 0..255 in each component m_LightmapPixelWriter.WritePixelNoAdvance_BGRA8888(rgba); // forcibly advance m_LightmapPixelWriter.SkipBytes(4); /* // not supported on X360 if ( pfmOut ) { // Write data to the bitmapped represenations so that PFM files can be written PixRGBAF pixelData; XMStoreVector4(&pixelData,rgba); pfmOut->WritePixelRGBAF( pOffsetIntoLightmapPage[0] + s, pOffsetIntoLightmapPage[1] + t, pixelData ); } */ } } break; } case IMAGE_FORMAT_RGBA16161616: case IMAGE_FORMAT_LINEAR_RGBA16161616: { for ( int t = 0; t < pLightmapSize[1]; ++t ) { m_LightmapPixelWriter.Seek( pOffsetIntoLightmapPage[0], pOffsetIntoLightmapPage[1] + t ); for ( int s = 0; s < pLightmapSize[0]; ++s, pSrc += 4 ) { static const fltx4 vSixteen = {16.0f, 16.0f, 16.0f, 16.0f}; fltx4 rgba = LoadUnalignedSIMD(pSrc); rgba = MinSIMD(rgba, vSixteen); // clamp to 0..16 float m_LightmapPixelWriter.WritePixelNoAdvance_RGBA16161616(rgba); m_LightmapPixelWriter.SkipBytes(8); } } break; } default: AssertMsg1(false,"Unsupported pixel format %d while writing lightmaps!", m_LightmapPixelWriter.GetFormat() ); Warning("Unsupported pixel format used in lightmap. Lightmaps could not be downloaded.\n"); break; } } #endif } void CMatLightmaps::BeginUpdateLightmaps( void ) { CMatCallQueue *pCallQueue = GetMaterialSystem()->GetRenderContextInternal()->GetCallQueueInternal(); if ( pCallQueue ) { pCallQueue->QueueCall( this, &CMatLightmaps::BeginUpdateLightmaps ); return; } m_nUpdatingLightmapsStackDepth++; } void CMatLightmaps::EndUpdateLightmaps( void ) { CMatCallQueue *pCallQueue = GetMaterialSystem()->GetRenderContextInternal()->GetCallQueueInternal(); if ( pCallQueue ) { pCallQueue->QueueCall( this, &CMatLightmaps::EndUpdateLightmaps ); return; } m_nUpdatingLightmapsStackDepth--; Assert( m_nUpdatingLightmapsStackDepth >= 0 ); if( m_nUpdatingLightmapsStackDepth <= 0 && m_nLockedLightmap != -1 ) { g_pShaderAPI->TexUnlock(); m_nLockedLightmap = -1; } } int CMatLightmaps::AllocateDynamicLightmap( int lightmapSize[2], int *pOutOffsetIntoPage, int frameID ) { // check frameID, fail if current for ( int i = 0; i < COUNT_DYNAMIC_LIGHTMAP_PAGES; i++ ) { int dynamicIndex = (m_dynamic.currentDynamicIndex + i) % COUNT_DYNAMIC_LIGHTMAP_PAGES; int lightmapPageIndex = m_firstDynamicLightmap + dynamicIndex; if ( m_dynamic.lightmapLockFrame[dynamicIndex] != frameID ) { m_dynamic.lightmapLockFrame[dynamicIndex] = frameID; m_dynamic.imagePackers[dynamicIndex].Reset( 0, m_pLightmapPages[lightmapPageIndex].m_Width, m_pLightmapPages[lightmapPageIndex].m_Height ); } if ( m_dynamic.imagePackers[dynamicIndex].AddBlock( lightmapSize[0], lightmapSize[1], &pOutOffsetIntoPage[0], &pOutOffsetIntoPage[1] ) ) { return lightmapPageIndex; } } return -1; } //----------------------------------------------------------------------------- // Updates the lightmap //----------------------------------------------------------------------------- void CMatLightmaps::UpdateLightmap( int lightmapPageID, int lightmapSize[2], int offsetIntoLightmapPage[2], float *pFloatImage, float *pFloatImageBump1, float *pFloatImageBump2, float *pFloatImageBump3 ) { VPROF( "CMatRenderContext::UpdateLightmap" ); bool hasBump = false; int uSize = 1; FloatBitMap_t *pfmOut = NULL; if ( pFloatImageBump1 && pFloatImageBump2 && pFloatImageBump3 ) { hasBump = true; uSize = 4; } if ( lightmapPageID >= GetNumLightmapPages() || lightmapPageID < 0 ) { Error( "MaterialSystem_Interface_t::UpdateLightmap lightmapPageID=%d out of range\n", lightmapPageID ); return; } bool bDynamic = IsDynamicLightmap(lightmapPageID); if ( bDynamic ) { int dynamicIndex = lightmapPageID-m_firstDynamicLightmap; Assert(dynamicIndex < COUNT_DYNAMIC_LIGHTMAP_PAGES); m_dynamic.currentDynamicIndex = (dynamicIndex + 1) % COUNT_DYNAMIC_LIGHTMAP_PAGES; } if ( mat_lightmap_pfms.GetBool()) { // Allocate and initialize lightmap data that will be written to a PFM file if (NULL == m_pLightmapDataPtrArray[lightmapPageID]) { m_pLightmapDataPtrArray[lightmapPageID] = new FloatBitMap_t(m_pLightmapPages[lightmapPageID].m_Width, m_pLightmapPages[lightmapPageID].m_Height); m_pLightmapDataPtrArray[lightmapPageID]->Clear(0, 0, 0, 1); } pfmOut = m_pLightmapDataPtrArray[lightmapPageID]; } // NOTE: Change how the lock is taking place if you ever change how bumped // lightmaps are put into the page. Right now, we assume that they're all // added to the right of the original lightmap. bool bLockSubRect; { VPROF_( "Locking lightmaps", 2, VPROF_BUDGETGROUP_DLIGHT_RENDERING, false, 0 ); // vprof scope bLockSubRect = m_nUpdatingLightmapsStackDepth <= 0 && !bDynamic; if( bLockSubRect ) { VPROF_INCREMENT_COUNTER( "lightmap subrect texlock", 1 ); g_pShaderAPI->ModifyTexture( m_LightmapPageTextureHandles[lightmapPageID] ); if (!g_pShaderAPI->TexLock( 0, 0, offsetIntoLightmapPage[0], offsetIntoLightmapPage[1], lightmapSize[0] * uSize, lightmapSize[1], m_LightmapPixelWriter )) { return; } } else if( lightmapPageID != m_nLockedLightmap ) { if ( !LockLightmap( lightmapPageID ) ) { ExecuteNTimes( 10, Warning( "Failed to lock lightmap\n" ) ); return; } } } int subRectOffset[2] = {0,0}; { // account for the part spent in math: VPROF_( "LightmapBitsToPixelWriter", 2, VPROF_BUDGETGROUP_DLIGHT_RENDERING, false, 0 ); #ifdef _PS3 // PS3 uses 16-bit half floats per channel...but the HDR_TYPE_FLOAT codepath has a lot of other assumptions, so just // lie about the format right here on PS3 only if ( hasBump ) { BumpedLightmapBitsToPixelWriter_HDRF( pFloatImage, pFloatImageBump1, pFloatImageBump2, pFloatImageBump3, lightmapSize, bLockSubRect ? subRectOffset : offsetIntoLightmapPage, pfmOut ); } else { LightmapBitsToPixelWriter_HDRF( pFloatImage, lightmapSize, bLockSubRect ? subRectOffset : offsetIntoLightmapPage, pfmOut ); } #else // _PS3 if ( hasBump ) { switch( HardwareConfig()->GetHDRType() ) { case HDR_TYPE_NONE: BumpedLightmapBitsToPixelWriter_LDR( pFloatImage, pFloatImageBump1, pFloatImageBump2, pFloatImageBump3, lightmapSize, bLockSubRect ? subRectOffset : offsetIntoLightmapPage, pfmOut ); break; case HDR_TYPE_INTEGER: BumpedLightmapBitsToPixelWriter_HDRI( pFloatImage, pFloatImageBump1, pFloatImageBump2, pFloatImageBump3, lightmapSize, bLockSubRect ? subRectOffset : offsetIntoLightmapPage, pfmOut ); break; case HDR_TYPE_FLOAT: BumpedLightmapBitsToPixelWriter_HDRF( pFloatImage, pFloatImageBump1, pFloatImageBump2, pFloatImageBump3, lightmapSize, bLockSubRect ? subRectOffset : offsetIntoLightmapPage, pfmOut ); break; } } else { switch ( HardwareConfig()->GetHDRType() ) { case HDR_TYPE_NONE: LightmapBitsToPixelWriter_LDR( pFloatImage, lightmapSize, bLockSubRect ? subRectOffset : offsetIntoLightmapPage, pfmOut ); break; case HDR_TYPE_INTEGER: LightmapBitsToPixelWriter_HDRI( pFloatImage, lightmapSize, bLockSubRect ? subRectOffset : offsetIntoLightmapPage, pfmOut ); break; case HDR_TYPE_FLOAT: LightmapBitsToPixelWriter_HDRF( pFloatImage, lightmapSize, bLockSubRect ? subRectOffset : offsetIntoLightmapPage, pfmOut ); break; default: Assert( 0 ); break; } } #endif // !_PS3 } if( bLockSubRect ) { VPROF_( "Unlocking Lightmaps", 2, VPROF_BUDGETGROUP_DLIGHT_RENDERING, false, 0 ); g_pShaderAPI->TexUnlock(); } } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- int CMatLightmaps::GetNumSortIDs( void ) { return m_numSortIDs; } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void CMatLightmaps::ComputeSortInfo( MaterialSystem_SortInfo_t* pInfo, int& sortId, bool alpha ) { int lightmapPageID; for ( MaterialHandle_t i = GetMaterialDict()->FirstMaterial(); i != GetMaterialDict()->InvalidMaterial(); i = GetMaterialDict()->NextMaterial(i) ) { IMaterialInternal* pMaterial = GetMaterialInternal(i); if ( pMaterial->GetMinLightmapPageID() > pMaterial->GetMaxLightmapPageID() ) { continue; } // const IMaterialVar *pTransVar = pMaterial->GetMaterialProperty( MATERIAL_PROPERTY_OPACITY ); // if( ( !alpha && ( pTransVar->GetIntValue() == MATERIAL_TRANSLUCENT ) ) || // ( alpha && !( pTransVar->GetIntValue() == MATERIAL_TRANSLUCENT ) ) ) // { // return true; // } // Warning( "sort stuff: %s %s\n", material->GetName(), bAlpha ? "alpha" : "not alpha" ); // fill in the lightmapped materials for ( lightmapPageID = pMaterial->GetMinLightmapPageID(); lightmapPageID <= pMaterial->GetMaxLightmapPageID(); ++lightmapPageID ) { pInfo[sortId].material = pMaterial->GetQueueFriendlyVersion(); pInfo[sortId].lightmapPageID = lightmapPageID; #if 0 char buf[128]; Q_snprintf( buf, sizeof( buf ), "ComputeSortInfo: %s lightmapPageID: %d sortID: %d\n", pMaterial->GetName(), lightmapPageID, sortId ); OutputDebugString( buf ); #endif ++sortId; } } } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void CMatLightmaps::ComputeWhiteLightmappedSortInfo( MaterialSystem_SortInfo_t* pInfo, int& sortId, bool alpha ) { for (MaterialHandle_t i = GetMaterialDict()->FirstMaterial(); i != GetMaterialDict()->InvalidMaterial(); i = GetMaterialDict()->NextMaterial(i) ) { IMaterialInternal* pMaterial = GetMaterialInternal(i); // fill in the lightmapped materials that are actually used by this level if( pMaterial->GetNeedsWhiteLightmap() && ( pMaterial->GetReferenceCount() > 0 ) ) { // const IMaterialVar *pTransVar = pMaterial->GetMaterialProperty( MATERIAL_PROPERTY_OPACITY ); // if( ( !alpha && ( pTransVar->GetIntValue() == MATERIAL_TRANSLUCENT ) ) || // ( alpha && !( pTransVar->GetIntValue() == MATERIAL_TRANSLUCENT ) ) ) // { // return true; // } pInfo[sortId].material = pMaterial->GetQueueFriendlyVersion(); if( pMaterial->GetPropertyFlag( MATERIAL_PROPERTY_NEEDS_BUMPED_LIGHTMAPS ) ) { pInfo[sortId].lightmapPageID = MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP; } else { pInfo[sortId].lightmapPageID = MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE; } sortId++; } } } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void CMatLightmaps::GetSortInfo( MaterialSystem_SortInfo_t *pSortInfoArray ) { // sort non-alpha blended materials first int sortId = 0; ComputeSortInfo( pSortInfoArray, sortId, false ); ComputeWhiteLightmappedSortInfo( pSortInfoArray, sortId, false ); Assert( m_numSortIDs == sortId ); } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void CMatLightmaps::EnableLightmapFiltering( bool enabled ) { int i; for( i = 0; i < GetNumLightmapPages(); i++ ) { g_pShaderAPI->ModifyTexture( m_LightmapPageTextureHandles[i] ); if( enabled ) { g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR ); g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR ); } else { g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_NEAREST ); g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_NEAREST ); } } }