Backups/csgo-2018-source
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
93f753e8ef
csgo-2018-source/engine/paint.cpp

1657 lines
46 KiB
C++
Raw Normal View History

uid issue
2021-07-25 12:11:47 +08:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//==========================================================================//
#include "paint.h"
#include "materialsystem/imaterial.h"
#include "pixelwriter.h"
#include "gl_model_private.h"
#include "gl_matsysiface.h"
#include "dt_common.h"
#include "keyvalues.h"
#include <vstdlib/random.h> // RandomFloat
#include "collisionutils.h" // ray triangle test
#include "cmodel_private.h"
// debug stuff
#include "debugoverlay.h"
#include "con_nprint.h"
// src/public/
#include "game/shared/portal2/paint_enum.h"
#include "tier1/callqueue.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern ConVar r_redownloadallpaintmaps;
static const BYTE NUM_ALPHA_BITS = 5;
static const BYTE PAINT_COLOR_BITS = 7 << NUM_ALPHA_BITS; // 224
static const BYTE PAINT_ALPHA_BITS = PAINT_COLOR_BITS ^ 0xFF; // 31
ConVar paint_max_surface_border_alpha("paint_max_surface_border_alpha", "0.7f", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED );
ConVar paint_alpha_offset_enabled("paint_alpha_offset_enabled", "1", FCVAR_DEVELOPMENTONLY | FCVAR_REPLICATED );
ConVar paintsplat_bias("paintsplat_bias", "0.1f", FCVAR_REPLICATED | FCVAR_CHEAT, "Change bias value for computing circle buffer" );
ConVar paintsplat_noise_enabled("paintsplat_noise_enabled", "1", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar paintsplat_max_alpha_noise("paintsplat_max_alpha_noise", "0.1f", FCVAR_REPLICATED | FCVAR_CHEAT, "Max noise value of circle alpha" );
ConVar paint_min_valid_alpha_value("paint_min_valid_alpha_value", "0.7f", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
ConVar debug_paint_alpha("debug_paint_alpha", "0", FCVAR_DEVELOPMENTONLY );
int GetDiameter( int radius )
{
return radius * 2 + 1;
}
BYTE GetColorIndex( BYTE byte )
{
return ( PAINT_COLOR_BITS & byte ) >> NUM_ALPHA_BITS;
}
void SetColorBits( BYTE& byte, BYTE colorIndex, float alpha )
{
BYTE nAlpha = static_cast< BYTE >( alpha * PAINT_ALPHA_BITS );
BYTE nColor = colorIndex << NUM_ALPHA_BITS;
byte = nColor | nAlpha;
}
float GetAlpha( BYTE byte )
{
float alpha = ( PAINT_ALPHA_BITS & byte );
alpha /= PAINT_ALPHA_BITS;
alpha = clamp( alpha, 0.f, 1.f );
return alpha;
}
#if !defined( LINUX )
// draw a surface in random color
void DebugDrawSurface( SurfaceHandle_t surfID )
{
Color surfColor = Color( RandomInt(0, 255), RandomInt(0, 255), RandomInt(0, 255), 128 );
// check if the sphere actually intersecting with the surface using barycentric test
int nFirstVertex = MSurf_FirstVertIndex( surfID );
int numVert = MSurf_VertCount( surfID );
int vertIndex = host_state.worldbrush->vertindices[nFirstVertex];
Vector vOrigin = host_state.worldbrush->vertexes[vertIndex].position;
for (int v = 1; v < numVert - 1; ++v )
{
vertIndex = host_state.worldbrush->vertindices[nFirstVertex+v];
Vector v1 = host_state.worldbrush->vertexes[vertIndex].position;
vertIndex = host_state.worldbrush->vertindices[nFirstVertex+v+1];
Vector v2 = host_state.worldbrush->vertexes[vertIndex].position;
CDebugOverlay::AddTriangleOverlay( vOrigin, v1, v2, surfColor.r(), surfColor.g(), surfColor.b(), 128, false, 0.1f );
}
}
#endif
extern MaterialSystem_SortInfo_t *materialSortInfoArray;
CPaintmapDataManager g_PaintManager;
CPaintmapDataManager::CPaintmapDataManager( void )
: m_pPaintTextureDataArray( NULL ), m_iPaintmaps( 0 ), m_bShouldRegister( false )
{
}
CPaintmapDataManager::~CPaintmapDataManager( void )
{
}
void CPaintmapDataManager::DestroyPaintmapsData( void )
{
if( m_pPaintTextureDataArray )
{
for( int i = 0; i != m_iPaintmaps; ++i )
{
m_pPaintTextureDataArray[i].Destroy();
}
delete []m_pPaintTextureDataArray;
m_pPaintTextureDataArray = NULL;
m_iPaintmaps = 0;
}
}
void R_UpdatePaintmapRect( int paintmap, BYTE* pPaintData, int numRects, Rect_t* pRects )
{
materials->UpdatePaintmap( paintmap, pPaintData, numRects, pRects );
}
void R_UpdatePaintmap( ICallQueue *pCallQueue, int paintmap, BYTE* pPaintData, int numRects, Rect_t* pRects )
{
if ( !pCallQueue )
{
R_UpdatePaintmapRect( paintmap, pPaintData, numRects, pRects );
}
else
{
pCallQueue->QueueCall( R_UpdatePaintmapRect, paintmap, pPaintData, numRects, CUtlEnvelope<Rect_t>( pRects, numRects ) );
}
}
void MarkSurfaceBrushes( int nSurfIndex, worldbrushdata_t *pData = host_state.worldbrush )
{
if ( !pData->m_pSurfaceBrushList )
return;
const dfacebrushlist_t &brushList = pData->m_pSurfaceBrushList[nSurfIndex];
const uint16 *pBrushIndex = (brushList.m_nFaceBrushCount <= 1) ? &brushList.m_nFaceBrushStart : &pData->m_pSurfaceBrushes[brushList.m_nFaceBrushStart];
CCollisionBSPData *pBSPData = GetCollisionBSPData();
for ( int i = 0; i < brushList.m_nFaceBrushCount; i++ )
{
pBSPData->map_brushes[ pBrushIndex[i] ].contents |= CONTENTS_BRUSH_PAINT;
}
}
void CPaintmapDataManager::UpdatePaintmapTextures()
{
// Can't build lightmaps if the source data has been dumped
CMatRenderContextPtr pRenderContext( materials );
ICallQueue *pCallQueue = pRenderContext->GetCallQueue();
if( pCallQueue )
pCallQueue->QueueCall( materials, &IMaterialSystem::BeginUpdatePaintmaps );
else
materials->BeginUpdatePaintmaps();
for( int paintmap=0; paintmap < m_iPaintmaps; ++paintmap )
{
PaintDirtyFlags_t nDirtyFlag = m_pPaintTextureDataArray[paintmap].GetDirtyFlag();
if ( nDirtyFlag == PAINTMAP_CLEAN )
continue;
if ( nDirtyFlag == PAINTMAP_DIRTY_FULLRECT )
{
R_UpdatePaintmap( pCallQueue, paintmap, m_pPaintTextureDataArray[paintmap].GetPaintmapData(), 0, NULL );
}
else
{
CUtlVectorFixedGrowable<Rect_t, 1024> *pRects = m_pPaintTextureDataArray[paintmap].GetDirtyRectList();
int count = pRects->Count();
Assert( count > 0 );
R_UpdatePaintmap( pCallQueue, paintmap, m_pPaintTextureDataArray[paintmap].GetPaintmapData(), count, pRects->Base() );
}
m_pPaintTextureDataArray[paintmap].RemoveDirty();
}
if( pCallQueue )
pCallQueue->QueueCall( materials, &IMaterialSystem::EndUpdatePaintmaps );
else
materials->EndUpdatePaintmaps();
}
BYTE* CPaintmapDataManager::GetPaintmapData( int paintmap )
{
if ( paintmap >= 0 && paintmap < m_iPaintmaps )
{
return m_pPaintTextureDataArray[paintmap].GetPaintmapData();
}
return NULL;
}
void CPaintmapDataManager::GetPaintmapSize( int paintmap, int& width, int& height )
{
if ( paintmap >= 0 && paintmap < m_iPaintmaps )
{
m_pPaintTextureDataArray[paintmap].GetPaintSize( &width, &height );
}
}
void CPaintmapDataManager::OnRestorePaintmaps()
{
for ( int i=0; i<m_iPaintmaps; ++i )
{
m_pPaintTextureDataArray[i].MarkAsDirty();
}
}
void CPaintmapDataManager::RemoveAllPaint( void )
{
if( m_pPaintTextureDataArray )
{
for( int i = 0; i != m_iPaintmaps; ++i )
{
m_pPaintTextureDataArray[i].ClearTexture();
}
}
int nBrushCount = GetCollisionBSPData()->numbrushes;
cbrush_t *pBrush = GetCollisionBSPData()->map_brushes.Base();
for ( int i = 0; i < nBrushCount; i++ )
{
pBrush[i].contents &= ~CONTENTS_BRUSH_PAINT;
}
}
void CPaintmapDataManager::RemovePaint( const model_t *pModel )
{
Assert( pModel );
if ( !pModel )
return;
Assert( m_pPaintTextureDataArray );
if ( !m_pPaintTextureDataArray )
return;
BYTE noColor;
SetColorBits( noColor, NO_POWER, 0.f );
for ( int i=0; i<pModel->brush.nummodelsurfaces; ++i )
{
SurfaceHandle_t surfID = SurfaceHandleFromIndex( pModel->brush.firstmodelsurface + i );
int lightmapID = materialSortInfoArray[MSurf_MaterialSortID( surfID )].lightmapPageID;
CPaintTextureData& paintTexture = m_pPaintTextureDataArray[ lightmapID ];
Rect_t rect;
rect.x = MSurf_OffsetIntoLightmapPage( surfID )[0];
rect.y = MSurf_OffsetIntoLightmapPage( surfID )[1];
rect.width = MSurf_LightmapExtents( surfID )[0] + 1;
rect.height= MSurf_LightmapExtents( surfID )[1] + 1;
for ( int y=0; y<rect.height; ++y )
{
for ( int x=0; x<rect.width; ++x )
{
paintTexture.SetPixel( x + rect.x, y + rect.y, noColor );
}
}
paintTexture.AddDirtyRect( rect );
}
}
void CPaintmapDataManager::PaintAllSurfaces( BYTE color )
{
AssertMsg( m_pPaintTextureDataArray, "Failed to paint all surfaces. Paint textures are not allocated." );
if( m_pPaintTextureDataArray )
{
for( int i = 0; i != m_iPaintmaps; ++i )
{
m_pPaintTextureDataArray[i].PaintAllSurfaces( color );
}
}
int numSurfs = host_state.worldbrush->numsurfaces;
for ( int i=0; i<numSurfs; ++i )
{
SurfaceHandle_t surfID = SurfaceHandleFromIndex( i );
MSurf_Flags( surfID ) |= SURFDRAW_PAINTED;
}
int nBrushCount = GetCollisionBSPData()->numbrushes;
cbrush_t *pBrush = GetCollisionBSPData()->map_brushes.Base();
for ( int i = 0; i < nBrushCount; i++ )
{
pBrush[i].contents |= CONTENTS_BRUSH_PAINT;
}
}
void CPaintmapDataManager::BeginPaintmapsDataAllocation( int iPaintmapCount )
{
DestroyPaintmapsData();
m_iPaintmaps = iPaintmapCount;
m_pPaintTextureDataArray = new CPaintTextureData[iPaintmapCount];
}
void CPaintmapDataManager::AllocatePaintmapData( int iPaintmapID, int iCorrespondingLightMapWidth, int iCorrespondingLightMapHeight )
{
m_pPaintTextureDataArray[iPaintmapID].Init( iCorrespondingLightMapWidth, iCorrespondingLightMapHeight, iPaintmapID );
}
CPaintTextureData::CPaintTextureData()
{
m_nPaintWidth = m_nPaintHeight = 0;
m_backbuffer = NULL;
m_nDirtyFlag = PAINTMAP_CLEAN;
}
// Initializes, shuts down the material
bool CPaintTextureData::Init( int width, int height, int lightmapPageID )
{
m_nPaintWidth = width;
m_nPaintHeight = height;
m_lightmapPageID = lightmapPageID;
m_backbuffer = new BYTE[ m_nPaintWidth * m_nPaintHeight ];
AssertMsg( m_backbuffer, "Failed to allocate paint texture data array" );
ClearBuffer();
return true;
}
void CPaintTextureData::Destroy()
{
if ( m_backbuffer )
{
delete[] m_backbuffer;
m_backbuffer = NULL;
}
}
BYTE CPaintTextureData::GetPixel( int x, int y ) const
{
return m_backbuffer[ y * m_nPaintWidth + x ];
}
void CPaintTextureData::SetPixel( int x, int y, BYTE color )
{
m_backbuffer[ y * m_nPaintWidth + x ] = color;
}
bool CPaintTextureData::Paint( const PaintRect_t& paintRect )
{
uint32 nChangeFlags = DrawCircle( paintRect );
if ( nChangeFlags & TEXEL_CHANGED )
{
// no need for extra alpha if we are erasing
if ( paint_alpha_offset_enabled.GetBool() && paintRect.colorIndex != NO_POWER )
{
Rect_t rect = paintRect.rect;
int sOffset = MSurf_OffsetIntoLightmapPage( paintRect.surfID )[0];
int tOffset = MSurf_OffsetIntoLightmapPage( paintRect.surfID )[1];
int sMax = ( MSurf_LightmapExtents( paintRect.surfID )[0] );
int tMax = ( MSurf_LightmapExtents( paintRect.surfID )[1] );
if ( paintRect.rect.x > sOffset )
{
--rect.x;
++rect.width;
}
if ( paintRect.rect.y > tOffset )
{
--rect.y;
++rect.height;
}
if ( paintRect.rect.x + paintRect.rect.width - 1 < sOffset + sMax )
{
++rect.width;
}
if ( paintRect.rect.y + paintRect.rect.height - 1 < tOffset + tMax )
{
++rect.height;
}
AddDirtyRect( rect );
}
else
{
AddDirtyRect( paintRect.rect );
}
}
return ( nChangeFlags & PAINT_POWER_CHANGED ) != 0;
}
BYTE BlendColor( BYTE colorIndex, BYTE nPrePixel, float flAlpha, float flPaintCoatPercent, float flMaxAlpha )
{
BYTE finalColor;
// stomp erase color
if ( colorIndex == NO_POWER )
{
// if it's erase, the alpha is always 0.f or 1.f (0.f for surrounding edges)
SetColorBits( finalColor, paint_alpha_offset_enabled.GetBool() ? GetColorIndex( nPrePixel ) : colorIndex, 0.f );
}
else
{
float bAlpha = GetAlpha( nPrePixel );
float flNewAlpha = clamp( bAlpha + ( flPaintCoatPercent * flAlpha ), 0.f, flMaxAlpha );
SetColorBits( finalColor, colorIndex, flNewAlpha );
}
return finalColor;
}
float ComputeCircleAlpha( const PaintRect_t& paintRect, int x, int y )
{
float flPixelDist = Vector2D( x - paintRect.uvCenter.x, y - paintRect.uvCenter.y ).Length();
float flRadiusRatio = clamp( paintRect.flCenterAlpha + flPixelDist / paintRect.flCircleRadius, 0.f, 1.f );
float flAlpha = 1.f - Bias( flRadiusRatio, paintsplat_bias.GetFloat() );
if ( paintsplat_noise_enabled.GetBool() )
{
float flNoise = paintsplat_max_alpha_noise.GetFloat();
flAlpha += RandomFloat( -flNoise, flNoise );
flAlpha = clamp( flAlpha, 0.f, 1.f );
}
return flAlpha;
}
uint32 CPaintTextureData::BlendLuxel( const PaintRect_t& paintRect, int x, int y, float flNewAlpha, float flMaxAlpha /*= 1.f*/ )
{
uint32 nChangeFlags = 0;
BYTE nPrePixel = GetPixel( x, y );
BYTE nPostPixel = BlendColor( paintRect.colorIndex, nPrePixel, flNewAlpha, paintRect.flPaintCoatPercent, flMaxAlpha );
if ( nPrePixel != nPostPixel )
{
SetPixel( x, y, nPostPixel );
nChangeFlags |= TEXEL_CHANGED;
if ( GetColorIndex( nPrePixel ) != GetColorIndex( nPostPixel ) )
{
nChangeFlags |= PAINT_POWER_CHANGED;
}
}
return nChangeFlags;
}
uint32 CPaintTextureData::AddSurroundingAlpha( const PaintRect_t& paintRect, int x, int y )
{
SurfaceHandle_t surfID = paintRect.surfID;
int surroundCase = 0;
int sOffset = MSurf_OffsetIntoLightmapPage( surfID )[0];
int tOffset = MSurf_OffsetIntoLightmapPage( surfID )[1];
int sMax = ( MSurf_LightmapExtents( surfID )[0] );
int tMax = ( MSurf_LightmapExtents( surfID )[1] );
surroundCase |= ( x > sOffset ) ? 1 : 0; // left
surroundCase |= ( x < sOffset + sMax ) ? 2 : 0; // right
surroundCase |= ( y > tOffset ) ? 4 : 0; // up
surroundCase |= ( y < tOffset + tMax ) ? 8 : 0; // down
uint32 nChangeFlags = 0;
switch ( surroundCase )
{
case 1: // left only
{
nChangeFlags |= BlendLuxel( paintRect, x - 1, y, 0.f );
break;
}
case 2: // right only
{
nChangeFlags |= BlendLuxel( paintRect, x + 1, y, 0.f );
break;
}
case 3: // left right
{
nChangeFlags |= BlendLuxel( paintRect, x - 1, y, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y, 0.f );
break;
}
case 4: // up only
{
nChangeFlags |= BlendLuxel( paintRect, x, y - 1, 0.f );
break;
}
case 5: // left up
{
nChangeFlags |= BlendLuxel( paintRect, x - 1, y, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x - 1, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x, y - 1, 0.f );
break;
}
case 6: // right up
{
nChangeFlags |= BlendLuxel( paintRect, x + 1, y, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x, y - 1, 0.f );
break;
}
case 7: // left up right
{
nChangeFlags |= BlendLuxel( paintRect, x - 1, y, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x - 1, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y, 0.f );
break;
}
case 8: // down only
{
nChangeFlags |= BlendLuxel( paintRect, x, y + 1, 0.f );
break;
}
case 9: // left down
{
nChangeFlags |= BlendLuxel( paintRect, x - 1, y, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x - 1, y + 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x, y + 1, 0.f );
break;
}
case 10: // right down
{
nChangeFlags |= BlendLuxel( paintRect, x + 1, y, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y + 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x, y + 1, 0.f );
break;
}
case 11: // left down right
{
nChangeFlags |= BlendLuxel( paintRect, x - 1, y, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x - 1, y + 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x, y + 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y + 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y, 0.f );
break;
}
case 12: // up down
{
nChangeFlags |= BlendLuxel( paintRect, x, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x, y + 1, 0.f );
break;
}
case 13: // up left down
{
nChangeFlags |= BlendLuxel( paintRect, x, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x - 1, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x - 1, y, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x - 1, y + 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x, y + 1, 0.f );
break;
}
case 14: // up right down
{
nChangeFlags |= BlendLuxel( paintRect, x, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y + 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x, y + 1, 0.f );
break;
}
case 15: // all 8 surrounding luxels
{
nChangeFlags |= BlendLuxel( paintRect, x, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x - 1, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x - 1, y, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x - 1, y + 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y - 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x + 1, y + 1, 0.f );
nChangeFlags |= BlendLuxel( paintRect, x, y + 1, 0.f );
break;
}
default:
break;
}
return nChangeFlags;
}
uint32 CPaintTextureData::DrawLine( const PaintRect_t& paintRect, int x1, int x2, int y )
{
uint32 nChangeFlags = 0;
int sOffset = MSurf_OffsetIntoLightmapPage( paintRect.surfID )[0];
int tOffset = MSurf_OffsetIntoLightmapPage( paintRect.surfID )[1];
int sMax = ( MSurf_LightmapExtents( paintRect.surfID )[0] );
int tMax = ( MSurf_LightmapExtents( paintRect.surfID )[1] );
int start = x1;
int end = x2;
// clamp border luxel alpha below paint_max_surface_border_alpha threshold so the shader won't look up color from other surface border
float flMaxAlpha = 1.f;
if ( y == tOffset || y == tOffset + tMax )
{
flMaxAlpha = paint_max_surface_border_alpha.GetFloat();
}
else
{
if ( x1 == sOffset )
{
float flAlpha = ( paintRect.colorIndex == NO_POWER ) ? 1.f : ComputeCircleAlpha( paintRect, x1, y );
nChangeFlags |= BlendLuxel( paintRect, x1, y, flAlpha, paint_max_surface_border_alpha.GetFloat() );
++start;
}
if ( x2 == sOffset + sMax )
{
float flAlpha = ( paintRect.colorIndex == NO_POWER ) ? 1.f : ComputeCircleAlpha( paintRect, x2, y );
nChangeFlags |= BlendLuxel( paintRect, x2, y, flAlpha, paint_max_surface_border_alpha.GetFloat() );
--end;
}
}
for ( int x = start; x <= end; ++x )
{
float flAlpha = ( paintRect.colorIndex == NO_POWER ) ? 1.f : ComputeCircleAlpha( paintRect, x, y );
nChangeFlags |= BlendLuxel( paintRect, x, y, flAlpha, flMaxAlpha );
}
// don't add surrounding alpha if we are erasing
if ( paint_alpha_offset_enabled.GetBool() && paintRect.colorIndex != NO_POWER )
{
if ( x1 == x2 )
{
nChangeFlags |= AddSurroundingAlpha( paintRect, x1, y );
}
else
{
nChangeFlags |= AddSurroundingAlpha( paintRect, x1, y );
nChangeFlags |= AddSurroundingAlpha( paintRect, x2, y );
}
}
return nChangeFlags;
}
uint32 CPaintTextureData::Draw2Lines( const PaintRect_t& paintRect, float x, float y )
{
const Rect_t& rect = paintRect.rect;
int minX = rect.x;
int minY = rect.y;
int maxX = rect.x + rect.width - 1;
int maxY = rect.y + rect.height - 1;
const Vector2D& uvCenter = paintRect.uvCenter;
int x1 = MAX( ( int )( uvCenter.x - x - 0.5f ), minX );
int y1 = MAX( ( int )( uvCenter.y - y - 0.5f ), minY );
int x2 = MIN( ( int )( uvCenter.x + x + 0.5f ), maxX );
int y2 = MIN( ( int )( uvCenter.y + y + 0.5f ), maxY );
// if line is outside the rect, don't do anything
if ( x1 > maxX || x2 < minX )
return 0;
uint32 nChangeFlags = 0;
// draw line1
if ( minY <= y1 && y1 <= maxY )
{
nChangeFlags |= DrawLine( paintRect, x1, x2, y1 );
}
if ( y1 != y2 )
{
if ( minY <= y2 && y2 <= maxY )
{
nChangeFlags |= DrawLine( paintRect, x1, x2, y2 );
}
}
return nChangeFlags;
}
uint32 CPaintTextureData::Draw4Lines( const PaintRect_t& paintRect, float x, float y )
{
uint32 nChangeFlags = 0;
nChangeFlags |= Draw2Lines( paintRect, x, y );
if ( x != y )
{
nChangeFlags |= Draw2Lines( paintRect, y, x );
}
return nChangeFlags;
}
uint32 CPaintTextureData::DrawCircle( const PaintRect_t& paintRect )
{
// assume uvExtents x and y are about the same
float radius = paintRect.flCircleRadius;
float error = -radius;
float x = radius;
float y = 0;
uint32 nChangeFlags = 0;
while (x >= y)
{
nChangeFlags |= Draw4Lines( paintRect, x, y );
error += y;
++y;
error += y;
if (error >= 0)
{
--x;
error -= x;
error -= x;
}
}
return nChangeFlags;
}
// Returns the tecxoord range
void CPaintTextureData::GetTexCoordRange( float *pMaxU, float *pMaxV )
{
*pMaxU = *pMaxV = 1.0f;
return;
}
// Returns the size of the paint texture (stored in a subrect of the material itself)
void CPaintTextureData::GetPaintSize( int *pWidth, int *pHeight )
{
*pWidth = m_nPaintWidth;
*pHeight = m_nPaintHeight;
}
void CPaintTextureData::ClearTexture()
{
ClearBuffer();
MarkAsDirty();
}
void CPaintTextureData::GetPixels( const Rect_t& splatRect, CUtlVector<BYTE>& surfColors )
{
//sample color inside rect
for (int y = 0; y < splatRect.height; ++y )
{
for (int x = 0; x < splatRect.width; ++x )
{
BYTE packedColor = GetPixel( splatRect.x + x, splatRect.y + y );
BYTE colorIndex = GetColorIndex( packedColor );
float flAlpha = GetAlpha( packedColor );
if( flAlpha > paint_min_valid_alpha_value.GetFloat() )
surfColors.AddToTail( colorIndex );
if( debug_paint_alpha.GetBool() )
{
Con_NPrintf( y * splatRect.width + x, "(%d, %d), Alpha: %f\n", x, y, flAlpha );
}
}
}
}
void CPaintTextureData::ClearBuffer( BYTE *pByte )
{
BYTE nPixel = ( pByte ) ? *pByte : NO_POWER << NUM_ALPHA_BITS;
V_memset( m_backbuffer, nPixel, m_nPaintWidth * m_nPaintHeight );
}
// paint all surfaces
void CPaintTextureData::PaintAllSurfaces( BYTE colorIndex )
{
BYTE nPixel;
SetColorBits( nPixel, colorIndex, 1.f );
ClearBuffer( &nPixel );
MarkAsDirty();
}
void CPaintTextureData::GetSurfacePaintData( SurfaceHandle_t surfID, CUtlVector< BYTE > &data ) const
{
if ( !m_backbuffer )
return;
short x = MSurf_OffsetIntoLightmapPage( surfID )[0];
short y = MSurf_OffsetIntoLightmapPage( surfID )[1];
short width = MSurf_LightmapExtents( surfID )[0] + 1;
short height = MSurf_LightmapExtents( surfID )[1] + 1;
int nDataCount = width * height;
// make sure alloc number is divisible by 4
uint nAllocSize = nDataCount + ( ( 4 - ( nDataCount % 4 ) ) % 4 );
Assert( ( nAllocSize % 4 ) == 0 );
data.EnsureCount( nAllocSize );
BYTE* pOut = data.Base();
const BYTE* pEnd = data.Base() + nDataCount;
const BYTE* pRead = &m_backbuffer[ y * m_nPaintWidth + x ];
while( pOut < pEnd )
{
V_memcpy( pOut, pRead, width );
pOut += width;
pRead += m_nPaintWidth;
}
Assert( pOut == pEnd );
}
void CPaintTextureData::SetSurfacePaintData( SurfaceHandle_t surfID, const CUtlVector< BYTE > &data )
{
if ( !m_backbuffer )
return;
Rect_t rect;
rect.x = MSurf_OffsetIntoLightmapPage( surfID )[0];
rect.y = MSurf_OffsetIntoLightmapPage( surfID )[1];
rect.width = MSurf_LightmapExtents( surfID )[0] + 1;
rect.height = MSurf_LightmapExtents( surfID )[1] + 1;
uint nDataCount = rect.width * rect.height;
const BYTE* pRead = data.Base();
const BYTE* pEnd = data.Base() + nDataCount;
BYTE *pSet = &m_backbuffer[ rect.y * m_nPaintWidth + rect.x ];
while ( pRead < pEnd )
{
V_memcpy( pSet, pRead, rect.width );
pRead += rect.width;
pSet += m_nPaintWidth;
}
AddDirtyRect( rect );
// mark surf as painted
MSurf_Flags( surfID ) |= SURFDRAW_PAINTED;
MarkSurfaceBrushes( MSurf_Index(surfID) );
}
void EncodeDataRLE( const uint32* pBuffer, uint32 nDwordCount, CUtlVector< uint32 > &data )
{
if ( nDwordCount == 0 )
return;
// first build a list of runs into a local utlvector
CUtlVectorFixedGrowable<intp, 1024> outList;
// this is the start of the run of unique data to copy
const uint32 *pCopyStart = pBuffer;
// we need to find at least a run of 3 in order for encoding a run to pay for itself, keep last two
uint32 nSymbol0 = *pCopyStart;
uint32 nSymbol1 = pCopyStart[1];
const uint32 *pEndOfData = pCopyStart + nDwordCount;
// start here with the first two loaded up and ready to copy
const uint32 *pCurrent = pCopyStart + 2;
// this is the size in dwords of the rle output buffer
uint32 nRLESize = 0;
// anything that defines _GAMECONSOLE should support prefetches
#if defined(_GAMECONSOLE)
// prefetch the first 7 cache lines
for ( int i = 0; i < 7; i++ )
{
PREFETCH_128( pCurrent + (i * 32), 0 );
}
#endif
// this is the next read that will trigger a prefetch (not every read should prefetch)
const uint32 *pNextPrefetch = pCurrent + 32;
// this is the end of the space we'd want to prefetch ahead of
const uint32 *pLastPrefetch = pEndOfData - (8 * 32);
// this is how far ahead of the current read to prefetch
#if defined(_GAMECONSOLE)
const uint32 nPrefetchOffsetDwords = 7 * 32; // will cause an error if your platform has prefetch but not _GAMECONSOLE
#endif
while ( pCurrent < pEndOfData )
{
uint32 nSymbol2 = *pCurrent;
if ( nSymbol0 == nSymbol1 && nSymbol1 == nSymbol2 )
{
// found a run
const uint32 *pRunStart = pCurrent - 2;
int nCopyOut = pRunStart - pCopyStart;
// copy any previous run of non-similar values
if ( nCopyOut )
{
// note, we're building a list of copies, so just add a record
outList.AddToTail( nCopyOut );
outList.AddToTail( intp(pCopyStart) );
nRLESize += nCopyOut + 1;
pCopyStart = pRunStart;
}
// follow current run until its end
pCurrent++;
while ( pCurrent < pEndOfData && *pCurrent == nSymbol0 )
{
pCurrent++;
if ( pCurrent >= pNextPrefetch && pNextPrefetch < pLastPrefetch )
{
// schedule prefetches 128 bytes (32 dwords) apart
PREFETCH_128( pNextPrefetch + nPrefetchOffsetDwords, 0 );
pNextPrefetch += 32;
}
}
// write out the run
int nRunCount = pCurrent - pRunStart;
outList.AddToTail( -nRunCount );
outList.AddToTail( nSymbol0 );
nRLESize += 2;
if ( pCurrent < pEndOfData )
{
// restart run detection
nSymbol2 = *pCurrent;
nSymbol1 = nSymbol2+1; // make these not equal so a run will not be detected
}
pCopyStart = pCurrent;
}
// advance read cursor and shift over previous run-detect state
pCurrent++;
nSymbol0 = nSymbol1;
nSymbol1 = nSymbol2;
if ( pCurrent >= pNextPrefetch && pNextPrefetch < pLastPrefetch )
{
PREFETCH_128( pNextPrefetch + nPrefetchOffsetDwords, 0 );
pNextPrefetch += 32;
}
}
int nCopyOut = pEndOfData - pCopyStart;
if ( nCopyOut )
{
// add another record if the map ends in a copy
outList.AddToTail( nCopyOut );
outList.AddToTail( (intp)pCopyStart );
nRLESize += nCopyOut + 1;
pCopyStart = pEndOfData;
}
// now build the full RLE output from the records we just made
// we can allocate once because we know the output size
data.SetCount( nRLESize );
uint32 *pOut = data.Base();
const intp *pRLE = outList.Base();
const intp *pEndRLE = pRLE + outList.Count();
while ( pRLE < pEndRLE )
{
int nCount = *pRLE++;
if ( nCount < 0 )
{
// run, insert in output
*pOut++ = uint32( nCount );
*pOut++ = uint32( *pRLE++ );
}
else
{
// copy, do the actual copy now
*pOut++ = uint32( nCount );
const uint32 *pSource = (const uint32 *)*pRLE++;
for ( int i = 0; i < nCount; i++ )
{
*pOut++ = *pSource++;
}
}
}
// make sure our buffer contains exactly what the records predicted
Assert( (uint32)(pOut - data.Base()) == nRLESize );
}
void CPaintmapDataManager::GetPaintmapDataRLE( CUtlVector< uint32 > &data ) const
{
for ( int i=0; i< host_state.worldbrush->numsurfaces; ++i )
{
SurfaceHandle_t surfID = SurfaceHandleFromIndex( i );
if ( MSurf_Flags( surfID ) & SURFDRAW_PAINTED )
{
int lightmapID = materialSortInfoArray[MSurf_MaterialSortID( surfID )].lightmapPageID;
// get paint data from a surface
CUtlVector< BYTE > surfPaintData;
m_pPaintTextureDataArray[lightmapID].GetSurfacePaintData( surfID, surfPaintData );
// encode into RLE format
CUtlVector< uint32 > rleData;
uint nDwordCount = surfPaintData.Count() / 4;
EncodeDataRLE( (uint32*)surfPaintData.Base(), nDwordCount, rleData );
// write surface index, RLE size, and RLE data to output data
data.AddToTail( i );
data.AddToTail( rleData.Count() );
data.AddMultipleToTail( rleData.Count(), rleData.Base() );
}
}
}
void DecodeDataRLE( const uint32* pRLEStart, uint rleCount, SurfaceHandle_t surfID, uint32* pOutput, uint nDwordCount )
{
// NOTE: This assumes the size is always correct, will assert if not
const uint32 *pRLE = pRLEStart;
const uint32 *pEndOfData = pRLE + rleCount;
#if _DEBUG
const uint32* pOutStart = pOutput;
#endif
while ( pRLE < pEndOfData )
{
int32 nCount = int32(*pRLE++);
if ( nCount < 0 ) // run, output repeated value nCount times
{
nCount = -nCount;
uint32 nRunVal = *pRLE++;
for ( int i = 0; i < nCount; i++ )
{
*pOutput++ = nRunVal;
}
}
else // copy raw dwords from input
{
for ( int i = 0; i < nCount; i++ )
{
*pOutput++ = *pRLE++;
}
}
}
Assert( pRLE == pEndOfData );
Assert( pOutput - pOutStart == nDwordCount );
}
void CPaintmapDataManager::LoadPaintmapDataRLE( const CUtlVector< uint32 > &data )
{
const uint32* pCurrent = data.Base();
const uint32* pEnd = pCurrent + data.Count();
while ( pCurrent < pEnd )
{
// assumes that the surface index is always the same (it'll change if the map's changed)
int surfIndex = *pCurrent++;
SurfaceHandle_t surfID = SurfaceHandleFromIndex( surfIndex );
int lightmapID = materialSortInfoArray[MSurf_MaterialSortID( surfID )].lightmapPageID;
uint nRLESize = *pCurrent++;
// alloc output. make sure the size is divisible by 4 to copy data from array of uint32
CUtlVector< BYTE > rawPaintData;
int width = MSurf_LightmapExtents( surfID )[0] + 1;
int height = MSurf_LightmapExtents( surfID )[1] + 1;
int nByteCount = width * height;
uint nAllocSize = nByteCount + ( ( 4 - ( nByteCount % 4 ) ) % 4 );
Assert( ( nAllocSize % 4 ) == 0 );
rawPaintData.SetCount( nAllocSize );
uint nDWord = nAllocSize / 4;
DecodeDataRLE( pCurrent, nRLESize, surfID, (uint32*)rawPaintData.Base(), nDWord );
pCurrent += nRLESize;
m_pPaintTextureDataArray[lightmapID].SetSurfacePaintData( surfID, rawPaintData );
}
}
void CPaintTextureData::AddDirtyRect( const Rect_t& rect )
{
MarkAsDirty( PAINTMAP_DIRTY_SUBRECT );
m_dirtyRects.AddToTail( rect );
}
CUtlVectorFixedGrowable<Rect_t, 1024>* CPaintTextureData::GetDirtyRectList()
{
return &m_dirtyRects;
}
void CPaintTextureData::RemoveDirty()
{
m_nDirtyFlag = PAINTMAP_CLEAN;
m_dirtyRects.RemoveAll();
}
PaintDirtyFlags_t CPaintTextureData::GetDirtyFlag() const
{
return m_nDirtyFlag;
}
void CPaintTextureData::MarkAsDirty( PaintDirtyFlags_t nDirtyFlag /*= PAINTMAP_DIRTY_FULLRECT*/ )
{
m_nDirtyFlag = ( m_nDirtyFlag == PAINTMAP_DIRTY_FULLRECT ) ? m_nDirtyFlag : nDirtyFlag;
}
void ProjectPointOntoSurfaceTexture( const SurfaceCtx_t& ctx, SurfaceHandle_t surfID, const Vector& vPoint, Vector2D& uv )
{
mtexinfo_t* pTexInfo = MSurf_TexInfo( surfID );
uv.x = DotProduct ( vPoint, pTexInfo->lightmapVecsLuxelsPerWorldUnits[0].AsVector3D()) +
pTexInfo->lightmapVecsLuxelsPerWorldUnits[0][3];
uv.x -= MSurf_LightmapMins( surfID )[0];
uv.x += 0.5f;
uv.y = DotProduct ( vPoint, pTexInfo->lightmapVecsLuxelsPerWorldUnits[1].AsVector3D()) +
pTexInfo->lightmapVecsLuxelsPerWorldUnits[1][3];
uv.y -= MSurf_LightmapMins( surfID )[1];
uv.y += 0.5f;
uv *= ctx.m_Scale;
uv += ctx.m_Offset;
// convert back to the old space
uv /= ctx.m_Scale;
}
bool ComputePaintRect( SurfaceHandle_t surfID, const Vector &vPosition, float flSphereRadius, PaintRect_t& paintRect )
{
#if !defined( LINUX )
// find dist from plane
VPlane forwardFacingPlane = MSurf_GetForwardFacingPlane( surfID );
float distFromPlane = forwardFacingPlane.DistTo( vPosition );
AssertMsg( distFromPlane < flSphereRadius, "How did this surface intersect with the query sphere?" );
float circleRadius = FastSqrt( flSphereRadius * flSphereRadius - distFromPlane * distFromPlane );
SurfaceCtx_t ctx;
SurfSetupSurfaceContext( ctx, surfID );
Vector2D uvCenter, uvExtents;
{
ProjectPointOntoSurfaceTexture( ctx, surfID, vPosition, uvCenter );
mtexinfo_t *pTexInfo = MSurf_TexInfo( surfID );
uvExtents.x = circleRadius * pTexInfo->lightmapVecsLuxelsPerWorldUnits[0].AsVector3D().Length();
uvExtents.y = circleRadius * pTexInfo->lightmapVecsLuxelsPerWorldUnits[1].AsVector3D().Length();
}
Assert( uvExtents.x > 0 && uvExtents.y > 0 );
Vector2D uvMins, uvMaxs;
uvMins = uvCenter - uvExtents;
uvMaxs = uvCenter + uvExtents;
int sOffset = MSurf_OffsetIntoLightmapPage( surfID )[0];
int tOffset = MSurf_OffsetIntoLightmapPage( surfID )[1];
int sMax = ( MSurf_LightmapExtents( surfID )[0] );
int tMax = ( MSurf_LightmapExtents( surfID )[1] );
if ( ( sOffset <= uvMaxs.x && uvMins.x <= sOffset + sMax ) && ( tOffset <= uvMaxs.y && uvMins.y <= tOffset + tMax ) )
{
// init paintRect
float flRoundedCircleRadius = floor( fpmax( uvExtents.x, uvExtents.y ) + 0.5f );
int surfWidth = sMax + 1;
int surfHeight = tMax + 1;
paintRect.flCenterAlpha = distFromPlane / flSphereRadius;
paintRect.flCircleRadius = flRoundedCircleRadius;
paintRect.uvCenter = uvCenter;
paintRect.surfID = surfID;
int startX = MAX( ( int )( uvCenter.x - flRoundedCircleRadius - 0.5f ), sOffset );
int startY = MAX( ( int )( uvCenter.y - flRoundedCircleRadius - 0.5f ), tOffset );
int endX = MIN( ( int )( uvCenter.x + flRoundedCircleRadius + 0.5f ), sOffset + surfWidth );
int endY = MIN( ( int )( uvCenter.y + flRoundedCircleRadius + 0.5f ), tOffset + surfHeight );
Rect_t rect;
rect.x = startX;
rect.y = startY;
rect.width = endX - startX;
rect.height = endY - startY;
paintRect.rect = rect;
return ( rect.width > 0 && rect.height > 0 );
}
#endif
return false;
}
bool R_PaintSurface( SurfaceHandle_t surfID, const Vector &vPosition, float flSphereRadius, const VPlane& basePlane, BYTE colorIndex, float flPaintCoatPercent )
{
bool bAddedPaint = false;
int lightmapID = materialSortInfoArray[MSurf_MaterialSortID( surfID )].lightmapPageID;
PaintRect_t paintRect;
paintRect.colorIndex = colorIndex;
paintRect.flPaintCoatPercent = flPaintCoatPercent;
if ( ComputePaintRect( surfID, vPosition, flSphereRadius, paintRect ) )
{
if ( g_PaintManager.m_pPaintTextureDataArray[ lightmapID ].Paint( paintRect ) )
{
// HACK SUPER HACK! mark surface as painted to optimize rendering
MSurf_Flags( surfID ) |= SURFDRAW_PAINTED;
MarkSurfaceBrushes( MSurf_Index(surfID) );
bAddedPaint = true;
}
}
return bAddedPaint;
}
//-----------------------------------------------------------------------------
// find a surface to paint by traversing through all surfaces in a model
//-----------------------------------------------------------------------------
struct paintinfo_t
{
Vector m_vPosition;
VPlane m_plane; // closest plane to the sphere
worldbrushdata_t *m_pBrush; // The shared brush data for this model
float m_flSize; // radius of surf searching sphere
float m_flCurrentDistance; // distance away from the center of the sphere
CUtlVector<SurfaceHandle_t> m_aApplySurfs;
// debug stuff
bool m_bPainting;
};
Vector FindClosestPointToTriangle( const Vector& p, const Vector& a, const Vector& b, const Vector& c )
{
Vector ab = b - a;
Vector ac = c - a;
Vector bc = c - b;
// project p onto ab,
// p' = a + projAB * ab, projAB = projABnom/(projABnom+projABdenom)
float projABnom = DotProduct( p - a, ab ), projABdenom = DotProduct( p - b, a - b );
// project p onto ac,
// p' = a + projAC * ac, = projACnom/(projACnom+projACdenom)
float projACnom = DotProduct( p - a, ac ), projACdenom = DotProduct( p - c, a - c );
if ( projABnom <= 0.0f && projACnom <= 0.0f )
{
return a; // Vertex region early out
}
// project p onto bc,
// p' = b + projBC * bc, projBC = projBCnom/(projBCnom+projBCdenom)
float projBCnom = DotProduct( p - b, bc ), projBCdenom = DotProduct( p - c, b - c );
if ( projABdenom <= 0.0f && projBCnom <= 0.0f )
{
return b; // Vertex region early out
}
if ( projACdenom <= 0.0f && projBCdenom <= 0.0f )
{
return c; // Vertex region early out
}
Vector n = CrossProduct( ab, ac );
// P is outside (or on) AB if the triple product [N PA PB] = N.(PAxPB) <= 0
float tpC = DotProduct( n, CrossProduct( a - p, b - p ) );
// If P outside AB and within feature region of AB, return projection of P onto AB
if ( tpC <= 0.0f && projABnom >= 0.0f && projABdenom >= 0.0f )
{
return a + projABnom / ( projABnom + projABdenom ) * ab;
}
// P is outside (or on) BC if the triple product [N PB PC] = N.(PBxPC) <= 0
float tpA = DotProduct( n, CrossProduct(b - p, c - p) );
// If P outside BC and within feature region of BC, return projection of P onto BC
if ( tpA <= 0.0f && projBCnom >= 0.0f && projBCdenom >= 0.0f )
{
return b + projBCnom / (projBCnom + projBCdenom) * bc;
}
// P is outside (or on) CA if the triple product [N PC PA] = N.(PCxPA) <= 0
float tpB = DotProduct( n, CrossProduct(c - p, a - p) );
// If P outside CA and within feature region of CA, return projection of P onto CA
if ( tpB <= 0.0f && projACnom >= 0.0f && projACdenom >= 0.0f )
{
return a + projACnom / ( projACnom + projACdenom ) * ac;
}
// P must project inside the triangle. Compute the position using barycentric coordinates
float u = tpA / ( tpA + tpB + tpC );
float v = tpB / ( tpA + tpB + tpC );
float w = 1.0f - u - v; // = tpC / ( tpA + tpB + tpC )
return u * a + v * b + w * c;
}
bool IsSphereIntersectForwardFacingTriangle( const Vector& vCenter, const VPlane& plane, float flRadius, const Vector& a, const Vector& b, const Vector& c, Vector& vClosestPoint )
{
vClosestPoint = FindClosestPointToTriangle( vCenter, a, b, c );
float flDistFromPlane = DotProduct( vClosestPoint, plane.m_Normal ) - plane.m_Dist;
if ( flDistFromPlane < 0.f )
{
vClosestPoint = vClosestPoint + ( flDistFromPlane + 0.1f ) * plane.m_Normal;
}
Vector vDist = vCenter - vClosestPoint;
float flDistSquare = DotProduct( vDist, vDist );
return flDistSquare < Square( flRadius );
}
void R_AddPaintToSurface( SurfaceHandle_t surfID, paintinfo_t *paintinfo )
{
const unsigned int ignoreFlags = SURFDRAW_NOPAINT | SURFDRAW_TRANS;
if ( MSurf_Flags( surfID ) & ignoreFlags )
return;
// Displacement surfaces get decals in R_DecalLeaf.
if ( SurfaceHasDispInfo( surfID ) )
return;
if ( paintinfo->m_aApplySurfs.Find( surfID ) != -1 )
return;
// in multiplayer, materialSortInfoArray is initialized after paint power user objects are active
if ( materialSortInfoArray == NULL )
return;
// don't do it if it's full bright
if ( materialSortInfoArray[MSurf_MaterialSortID( surfID )].lightmapPageID < 0 )
return;
VPlane plane = MSurf_GetForwardFacingPlane( surfID );
float flDistFromPlane = DotProduct( paintinfo->m_vPosition, plane.m_Normal ) - plane.m_Dist;
// ignore if point is behind the plane or too far from the forward facing plane
if ( flDistFromPlane > paintinfo->m_flSize || flDistFromPlane < 0.f )
return;
// check if the sphere actually intersecting with the surface using barycentric test
int nFirstVertex = MSurf_FirstVertIndex( surfID );
int numVert = MSurf_VertCount( surfID );
int vertIndex = host_state.worldbrush->vertindices[nFirstVertex];
Vector vOrigin = host_state.worldbrush->vertexes[vertIndex].position;
bool bIntersect = false;
Vector vClosestPoint;
for (int v = 1; v < numVert - 1; ++v )
{
vertIndex = host_state.worldbrush->vertindices[nFirstVertex+v];
Vector v1 = host_state.worldbrush->vertexes[vertIndex].position;
vertIndex = host_state.worldbrush->vertindices[nFirstVertex+v+1];
Vector v2 = host_state.worldbrush->vertexes[vertIndex].position;
Vector vIntersectPoint;
if ( IsSphereIntersectForwardFacingTriangle( paintinfo->m_vPosition, plane, paintinfo->m_flSize, vOrigin, v1, v2, vIntersectPoint ) )
{
if ( !bIntersect )
{
vClosestPoint = vIntersectPoint;
}
else
{
Vector vecA = vClosestPoint - paintinfo->m_vPosition;
Vector vecB = vIntersectPoint - paintinfo->m_vPosition;
if ( DotProduct( vecB, vecB ) < DotProduct( vecA, vecA ) )
{
vClosestPoint = vIntersectPoint;
}
}
bIntersect = true;
}
}
if ( bIntersect )
{
Vector vDist = vClosestPoint - paintinfo->m_vPosition;
float flDistFromClosestPointSquare = DotProduct( vDist, vDist );
if ( flDistFromClosestPointSquare < paintinfo->m_flCurrentDistance )
{
paintinfo->m_flCurrentDistance = flDistFromClosestPointSquare;
paintinfo->m_plane = plane;
}
paintinfo->m_aApplySurfs.AddToTail( surfID );
}
}
//-----------------------------------------------------------------------------
// iterate over all surfaces on a model, looking for surfaces to paint
//-----------------------------------------------------------------------------
void R_PaintLeaf( mleaf_t *pLeaf, paintinfo_t *paintinfo )
{
SurfaceHandle_t *pHandle = &host_state.worldbrush->marksurfaces[pLeaf->firstmarksurface];
for ( int i = 0; i < pLeaf->nummarksurfaces; i++ )
{
SurfaceHandle_t surfID = pHandle[i];
R_AddPaintToSurface( surfID, paintinfo );
}
}
void R_PaintNode( mnode_t *node, paintinfo_t* paintinfo )
{
cplane_t *splitplane;
float dist;
if (!node )
return;
if ( node->contents >= 0 )
{
R_PaintLeaf( (mleaf_t *)node, paintinfo );
return;
}
splitplane = node->plane;
dist = DotProduct (paintinfo->m_vPosition, splitplane->normal) - splitplane->dist;
if (dist > paintinfo->m_flSize)
{
R_PaintNode (node->children[0], paintinfo);
}
else if (dist < -paintinfo->m_flSize)
{
R_PaintNode (node->children[1], paintinfo);
}
else
{
R_PaintNode (node->children[0], paintinfo);
R_PaintNode (node->children[1], paintinfo);
}
}
bool IsSurfaceInFrontOfPlane( SurfaceHandle_t surfID, const VPlane& plane )
{
// check if the surface is on the same plane as the main plane
VPlane trianglePlane = MSurf_GetForwardFacingPlane( surfID );
if ( AlmostEqual( DotProduct( plane.m_Normal, trianglePlane.m_Normal ), 1.f ) && AlmostEqual( plane.m_Dist, trianglePlane.m_Dist) )
{
return true;
}
// if center of the first triangle is behind the main plane, ignore it.
int numVert = MSurf_VertCount( surfID );
if ( numVert < 3 )
{
return false;
}
int nFirstVertex = MSurf_FirstVertIndex( surfID );
int vertIndex = host_state.worldbrush->vertindices[nFirstVertex];
Vector vOrigin = host_state.worldbrush->vertexes[vertIndex].position;
vertIndex = host_state.worldbrush->vertindices[nFirstVertex + 1];
Vector v1 = host_state.worldbrush->vertexes[vertIndex].position;
vertIndex = host_state.worldbrush->vertindices[nFirstVertex + 2];
Vector v2 = host_state.worldbrush->vertexes[vertIndex].position;
Vector vCenter = vOrigin + 0.25f * ( ( v1 - vOrigin ) + ( v2 - vOrigin ) );
vCenter += 0.1f * trianglePlane.m_Normal; // push it a bit off the triangle plane to account for floating point error
if ( plane.DistTo( vCenter ) < 0.f )
{
return false;
}
// debug paint rejection
/*{
CDebugOverlay::AddTriangleOverlay( vOrigin, v1, v2, 255, 0,0,128, true, 10.0f );
CDebugOverlay::AddBoxOverlay( vCenter, Vector(-1,-1,-1), Vector(1,1,1), vec3_angle, 255, 255,0,128, 10.0f );
}*/
return true;
}
bool ShootPaintSphere( const model_t *pModel, const Vector& vPosition, BYTE colorIndex, float flSphereRadius, float flPaintCoatPercent )
{
if ( !g_PaintManager.m_bShouldRegister || g_PaintManager.m_pPaintTextureDataArray == NULL )
{
return false;
}
Assert( pModel );
if ( !pModel )
return false;
paintinfo_t paintinfo;
paintinfo.m_vPosition = vPosition;
paintinfo.m_flSize = flSphereRadius;
paintinfo.m_flCurrentDistance = FLT_MAX;
paintinfo.m_pBrush = pModel->brush.pShared;
paintinfo.m_aApplySurfs.RemoveAll();
paintinfo.m_bPainting = true;
mnode_t *pnodes = paintinfo.m_pBrush->nodes + pModel->brush.firstnode;
R_PaintNode( pnodes, &paintinfo );
//do the actual painting
bool bChangedPaint = false;
int numSurf = paintinfo.m_aApplySurfs.Count();
for ( int i=0; i<numSurf; ++i )
{
// check if surface is behind main surface
if ( IsSurfaceInFrontOfPlane( paintinfo.m_aApplySurfs[i], paintinfo.m_plane ) )
{
if ( R_PaintSurface( paintinfo.m_aApplySurfs[i], vPosition, flSphereRadius, paintinfo.m_plane, colorIndex, flPaintCoatPercent ) )
{
bChangedPaint = true;
}
}
}
return bChangedPaint;
}
//-----------------------------------------------------------------------------
// iterate over all surfaces on a model, to find painted surface at the collision point
//-----------------------------------------------------------------------------
void GetPaintColorFromSurface( SurfaceHandle_t surfID, const Vector& vPosition, const Vector& vContactNormal, float flSphereRadius, const VPlane& basePlane, CUtlVector<BYTE>& surfColors )
{
if ( (MSurf_Flags( surfID ) & SURFDRAW_PAINTED) == 0 )
return;
// only detects paint from surface that has similar normal
if ( DotProduct( vContactNormal, MSurf_GetForwardFacingPlane( surfID ).m_Normal ) < 0.9f )
return;
int lightmapID = materialSortInfoArray[MSurf_MaterialSortID( surfID )].lightmapPageID;
PaintRect_t paintRect;
if ( ComputePaintRect( surfID, vPosition, flSphereRadius, paintRect ) )
{
g_PaintManager.m_pPaintTextureDataArray[ lightmapID ].GetPixels( paintRect.rect, surfColors );
}
}
void TracePaintSphere( const model_t *pModel, const Vector& vPosition, const Vector& vContactNormal, float flSphereRadius, CUtlVector<BYTE>& surfColors )
{
if ( !g_PaintManager.m_bShouldRegister || g_PaintManager.m_pPaintTextureDataArray == NULL )
{
return;
}
Assert( pModel );
if ( !pModel )
return;
//clear paint
surfColors.RemoveAll();
paintinfo_t paintinfo;
paintinfo.m_vPosition = vPosition;
paintinfo.m_flSize = flSphereRadius;
paintinfo.m_flCurrentDistance = FLT_MAX;
paintinfo.m_pBrush = pModel->brush.pShared;
paintinfo.m_aApplySurfs.RemoveAll();
paintinfo.m_bPainting = false;
mnode_t *pnodes = paintinfo.m_pBrush->nodes + pModel->brush.firstnode;
R_PaintNode( pnodes, &paintinfo );
int numSurf = paintinfo.m_aApplySurfs.Count();
for ( int i=0; i<numSurf; ++i )
{
GetPaintColorFromSurface( paintinfo.m_aApplySurfs[i], vPosition, vContactNormal, flSphereRadius, paintinfo.m_plane, surfColors );
}
}
void R_RedownloadAllPaintmaps()
{
if ( g_PaintManager.m_bShouldRegister )
{
for ( int i=0; i<g_PaintManager.m_iPaintmaps; ++i )
{
g_PaintManager.m_pPaintTextureDataArray[i].MarkAsDirty();
}
g_PaintManager.UpdatePaintmapTextures();
}
}
#if 0
CON_COMMAND_F( dump_paintmaps, "dump paintmap data to \"paintmap_#.txt\"", FCVAR_CHEAT )
{
for ( int i=0; i<g_PaintManager.m_iPaintmaps; ++i )
{
char filename[64];
V_snprintf( filename, sizeof(filename), "paintmap_%i.txt", i );
CUtlBuffer buf;
const BYTE *pData = g_PaintManager.GetPaintmapData(i);
int w,h;
g_PaintManager.GetPaintmapSize( i, w, h );
int size = w*h;
for ( int b=0; b<size; ++b)
{
buf.PutChar( pData[b] );
}
g_pFullFileSystem->WriteFile( filename, NULL, buf );
buf.Purge();
}
}
#endif
Reference in New Issue Copy Permalink