BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/engine/buildcubemaps.cpp

1147 lines
34 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $Workfile: $
// $Date: $
// $NoKeywords: $
//===========================================================================//
// HDRFIXME: reduce the number of include files here.
#include "render_pch.h"
#include "client.h"
#include "cdll_int.h"
#include "lightcache.h"
#include "client_class.h"
#include "icliententitylist.h"
#include "traceinit.h"
#include "server.h"
#include "ispatialpartitioninternal.h"
#include "cdll_engine_int.h"
#include "filesystem.h"
#include "filesystem_engine.h"
#include "ivtex.h"
#include "materialsystem/itexture.h"
#include "view.h"
#include "tier0/dbg.h"
#include "tier2/fileutils.h"
#include "staticpropmgr.h"
#include "icliententity.h"
#include "gl_drawlights.h"
#include "Overlay.h"
#include "vmodes.h"
#include "gl_cvars.h"
#include "utlbuffer.h"
#include "vtf/vtf.h"
#include "bitmap/imageformat.h"
#include "cbenchmark.h"
#include "r_decal.h"
#include "ivideomode.h"
#include "tier0/icommandline.h"
#include "dmxloader/dmxelement.h"
#include "dmxloader/dmxloader.h"
#include "bitmap/float_bm.h"
#include "tier2/tier2.h"
#include "../utils/common/bsplib.h"
#include "ibsppack.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// putting this here so that it is replicated to the client.dll and materialsystem.dll
ConVar dynamic_tonemap( "mat_dynamic_tonemapping", "1", FCVAR_CHEAT );
ConVar building_cubemaps( "building_cubemaps", "0" );
ConVar reload_materials( "reload_materials", "0" );
ConVar r_DrawBeams( "r_DrawBeams", "1", FCVAR_CHEAT, "0=Off, 1=Normal, 2=Wireframe" );
static ConVar mat_force_tonemap_scale( "mat_force_tonemap_scale", "0.0", FCVAR_CHEAT );
static const char *facingName[6] = { "rt", "lf", "bk", "ft", "up", "dn" };
//-----------------------------------------------------------------------------
// Load, unload vtex
//-----------------------------------------------------------------------------
IVTex* VTex_Load( CSysModule** pModule )
{
// load the vtex dll
IVTex *pIVTex = NULL;
*pModule = FileSystem_LoadModule( "vtex_dll" );
if ( *pModule )
{
CreateInterfaceFn factory = Sys_GetFactory( *pModule );
if ( factory )
{
pIVTex = ( IVTex * )factory( IVTEX_VERSION_STRING, NULL );
}
}
if ( !pIVTex )
{
ConMsg( "Can't load vtex_dll.dll\n" );
}
return pIVTex;
}
void VTex_Unload( CSysModule *pModule )
{
FileSystem_UnloadModule( pModule );
}
//-----------------------------------------------------------------------------
// Main entry point for taking cubemap snapshots
//-----------------------------------------------------------------------------
static void TakeCubemapSnapshot( const Vector &origin, const char *pFileNameBase, int screenBufSize,
int tgaSize, bool bPFM )
{
if ( IsX360() )
return;
if ( g_LostVideoMemory )
return;
ITexture *pSaveRenderTarget = NULL;
CMatRenderContextPtr pRenderContext( materials );
// HDRFIXME: push/pop
if( bPFM )
{
pSaveRenderTarget = pRenderContext->GetRenderTarget();
pRenderContext->SetRenderTarget( NULL );
}
// HACK HACK HACK!!!!
// If this is lower than the size of the render target (I think) we don't get water.
screenBufSize = 512;
char name[1024];
CViewSetup view;
memset( &view, 0, sizeof(view) );
view.origin = origin;
view.m_flAspectRatio = 1.0f;
view.m_bRenderToSubrectOfLargerScreen = true;
// garymcthack
view.zNear = 8.0f;
view.zFar = 28400.0f;
view.x = 0;
view.y = 0;
view.width = ( float )screenBufSize;
view.height = ( float )screenBufSize;
const char *pExtension = ".tga";
if( bPFM )
{
pExtension = ".pfm";
}
Shader_BeginRendering();
if( bPFM )
{
int backbufferWidth, backbufferHeight;
materials->GetBackBufferDimensions( backbufferWidth, backbufferHeight );
pRenderContext->Viewport( 0, 0, backbufferWidth, backbufferHeight );
pRenderContext->ClearColor3ub( 128, 128, 128 );
pRenderContext->ClearBuffers( true, true );
}
int nFlags = VIEW_CLEAR_COLOR | VIEW_CLEAR_DEPTH;
// NOTE: This is for a workaround on ATI with building cubemaps.
// Clearing just the viewport doesn't seem to work properly.
nFlags |= VIEW_CLEAR_FULL_TARGET;
static float angle0[6]={0,0,0,0,-90,90};
static float angle1[6]={0,180,90,270,0,0};
static CubeMapFaceIndex_t face_idx[6]={CUBEMAP_FACE_RIGHT,CUBEMAP_FACE_LEFT,
CUBEMAP_FACE_BACK,CUBEMAP_FACE_FRONT,
CUBEMAP_FACE_UP,CUBEMAP_FACE_DOWN};
static int engine_cubemap_idx_to_fbm_idx[6]={4,3,0,2,5,1};
if (bPFM)
{
FloatCubeMap_t Envmap(tgaSize, tgaSize);
for(int side=0;side<6;side++)
{
view.angles[0] = angle0[side];
view.angles[1] = angle1[side];
view.angles[2] = 0;
view.fov = 90;
view.fovViewmodel = 90;
view.origin = origin;
if (g_pMaterialSystemHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER)
{
FloatBitMap_t &hdr_map=Envmap.face_maps[engine_cubemap_idx_to_fbm_idx[side]];
hdr_map.Clear(0,0,0,1);
// we are going to need to render multiple exposures
float exposure=16.0;
bool bOverExposedTexels=true;
while( bOverExposedTexels && (exposure>0.05))
{
mat_force_tonemap_scale.SetValue(0.0f);
pRenderContext->ResetToneMappingScale( exposure );
g_ClientDLL->RenderView( view, nFlags, 0 );
uint8 *pImage = new uint8[ screenBufSize * screenBufSize * 4 ];
uint8 *pImage1 = new uint8[ tgaSize * tgaSize * 4 ];
// Get Bits from the material system
pRenderContext->ReadPixels( 0, 0, screenBufSize, screenBufSize,
pImage, IMAGE_FORMAT_RGBA8888 );
ImageLoader::ResampleInfo_t info;
info.m_pSrc = pImage;
info.m_pDest = pImage1;
info.m_nSrcWidth = screenBufSize;
info.m_nSrcHeight = screenBufSize;
info.m_nDestWidth = tgaSize;
info.m_nDestHeight = tgaSize;
info.m_flSrcGamma = 1.0f;
info.m_flDestGamma = 1.0f;
if( !ImageLoader::ResampleRGBA8888( info ) )
{
Sys_Error( "Can't resample\n" );
}
FloatBitMap_t ldr_map(tgaSize,tgaSize);
for(int x1=0;x1<tgaSize;x1++)
for(int y1=0;y1<tgaSize;y1++)
for(int c=0;c<3;c++)
ldr_map.Pixel(x1,y1,c)=pImage1[c+4*(x1+tgaSize*y1)]*(1/255.0);
delete[] pImage;
delete[] pImage1;
ldr_map.RaiseToPower(2.2); // gamma to linear
float scale=1.0/exposure;
bOverExposedTexels=false;
for(int x=0;x<hdr_map.Width;x++)
for(int y=0;y<hdr_map.Height;y++)
for(int c=0;c<3;c++)
{
float texel=ldr_map.Pixel(x,y,c);
if (texel>0.98)
bOverExposedTexels=true;
texel*=scale;
hdr_map.Pixel(x,y,c)=max(hdr_map.Pixel(x,y,c),texel);
}
exposure*=0.75;
materials->SwapBuffers();
}
Q_snprintf( name, sizeof( name ), "%s%s%s", pFileNameBase, facingName[side],pExtension );
// hdr_map.WritePFM(name);
}
else
{
g_ClientDLL->RenderView( view, nFlags, 0 );
Q_snprintf( name, sizeof( name ), "%s%s%s", pFileNameBase, facingName[side],pExtension );
Assert( strlen( name ) < 1023 );
videomode->TakeSnapshotTGARect( name, 0, 0, screenBufSize, screenBufSize, tgaSize, tgaSize, bPFM, face_idx[side]);
}
}
if (g_pMaterialSystemHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER)
{
// FloatCubeMap_t OutEnvmap(tgaSize, tgaSize);
// for(int f=0;f<6;f++)
// OutEnvmap.face_maps[f].Clear(0,0,0,1);
// Envmap.Resample(OutEnvmap,15.0);
Q_snprintf( name, sizeof( name ), "%s", pFileNameBase);
Envmap.WritePFMs( name );
// Q_snprintf( name, sizeof( name ), "%s_filtered", pFileNameBase);
// OutEnvmap.WritePFMs( name );
}
}
else
{
for(int side=0;side<6;side++)
{
view.angles[0] = angle0[side];
view.angles[1] = angle1[side];
view.angles[2] = 0;
view.fov = 90;
view.fovViewmodel = 90;
view.origin = origin;
g_ClientDLL->RenderView( view, nFlags, 0 );
Q_snprintf( name, sizeof( name ), "%s%s%s", pFileNameBase, facingName[side],pExtension );
Assert( strlen( name ) < 1023 );
videomode->TakeSnapshotTGARect( name, 0, 0, screenBufSize, screenBufSize, tgaSize, tgaSize, bPFM, face_idx[side]);
}
}
if( bPFM )
{
materials->SwapBuffers();
}
// HDRFIXME: push/pop
if( bPFM )
{
pRenderContext->SetRenderTarget( pSaveRenderTarget );
}
}
//-----------------------------------------------------------------------------
// Interface factory for VTex
//-----------------------------------------------------------------------------
void* CubemapsFSFactory( const char *pName, int *pReturnCode )
{
if ( IsX360() )
return NULL;
if ( Q_stricmp( pName, FILESYSTEM_INTERFACE_VERSION ) == 0 )
return g_pFileSystem;
return NULL;
}
//-----------------------------------------------------------------------------
// Generates a cubemap .vtf from .TGA snapshots
//-----------------------------------------------------------------------------
static void BuildSingleCubemap( const char *pVTFName, const Vector &vecOrigin,
int nSize, bool bHDR, const char *pGameDir, IVTex *ivt )
{
if ( IsX360() )
return;
int nScreenBufSize = 4 * nSize;
TakeCubemapSnapshot( vecOrigin, pVTFName, nScreenBufSize, nSize, bHDR );
char pTXTName[ MAX_PATH ];
Q_strncpy( pTXTName, pVTFName, sizeof(pTXTName) );
Q_SetExtension( pTXTName, ".txt", sizeof(pTXTName) );
// HDRFIXME: Make this go to a buffer instead.
FileHandle_t fp = g_pFileSystem->Open( pTXTName, "w" );
if( bHDR )
{
g_pFileSystem->FPrintf( fp, "\"pfm\" \"1\"\n" );
// HDRFIXME: Make sure that we can mip and lod and get rid of this.
}
// don't let any dest alpha creep into the image
g_pFileSystem->FPrintf( fp, "\"stripalphachannel\" \"1\"\n" );
g_pFileSystem->Close( fp );
if ( ivt )
{
char *argv[64];
int iArg = 0;
argv[iArg++] = "";
argv[iArg++] = "-quiet";
argv[iArg++] = "-UseStandardError"; // These are only here for the -currently released- version of vtex.dll.
argv[iArg++] = "-WarningsAsErrors";
argv[iArg++] = pTXTName;
ivt->VTex( CubemapsFSFactory, pGameDir, iArg, argv );
}
g_pFileSystem->RemoveFile( pTXTName, NULL );
const char *pSrcExtension = bHDR ? ".pfm" : ".tga";
for( int i = 0; i < 6; i++ )
{
char pTempName[MAX_PATH];
Q_snprintf( pTempName, sizeof( pTempName ), "%s%s", pVTFName, facingName[i] );
Q_SetExtension( pTempName, pSrcExtension, sizeof(pTempName) );
g_pFileSystem->RemoveFile( pTempName, NULL );
}
}
#if !defined( SWDS )
//-----------------------------------------------------------------------------
// Grab six views for environment mapping tests
//-----------------------------------------------------------------------------
CON_COMMAND( envmap, "" )
{
if ( IsX360() )
return;
char base[ 256 ];
IClientEntity *world = entitylist->GetClientEntity( 0 );
if( world && world->GetModel() )
{
Q_FileBase( modelloader->GetName( ( model_t *)world->GetModel() ), base, sizeof( base ) );
}
else
{
Q_strncpy( base, "Env", sizeof( base ) );
}
int strLen = strlen( base ) + strlen( "cubemap_screenshots/" ) + 1;
char *str = ( char * )_alloca( strLen );
Q_snprintf( str, strLen, "cubemap_screenshots/%s", base );
g_pFileSystem->CreateDirHierarchy( "cubemap_screenshots", "DEFAULT_WRITE_PATH" );
TakeCubemapSnapshot( MainViewOrigin(), str, mat_envmapsize.GetInt(), mat_envmaptgasize.GetInt(),
g_pMaterialSystemHardwareConfig->GetHDRType() != HDR_TYPE_NONE );
}
//-----------------------------------------------------------------------------
// Write lighting information to a DMX file
//-----------------------------------------------------------------------------
static void WriteLightProbe( const char *pBasePath, const LightingState_t& state, bool bHDR )
{
char pFullPath[MAX_PATH];
Q_strncpy( pFullPath, pBasePath, sizeof(pFullPath) );
Q_SetExtension( pFullPath, ".prb", sizeof(pFullPath) );
DECLARE_DMX_CONTEXT();
CDmxElement *pLightProbe = CreateDmxElement( "DmeElement" );
const char *pCubemap = pBasePath + Q_strlen( "materials/" );
CDmxElementModifyScope modify( pLightProbe );
pLightProbe->SetValue( "name", "lightprobe" );
pLightProbe->SetValue( "cubemap", pCubemap );
if ( bHDR )
{
char pTemp[MAX_PATH];
Q_snprintf( pTemp, sizeof(pTemp), "%s_hdr", pCubemap );
pLightProbe->SetValue( "cubemapHdr", pTemp );
}
CDmxAttribute *pAmbientCube = pLightProbe->AddAttribute( "ambientCube" );
CUtlVector< Vector >& vec = pAmbientCube->GetArrayForEdit<Vector>();
for ( int i = 0; i < 6 ; ++i )
{
vec.AddToTail( state.r_boxcolor[i] );
}
CDmxAttribute *pLocalLightList = pLightProbe->AddAttribute( "localLights" );
CUtlVector< CDmxElement* >& lights = pLocalLightList->GetArrayForEdit<CDmxElement*>();
modify.Release();
for ( int i = 0; i < state.numlights; ++i )
{
CDmxElement* pLight = CreateDmxElement( "DmeElement" );
lights.AddToTail( pLight );
const dworldlight_t &wl = *state.locallight[i];
pLight->SetValue( "color", wl.intensity );
switch( wl.type )
{
case emit_point:
pLight->SetValue( "name", "Point" );
pLight->SetValue( "origin", wl.origin );
pLight->SetValue( "attenuation", Vector( wl.constant_attn, wl.linear_attn, wl.quadratic_attn ) );
pLight->SetValue( "maxDistance", wl.radius );
break;
case emit_spotlight:
pLight->SetValue( "name", "Spot" );
pLight->SetValue( "origin", wl.origin );
pLight->SetValue( "direction", wl.normal );
pLight->SetValue( "attenuation", Vector( wl.constant_attn, wl.linear_attn, wl.quadratic_attn ) );
pLight->SetValue( "theta", 2.0f * acos( wl.stopdot ) );
pLight->SetValue( "phi", 2.0f * acos( wl.stopdot2 ) );
pLight->SetValue( "exponent", wl.exponent ? wl.exponent : 1.0f );
pLight->SetValue( "maxDistance", wl.radius );
break;
case emit_surface:
pLight->SetValue( "name", "Spot" );
pLight->SetValue( "origin", wl.origin );
pLight->SetValue( "direction", wl.normal );
pLight->SetValue( "attenuation", Vector( 0.0f, 0.0f, 1.0f ) );
pLight->SetValue( "theta", 0.0f );
pLight->SetValue( "phi", 0.0f );
pLight->SetValue( "exponent", 1.0f );
pLight->SetValue( "maxDistance", wl.radius );
break;
case emit_skylight:
pLight->SetValue( "name", "Directional" );
pLight->SetValue( "direction", wl.normal );
break;
}
}
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
if ( SerializeDMX( buf, pLightProbe, pFullPath ) )
{
g_pFullFileSystem->WriteFile( pFullPath, "MOD", buf );
}
CleanupDMX( pLightProbe );
}
//-----------------------------------------------------------------------------
// Grab an envmap @ the view position + write lighting information
//-----------------------------------------------------------------------------
CON_COMMAND( lightprobe,
"Samples the lighting environment.\n"
"Creates a cubemap and a file indicating the local lighting in a subdirectory called 'materials/lightprobes'\n."
"The lightprobe command requires you specify a base file name.\n" )
{
if ( IsX360() )
return;
if ( args.ArgC() < 2 )
{
ConMsg( "sample_lighting usage: lightprobe <base file name> [cubemap dimension]\n" );
return;
}
int nTGASize = mat_envmaptgasize.GetInt();
if ( args.ArgC() >= 3 )
{
nTGASize = atoi( args[2] );
}
CSysModule *pModule;
IVTex *pIVTex = VTex_Load( &pModule );
if ( !pIVTex )
return;
char pBasePath[MAX_PATH];
Q_snprintf( pBasePath, sizeof(pBasePath), "materials/lightprobes/%s", args[1] );
Q_StripFilename( pBasePath );
g_pFileSystem->CreateDirHierarchy( pBasePath, "DEFAULT_WRITE_PATH" );
char pTemp[MAX_PATH];
char pMaterialSrcPath[MAX_PATH];
Q_snprintf( pTemp, sizeof(pTemp), "materialsrc/lightprobes/%s", args[1] );
GetModContentSubdirectory( pTemp, pMaterialSrcPath, sizeof(pMaterialSrcPath) );
Q_StripFilename( pMaterialSrcPath );
g_pFileSystem->CreateDirHierarchy( pMaterialSrcPath, NULL );
char pGameDir[MAX_OSPATH];
COM_GetGameDir( pGameDir, sizeof( pGameDir ) );
bool bHDR = g_pMaterialSystemHardwareConfig->GetHDRType() != HDR_TYPE_NONE;
if ( bHDR )
{
char pTemp2[MAX_PATH];
Q_snprintf( pTemp2, sizeof(pTemp2), "materialsrc/lightprobes/%s_hdr", args[1] );
GetModContentSubdirectory( pTemp2, pMaterialSrcPath, sizeof(pMaterialSrcPath) );
BuildSingleCubemap( pMaterialSrcPath, MainViewOrigin(), nTGASize, true, pGameDir, pIVTex );
}
GetModContentSubdirectory( pTemp, pMaterialSrcPath, sizeof(pMaterialSrcPath) );
BuildSingleCubemap( pMaterialSrcPath, MainViewOrigin(), nTGASize, false, pGameDir, pIVTex );
VTex_Unload( pModule );
// Get the lighting at the point
LightingState_t lightingState;
LightcacheGetDynamic_Stats stats;
LightcacheGetDynamic( MainViewOrigin(), lightingState, stats );
Q_snprintf( pBasePath, sizeof(pBasePath), "materials/lightprobes/%s", args[1] );
WriteLightProbe( pBasePath, lightingState, bHDR );
}
static bool LoadSrcVTFFiles( IVTFTexture *pSrcVTFTextures[6], const char *pSkyboxBaseName )
{
if ( IsX360() )
return false;
int i;
for( i = 0; i < 6; i++ )
{
// !!! FIXME: This needs to open the vmt (or some other method) to find the correct LDR or HDR set of skybox textures! Look in vbsp\cubemap.cpp!
char srcVTFFileName[1024];
Q_snprintf( srcVTFFileName, sizeof( srcVTFFileName ), "materials/skybox/%s%s.vtf", pSkyboxBaseName, facingName[i] );
CUtlBuffer buf;
if ( !g_pFileSystem->ReadFile( srcVTFFileName, NULL, buf ) )
return false;
pSrcVTFTextures[i] = CreateVTFTexture();
if (!pSrcVTFTextures[i]->Unserialize(buf))
{
Warning("*** Error unserializing skybox texture: %s\n", pSkyboxBaseName );
return false;
}
// NOTE: texture[0] is a side texture that could be 1/2 height, so allow this and also allow 4x4 faces
if ( ( ( pSrcVTFTextures[i]->Width() != pSrcVTFTextures[0]->Width() ) && ( pSrcVTFTextures[i]->Width() != 4 ) ) ||
( ( pSrcVTFTextures[i]->Height() != pSrcVTFTextures[0]->Height() ) && ( pSrcVTFTextures[i]->Height() != pSrcVTFTextures[0]->Height()*2 ) && ( pSrcVTFTextures[i]->Height() != 4 ) ) ||
( pSrcVTFTextures[i]->Flags() != pSrcVTFTextures[0]->Flags() ) )
{
Warning("*** Error: Skybox vtf files for %s weren't compiled with the same size texture and/or same flags!\n", pSkyboxBaseName );
return false;
}
}
return true;
}
#define DEFAULT_CUBEMAP_SIZE 32
void Cubemap_CreateDefaultCubemap( const char *pMapName, IBSPPack *iBSPPack )
{
if ( IsX360() )
return;
// NOTE: This implementation depends on the fact that all VTF files contain
// all mipmap levels
ConVarRef skyboxBaseNameConVar( "sv_skyname" );
IVTFTexture *pSrcVTFTextures[6];
if ( !skyboxBaseNameConVar.IsValid() || !skyboxBaseNameConVar.GetString() )
{
Warning( "Couldn't create default cubemap\n" );
return;
}
const char *pSkyboxBaseName = skyboxBaseNameConVar.GetString();
if( !LoadSrcVTFFiles( pSrcVTFTextures, pSkyboxBaseName ) )
{
Warning( "Can't load skybox file %s to build the default cubemap!\n", pSkyboxBaseName );
return;
}
Msg( "Creating default cubemaps for env_cubemap using skybox %s...\n", pSkyboxBaseName );
// Figure out the mip differences between the two textures
int iMipLevelOffset = 0;
int tmp = pSrcVTFTextures[0]->Width();
while( tmp > DEFAULT_CUBEMAP_SIZE )
{
iMipLevelOffset++;
tmp >>= 1;
}
// Create the destination cubemap
IVTFTexture *pDstCubemap = CreateVTFTexture();
pDstCubemap->Init( DEFAULT_CUBEMAP_SIZE, DEFAULT_CUBEMAP_SIZE, 1,
pSrcVTFTextures[0]->Format(), pSrcVTFTextures[0]->Flags() | TEXTUREFLAGS_ENVMAP,
pSrcVTFTextures[0]->FrameCount() );
// First iterate over all frames
for (int iFrame = 0; iFrame < pDstCubemap->FrameCount(); ++iFrame)
{
// Next iterate over all normal cube faces (we know there's 6 cause it's an envmap)
for (int iFace = 0; iFace < 6; ++iFace )
{
// Finally, iterate over all mip levels in the *destination*
for (int iMip = 0; iMip < pDstCubemap->MipCount(); ++iMip )
{
// Copy the bits from the source images into the cube faces
unsigned char *pSrcBits = pSrcVTFTextures[iFace]->ImageData( iFrame, 0, iMip + iMipLevelOffset );
unsigned char *pDstBits = pDstCubemap->ImageData( iFrame, iFace, iMip );
int iSize = pDstCubemap->ComputeMipSize( iMip );
int iSrcMipSize = pSrcVTFTextures[iFace]->ComputeMipSize( iMip + iMipLevelOffset );
// !!! FIXME: Set this to black until the LDR/HDR issues are fixed on line ~563 in this file
memset( pDstBits, 0, iSize );
continue;
if ( ( pSrcVTFTextures[iFace]->Width() == 4 ) && ( pSrcVTFTextures[iFace]->Height() == 4 ) ) // If texture is 4x4 square
{
// Force mip level 2 to get the 1x1 face
pSrcBits = pSrcVTFTextures[iFace]->ImageData( iFrame, 0, 2 );
iSrcMipSize = pSrcVTFTextures[iFace]->ComputeMipSize( 2 );
// Replicate 1x1 mip level across entire face
//memset( pDstBits, 0, iSize );
for ( int i = 0; i < ( iSize / iSrcMipSize ); i++ )
{
memcpy( pDstBits + ( i * iSrcMipSize ), pSrcBits, iSrcMipSize );
}
}
else if ( pSrcVTFTextures[iFace]->Width() == pSrcVTFTextures[iFace]->Height() ) // If texture is square
{
if ( iSrcMipSize != iSize )
{
Warning( "%s - ERROR! Cannot copy square face for default cubemap! iSrcMipSize(%d) != iSize(%d)\n", pSkyboxBaseName, iSrcMipSize, iSize );
memset( pDstBits, 0, iSize );
}
else
{
// Just copy the mip level
memcpy( pDstBits, pSrcBits, iSize );
}
}
else if ( pSrcVTFTextures[iFace]->Width() == pSrcVTFTextures[iFace]->Height()*2 ) // If texture is rectangle 2x wide
{
int iMipWidth, iMipHeight, iMipDepth;
pDstCubemap->ComputeMipLevelDimensions( iMip, &iMipWidth, &iMipHeight, &iMipDepth );
if ( ( iMipHeight > 1 ) && ( iSrcMipSize*2 != iSize ) )
{
Warning( "%s - ERROR building default cube map! %d*2 != %d\n", pSkyboxBaseName, iSrcMipSize, iSize );
memset( pDstBits, 0, iSize );
}
else
{
// Copy row at a time and repeat last row
memcpy( pDstBits, pSrcBits, iSize/2 );
//memcpy( pDstBits + iSize/2, pSrcBits, iSize/2 );
int nSrcRowSize = pSrcVTFTextures[iFace]->RowSizeInBytes( iMip + iMipLevelOffset );
int nDstRowSize = pDstCubemap->RowSizeInBytes( iMip );
if ( nSrcRowSize != nDstRowSize )
{
Warning( "%s - ERROR building default cube map! nSrcRowSize(%d) != nDstRowSize(%d)!\n", pSkyboxBaseName, nSrcRowSize, nDstRowSize );
memset( pDstBits, 0, iSize );
}
else
{
for ( int i = 0; i < ( iSize/2 / nSrcRowSize ); i++ )
{
memcpy( pDstBits + iSize/2 + i*nSrcRowSize, pSrcBits + iSrcMipSize - nSrcRowSize, nSrcRowSize );
}
}
}
}
else
{
// ERROR! This code only supports square and rectangluar 2x wide
Warning( "%s - Couldn't create default cubemap because texture res is %dx%d\n", pSkyboxBaseName, pSrcVTFTextures[iFace]->Width(), pSrcVTFTextures[iFace]->Height() );
memset( pDstBits, 0, iSize );
return;
}
}
}
}
int flagUnion = 0;
int i;
for( i = 0; i < 6; i++ )
{
flagUnion |= pSrcVTFTextures[i]->Flags();
}
bool bHasAlpha =
( ( flagUnion & ( TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA ) ) != 0 );
// Convert the cube to format that we can apply tools to it...
// ImageFormat originalFormat = pDstCubemap->Format();
pDstCubemap->ConvertImageFormat( IMAGE_FORMAT_DEFAULT, false );
if( !bHasAlpha )
{
// set alpha to zero since the source doesn't have any alpha in it
unsigned char *pImageData = pDstCubemap->ImageData();
int size = pDstCubemap->ComputeTotalSize(); // in bytes!
unsigned char *pEnd = pImageData + size;
for( ; pImageData < pEnd; pImageData += 4 )
{
pImageData[3] = ( unsigned char )0;
}
}
// Fixup the cubemap facing
pDstCubemap->FixCubemapFaceOrientation();
// Now that the bits are in place, compute the spheremaps...
pDstCubemap->GenerateSpheremap();
// Convert the cubemap to the final format
pDstCubemap->ConvertImageFormat( IMAGE_FORMAT_DXT5, false );
// Write the puppy out!
char dstVTFFileName[1024];
Q_snprintf( dstVTFFileName, sizeof( dstVTFFileName ), "materials/maps/%s/cubemapdefault.vtf", pMapName );
CUtlBuffer outputBuf;
if (!pDstCubemap->Serialize( outputBuf ))
{
Warning( "Error serializing default cubemap %s\n", dstVTFFileName );
return;
}
// spit out the default one.
iBSPPack->AddBufferToPack( dstVTFFileName, outputBuf.Base(), outputBuf.TellPut(), false );
// Clean up the textures
for( i = 0; i < 6; i++ )
{
DestroyVTFTexture( pSrcVTFTextures[i] );
}
DestroyVTFTexture( pDstCubemap );
}
static void AddSampleToBSPFile( bool bHDR, mcubemapsample_t *pSample, const char *matDir, IBSPPack *iBSPPack )
{
if ( IsX360() )
return;
char textureName[MAX_PATH] = { 0 };
const char *pHDRExtension = "";
if( bHDR )
{
pHDRExtension = ".hdr";
}
Q_snprintf( textureName, sizeof( textureName ), "%s/c%d_%d_%d%s.vtf", matDir, ( int )pSample->origin[0],
( int )pSample->origin[1], ( int )pSample->origin[2], pHDRExtension );
char localPath[MAX_PATH] = { 0 };
if ( !g_pFileSystem->RelativePathToFullPath_safe( textureName, "DEFAULT_WRITE_PATH", localPath ) || !*localPath )
{
Warning("vtex failed to compile cubemap!\n");
}
else
{
Q_FixSlashes( localPath );
iBSPPack->AddFileToPack( textureName, localPath );
}
g_pFileSystem->RemoveFile( textureName, "DEFAULT_WRITE_PATH" );
}
/*
===============
R_BuildCubemapSamples
Take a cubemap at each "cubemap" entity in the current map.
===============
*/
// HOLY CRAP THIS NEEDS TO BE CLEANED UP
//Added these to seperate from R_BuildCubemapSamples to a) clean it up abit and b) fix the issue where if it fails, mouse is disabled.
static bool saveShadows = true;
static bool bDrawWater = true;
static int nSaveLightStyle = -1;
static int bSaveDrawBeams = true;
static bool bSaveMatSpecular = true;
static int nOldOcclusionVal = 1;
static int nOldBloomDisable = 0;
static int originaldrawMRMModelsVal = 1;
void R_BuildCubemapSamples_PreBuild()
{
// disable the mouse so that it won't be recentered all the bloody time.
ConVarRef cl_mouseenable( "cl_mouseenable" );
if( cl_mouseenable.IsValid() )
{
cl_mouseenable.SetValue( 0 );
}
ConVarRef r_shadows( "r_shadows" );
saveShadows = true;
if ( r_shadows.IsValid() )
{
saveShadows = r_shadows.GetBool();
r_shadows.SetValue( 0 );
}
// Clear the water surface.
ConVarRef mat_drawwater( "mat_drawwater" );
bDrawWater = true;
if ( mat_drawwater.IsValid() )
{
bDrawWater = mat_drawwater.GetBool();
mat_drawwater.SetValue( 0 );
}
nSaveLightStyle = -1;
ConVarRef r_lightstyleRef( "r_lightstyle" );
if ( r_lightstyleRef.IsValid() )
{
nSaveLightStyle = r_lightstyleRef.GetInt();
r_lightstyleRef.SetValue( 0 );
R_RedownloadAllLightmaps();
}
bSaveDrawBeams = r_DrawBeams.GetInt();
r_DrawBeams.SetValue( 0 );
bSaveMatSpecular = mat_fastspecular.GetBool();
// ConVar *r_drawtranslucentworld = ( ConVar * )cv->FindVar( "r_drawtranslucentworld" );
// ConVar *r_drawtranslucentrenderables = ( ConVar * )cv->FindVar( "r_drawtranslucentrenderables" );
// bool bSaveDrawTranslucentWorld = true;
// bool bSaveDrawTranslucentRenderables = true;
// if( r_drawtranslucentworld )
// {
// bSaveDrawTranslucentWorld = r_drawtranslucentworld->GetBool();
// NOTE! : We use to set this to 0 for HDR.
// r_drawtranslucentworld->SetValue( 0 );
// }
// if( r_drawtranslucentrenderables )
// {
// bSaveDrawTranslucentRenderables = r_drawtranslucentrenderables->GetBool();
// NOTE! : We use to set this to 0 for HDR.
// r_drawtranslucentrenderables->SetValue( 0 );
// }
building_cubemaps.SetValue( 1 );
ConVarRef r_portalsopenall( "r_portalsopenall" );
if( r_portalsopenall.IsValid() )
{
r_portalsopenall.SetValue( 1 );
}
nOldOcclusionVal = 1;
ConVarRef r_occlusion( "r_occlusion" );
if( r_occlusion.IsValid() )
{
nOldOcclusionVal = r_occlusion.GetInt();
r_occlusion.SetValue( 0 );
}
ConVarRef mat_disable_bloom( "mat_disable_bloom" );
nOldBloomDisable = 0;
if ( mat_disable_bloom.IsValid() )
{
nOldBloomDisable = mat_disable_bloom.GetInt();
mat_disable_bloom.SetValue( 1 );
}
ConVarRef drawMRMModelsCVar( "r_drawothermodels" );
if( drawMRMModelsCVar.IsValid() )
originaldrawMRMModelsVal = drawMRMModelsCVar.GetInt();
}
void R_BuildCubemapSamples_PostBuild()
{
// re-enable the mouse.
ConVarRef cl_mouseenable( "cl_mouseenable" );
if( cl_mouseenable.IsValid() )
{
cl_mouseenable.SetValue( 1 );
}
ConVarRef r_shadows( "r_shadows" );
if( r_shadows.IsValid() )
{
r_shadows.SetValue( saveShadows );
}
ConVarRef mat_drawwater( "mat_drawwater" );
if ( mat_drawwater.IsValid() )
{
mat_drawwater.SetValue( bDrawWater );
}
if( bSaveMatSpecular )
{
mat_fastspecular.SetValue( "1" );
}
else
{
mat_fastspecular.SetValue( "0" );
}
ConVarRef r_lightstyleRef( "r_lightstyle" );
if( r_lightstyleRef.IsValid() )
{
r_lightstyleRef.SetValue( nSaveLightStyle );
R_RedownloadAllLightmaps();
}
ConVarRef r_portalsopenall( "r_portalsopenall" );
if( r_portalsopenall.IsValid() )
{
r_portalsopenall.SetValue( 0 );
}
ConVarRef r_occlusion( "r_occlusion" );
if( r_occlusion.IsValid() )
{
r_occlusion.SetValue( nOldOcclusionVal );
}
ConVarRef mat_disable_bloom( "mat_disable_bloom" );
if ( mat_disable_bloom.IsValid() )
{
mat_disable_bloom.SetValue( nOldBloomDisable);
}
r_DrawBeams.SetValue( bSaveDrawBeams );
ConVarRef drawMRMModelsCVar( "r_drawothermodels" );
if( drawMRMModelsCVar.IsValid() )
{
drawMRMModelsCVar.SetValue( originaldrawMRMModelsVal );
}
building_cubemaps.SetValue( 0 );
}
void R_BuildCubemapSamples( int numIterations )
{
if ( IsX360() )
return;
// Make sure that the file is writable before building cubemaps.
Assert( g_pFileSystem->FileExists( cl.m_szLevelFileName, "GAME" ) );
if( !g_pFileSystem->IsFileWritable( cl.m_szLevelFileName, "GAME" ) )
{
Warning( "%s is not writable!!! Check it out before running buildcubemaps.\n", cl.m_szLevelFileName );
return;
}
R_BuildCubemapSamples_PreBuild();
int bounce;
for( bounce = 0; bounce < numIterations; bounce++ )
{
if( bounce == 0 )
{
mat_fastspecular.SetValue( "0" );
}
else
{
mat_fastspecular.SetValue( "1" );
}
UpdateMaterialSystemConfig();
IClientEntity *world = entitylist->GetClientEntity( 0 );
if( !world || !world->GetModel() )
{
ConDMsg( "R_BuildCubemapSamples: No map loaded!\n" );
R_BuildCubemapSamples_PostBuild();
return;
}
int oldDrawMRMModelsVal = 1;
ConVarRef drawMRMModelsCVar( "r_drawothermodels" );
if( drawMRMModelsCVar.IsValid() )
{
oldDrawMRMModelsVal = drawMRMModelsCVar.GetInt();
drawMRMModelsCVar.SetValue( 0 );
}
bool bOldLightSpritesActive = ActivateLightSprites( true );
// load the vtex dll
CSysModule *pModule;
IVTex *ivt = VTex_Load( &pModule );
if ( !ivt )
return;
char matDir[MAX_PATH];
Q_snprintf( matDir, sizeof(matDir), "materials/maps/%s", cl.m_szLevelBaseName );
g_pFileSystem->CreateDirHierarchy( matDir, "DEFAULT_WRITE_PATH" );
char pTemp[MAX_PATH];
Q_snprintf( pTemp, sizeof(pTemp), "materialsrc/maps/%s", cl.m_szLevelBaseName );
char pMaterialSrcDir[MAX_PATH];
GetModContentSubdirectory( pTemp, pMaterialSrcDir, sizeof(pMaterialSrcDir) );
g_pFileSystem->CreateDirHierarchy( pMaterialSrcDir, NULL );
char gameDir[MAX_OSPATH];
COM_GetGameDir( gameDir, sizeof( gameDir ) );
model_t *pWorldModel = ( model_t *)world->GetModel();
int i;
for( i = 0; i < pWorldModel->brush.pShared->m_nCubemapSamples; i++ )
{
mcubemapsample_t *pCubemapSample = &pWorldModel->brush.pShared->m_pCubemapSamples[i];
int tgaSize = ( pCubemapSample->size == 0 ) ? mat_envmaptgasize.GetInt() : 1 << ( pCubemapSample->size-1 );
int screenBufSize = 4 * tgaSize;
if ( (screenBufSize > videomode->GetModeWidth()) || (screenBufSize > videomode->GetModeHeight()) )
{
Warning( "Cube map buffer size %d x %d is bigger than screen!\nRun at a higher resolution! or reduce your cubemap resolution (needs 4X)\n", screenBufSize, screenBufSize );
// BUGBUG: We'll leak DLLs/handles if we break out here, but this should be infrequent.
R_BuildCubemapSamples_PostBuild();
return;
}
}
bool bSupportsHDR = g_pMaterialSystemHardwareConfig->GetHDRType() != HDR_TYPE_NONE;
for( i = 0; i < pWorldModel->brush.pShared->m_nCubemapSamples; i++ )
{
Warning( "bounce: %d/%d sample: %d/%d\n", bounce+1, numIterations, i+1, pWorldModel->brush.pShared->m_nCubemapSamples );
mcubemapsample_t *pCubemapSample = &pWorldModel->brush.pShared->m_pCubemapSamples[i];
char pVTFName[ MAX_PATH ];
Q_snprintf( pVTFName, sizeof( pVTFName ), "%s/c%d_%d_%d", pMaterialSrcDir,
( int )pCubemapSample->origin[0], ( int )pCubemapSample->origin[1],
( int )pCubemapSample->origin[2] );
int nTgaSize = ( pCubemapSample->size == 0 ) ? mat_envmaptgasize.GetInt() : 1 << ( pCubemapSample->size-1 );
BuildSingleCubemap( pVTFName, pCubemapSample->origin, nTgaSize, bSupportsHDR, gameDir, ivt );
}
ActivateLightSprites( bOldLightSpritesActive );
VTex_Unload( pModule );
// load the bsppack dll
IBSPPack *iBSPPack = NULL;
pModule = FileSystem_LoadModule( "bsppack" );
if ( pModule )
{
CreateInterfaceFn factory = Sys_GetFactory( pModule );
if ( factory )
{
iBSPPack = ( IBSPPack * )factory( IBSPPACK_VERSION_STRING, NULL );
}
}
if( !iBSPPack )
{
ConMsg( "Can't load bsppack.dll\n" );
R_BuildCubemapSamples_PostBuild();
return;
}
iBSPPack->SetHDRMode( g_pMaterialSystemHardwareConfig->GetHDRType() != HDR_TYPE_NONE );
iBSPPack->LoadBSPFile( g_pFileSystem, cl.m_szLevelFileName );
// Cram the textures into the bsp.
Q_snprintf( matDir, sizeof(matDir), "materials/maps/%s", cl.m_szLevelBaseName );
for ( i=0 ; i < pWorldModel->brush.pShared->m_nCubemapSamples ; i++ )
{
mcubemapsample_t *pSample = &pWorldModel->brush.pShared->m_pCubemapSamples[i];
AddSampleToBSPFile( bSupportsHDR, pSample, matDir, iBSPPack );
}
Cubemap_CreateDefaultCubemap( cl.m_szLevelBaseName, iBSPPack );
// Resolve levelfilename to absolute to ensure we are writing the exact file we loaded and not preferentially to
// DEFAULT_WRITE_PATH
char szAbsFile[MAX_PATH] = { 0 };
g_pFullFileSystem->RelativePathToFullPath( cl.m_szLevelFileName, NULL, szAbsFile, sizeof( szAbsFile ) );
if ( !*szAbsFile )
{
ConMsg( "Failed to resolve absolute path of map: %s\n", cl.m_szLevelFileName );
R_BuildCubemapSamples_PostBuild();
return;
}
iBSPPack->WriteBSPFile( szAbsFile );
iBSPPack->ClearPackFile();
FileSystem_UnloadModule( pModule );
Cbuf_AddText( "restart setpos\n" );
}
R_BuildCubemapSamples_PostBuild();
UpdateMaterialSystemConfig();
// after map reloads, run any state that had to wait for map to reload
reload_materials.SetValue( 1 );
}
#if !defined( _X360 )
CON_COMMAND( buildcubemaps, "Rebuild cubemaps." )
{
extern void V_RenderVGuiOnly();
bool bAllow = Host_AllowQueuedMaterialSystem(false);
// do this to force a frame to render so the material system syncs up to single thread mode
V_RenderVGuiOnly();
if ( args.ArgC() == 1 )
{
R_BuildCubemapSamples( 1 );
}
else if( args.ArgC() == 2 )
{
R_BuildCubemapSamples( atoi( args[ 1 ] ) );
}
else
{
ConMsg( "Usage: buildcubemaps [numBounces]\n" );
}
Host_AllowQueuedMaterialSystem(bAllow);
}
#endif // SWDS
#endif
Reference in New Issue View Git Blame Copy Permalink