void CReplayRenderer::DrawResolvingQuad( int nWidth, int nHeight )
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
IMesh *pMesh = pRenderContext->GetDynamicMesh();
CMeshBuilder meshBuilder;
// Epsilons for 1:1 texel to pixel mapping
float fWidthEpsilon = IsOSX() ? 0.0f : 0.5f / ((float) nWidth);
float fHeightEpsilon = IsOSX() ? 0.0f : 0.5f / ((float) nHeight);
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.Position3f( -1.0f, 1.0f, 0.5f ); // Upper left
meshBuilder.TexCoord2f( 0, 0.0f + fWidthEpsilon, 0.0f + fHeightEpsilon );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( -1.0f, -1.0f, 0.5f ); // Lower left
meshBuilder.TexCoord2f( 0, 0.0f + fWidthEpsilon, 1.0f + fHeightEpsilon );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( 1.0f, -1.0f, 0.5f ); // Lower right
meshBuilder.TexCoord2f( 0, 1.0f + fWidthEpsilon, 1.0f + fHeightEpsilon );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( 1.0f, 1.0f, 0.5f ); // Upper right
meshBuilder.TexCoord2f( 0, 1.0f + fWidthEpsilon, 0.0f + fHeightEpsilon );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
void SetSpriteCommonShadowState( unsigned int shaderFlags )
{
IShaderShadow *pShaderShadow = s_pShaderShadow;
s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
bool bSRGB = s_ppParams[NOSRGB]->GetIntValue() == 0;
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, bSRGB );
// Only enabling this on OSX() - it causes GL mode's light glow sprites to be much darker vs. D3D9 under Linux/Win GL.
bool bSRGBOutputAdapter = ( IsOSX() && !g_pHardwareConfig->FakeSRGBWrite() ) && !bSRGB;
unsigned int flags = VERTEX_POSITION;
if( shaderFlags & SHADER_USE_VERTEX_COLOR )
{
flags |= VERTEX_COLOR;
}
int numTexCoords = 1;
s_pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, 0 );
DECLARE_STATIC_VERTEX_SHADER( jl_sprite_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, ( shaderFlags & SHADER_USE_VERTEX_COLOR ) ? true : false );
SET_STATIC_VERTEX_SHADER_COMBO( SRGB, bSRGB );
SET_STATIC_VERTEX_SHADER( jl_sprite_vs20 );
if( g_pHardwareConfig->SupportsPixelShaders_2_b() || g_pHardwareConfig->ShouldAlwaysUseShaderModel2bShaders() ) // Always send GL down this path
{
DECLARE_STATIC_PIXEL_SHADER( jl_sprite_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, ( shaderFlags & SHADER_USE_VERTEX_COLOR ) ? true : false );
SET_STATIC_PIXEL_SHADER_COMBO( CONSTANTCOLOR, ( shaderFlags & SHADER_USE_CONSTANT_COLOR ) ? true : false );
SET_STATIC_PIXEL_SHADER_COMBO( HDRTYPE, g_pHardwareConfig->GetHDRType() );
SET_STATIC_PIXEL_SHADER_COMBO( SRGB, bSRGB );
SET_STATIC_PIXEL_SHADER_COMBO( SRGB_OUTPUT_ADAPTER, bSRGBOutputAdapter );
SET_STATIC_PIXEL_SHADER( jl_sprite_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( jl_sprite_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, ( shaderFlags & SHADER_USE_VERTEX_COLOR ) ? true : false );
SET_STATIC_PIXEL_SHADER_COMBO( CONSTANTCOLOR, ( shaderFlags & SHADER_USE_CONSTANT_COLOR ) ? true : false );
SET_STATIC_PIXEL_SHADER_COMBO( HDRTYPE, g_pHardwareConfig->GetHDRType() );
SET_STATIC_PIXEL_SHADER_COMBO( SRGB, bSRGB );
SET_STATIC_PIXEL_SHADER( jl_sprite_ps20 );
}
// OSX always has to sRGB write (don't do this on Linux/Win GL - it causes glow sprites to be way too dark)
s_pShaderShadow->EnableSRGBWrite( bSRGB || ( IsOSX() && !g_pHardwareConfig->FakeSRGBWrite() ) );
}
//-----------------------------------------------------------------------------
// Attach to a material
//-----------------------------------------------------------------------------
void CMaterialReference::Init( char const* pMaterialName, const char *pTextureGroupName, bool bComplain )
{
IMaterial *pMaterial = materials->FindMaterial( pMaterialName, pTextureGroupName, bComplain);
if( IsErrorMaterial( pMaterial ) )
{
if (IsOSX())
{
printf("\n ##### CMaterialReference::Init got error material for %s in tex group %s", pMaterialName, pTextureGroupName );
}
}
Assert( pMaterial );
Init( pMaterial );
}
// todo(jonahr): Eventually could add support for all conditions/operating
// systems, but these are the ones in use for now
void validateConfigBase(const GPUTestConfig &config)
{
EXPECT_EQ(IsWindows(), config.getConditions()[GPUTestConfig::kConditionWin]);
EXPECT_EQ(IsOSX(), config.getConditions()[GPUTestConfig::kConditionMac]);
EXPECT_EQ(IsLinux(), config.getConditions()[GPUTestConfig::kConditionLinux]);
EXPECT_EQ(IsAndroid(), config.getConditions()[GPUTestConfig::kConditionAndroid]);
EXPECT_EQ(IsNexus5X(), config.getConditions()[GPUTestConfig::kConditionNexus5X]);
EXPECT_EQ(IsPixel2(), config.getConditions()[GPUTestConfig::kConditionPixel2]);
EXPECT_EQ(IsIntel(), config.getConditions()[GPUTestConfig::kConditionIntel]);
EXPECT_EQ(IsAMD(), config.getConditions()[GPUTestConfig::kConditionAMD]);
EXPECT_EQ(IsNVIDIA(), config.getConditions()[GPUTestConfig::kConditionNVIDIA]);
EXPECT_EQ(IsDebug(), config.getConditions()[GPUTestConfig::kConditionDebug]);
EXPECT_EQ(IsRelease(), config.getConditions()[GPUTestConfig::kConditionRelease]);
}
void DrawRefract_DX9( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI,
IShaderShadow* pShaderShadow, Refract_DX9_Vars_t &info, VertexCompressionType_t vertexCompression )
{
bool bIsModel = IS_FLAG_SET( MATERIAL_VAR_MODEL );
bool bHasEnvmap = params[info.m_nEnvmap]->IsTexture();
bool bRefractTintTexture = params[info.m_nRefractTintTexture]->IsTexture();
bool bFadeOutOnSilhouette = params[info.m_nFadeOutOnSilhouette]->GetIntValue() != 0;
int blurAmount = params[info.m_nBlurAmount]->GetIntValue();
bool bMasked = (params[info.m_nMasked]->GetIntValue() != 0);
bool bSecondaryNormal = ( ( info.m_nNormalMap2 != -1 ) && ( params[info.m_nNormalMap2]->IsTexture() ) );
bool bColorModulate = ( ( info.m_nVertexColorModulate != -1 ) && ( params[info.m_nVertexColorModulate]->GetIntValue() ) );
bool bWriteZ = params[info.m_nNoWriteZ]->GetIntValue() == 0;
if( blurAmount < 0 )
{
blurAmount = 0;
}
else if( blurAmount > MAXBLUR )
{
blurAmount = MAXBLUR;
}
BlendType_t nBlendType = pShader->EvaluateBlendRequirements( BASETEXTURE, true );
bool bFullyOpaque = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !IS_FLAG_SET(MATERIAL_VAR_ALPHATEST); //dest alpha is free for special use
bFullyOpaque &= !bMasked;
bool bTranslucentNormal = pShader->TextureIsTranslucent( info.m_nNormalMap, false );
bFullyOpaque &= (! bTranslucentNormal );
NormalDecodeMode_t nNormalDecodeMode = NORMAL_DECODE_NONE;
if ( g_pHardwareConfig->SupportsNormalMapCompression() )
{
ITexture *pBumpTex = params[info.m_nNormalMap]->GetTextureValue();
if ( pBumpTex )
{
nNormalDecodeMode = pBumpTex->GetNormalDecodeMode();
if ( bSecondaryNormal ) // Check encoding of secondary normal if there is one
{
ITexture *pBumpTex2 = params[info.m_nNormalMap2]->GetTextureValue();
if ( pBumpTex2 && ( pBumpTex2->GetNormalDecodeMode() != nNormalDecodeMode ) )
{
DevMsg("Refract: Primary and Secondary normal map compression formats don't match. This is unsupported!\n");
Assert(0);
}
}
}
}
SHADOW_STATE
{
pShader->SetInitialShadowState( );
pShaderShadow->EnableDepthWrites( bWriteZ );
// Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState
pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
// If envmap is not specified, the alpha channel is the translucency
// (If envmap *is* specified, alpha channel is the reflection amount)
if ( params[info.m_nNormalMap]->IsTexture() && !bHasEnvmap )
{
pShader->SetDefaultBlendingShadowState( info.m_nNormalMap, false );
}
// source render target that contains the image that we are warping.
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true );
// normal map
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
if ( nNormalDecodeMode == NORMAL_DECODE_ATI2N_ALPHA )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); // Normal map alpha, in the compressed normal case
}
if ( bSecondaryNormal )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
if ( nNormalDecodeMode == NORMAL_DECODE_ATI2N_ALPHA )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); // Secondary normal map alpha, in the compressed normal case
}
}
if( bHasEnvmap )
{
// envmap
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true );
}
if( bRefractTintTexture )
{
// refract tint texture
pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER5, true );
}
pShaderShadow->EnableSRGBWrite( true );
unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;
int userDataSize = 0;
int nTexCoordCount = 1;
if( bIsModel )
{
userDataSize = 4;
}
else
{
flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T;
}
if ( bColorModulate )
{
flags |= VERTEX_COLOR;
}
// This shader supports compressed vertices, so OR in that flag:
flags |= VERTEX_FORMAT_COMPRESSED;
pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, NULL, userDataSize );
DECLARE_STATIC_VERTEX_SHADER( jl_refract_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( MODEL, bIsModel );
SET_STATIC_VERTEX_SHADER_COMBO( COLORMODULATE, bColorModulate );
SET_STATIC_VERTEX_SHADER( jl_refract_vs20 );
// We have to do this in the shader on R500 or Leopard
bool bShaderSRGBConvert = IsOSX() && ( g_pHardwareConfig->FakeSRGBWrite() || !g_pHardwareConfig->CanDoSRGBReadFromRTs() );
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() || g_pHardwareConfig->ShouldAlwaysUseShaderModel2bShaders() ) // always send OpenGL down the ps2b path
{
DECLARE_STATIC_PIXEL_SHADER( jl_refract_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( BLUR, blurAmount );
SET_STATIC_PIXEL_SHADER_COMBO( FADEOUTONSILHOUETTE, bFadeOutOnSilhouette );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap );
SET_STATIC_PIXEL_SHADER_COMBO( REFRACTTINTTEXTURE, bRefractTintTexture );
SET_STATIC_PIXEL_SHADER_COMBO( MASKED, bMasked );
SET_STATIC_PIXEL_SHADER_COMBO( COLORMODULATE, bColorModulate );
SET_STATIC_PIXEL_SHADER_COMBO( SECONDARY_NORMAL, bSecondaryNormal );
SET_STATIC_PIXEL_SHADER_COMBO( NORMAL_DECODE_MODE, (int) nNormalDecodeMode );
SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSRGBConvert );
SET_STATIC_PIXEL_SHADER( jl_refract_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( jl_refract_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( BLUR, blurAmount );
SET_STATIC_PIXEL_SHADER_COMBO( FADEOUTONSILHOUETTE, bFadeOutOnSilhouette );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap );
SET_STATIC_PIXEL_SHADER_COMBO( REFRACTTINTTEXTURE, bRefractTintTexture );
SET_STATIC_PIXEL_SHADER_COMBO( MASKED, bMasked );
SET_STATIC_PIXEL_SHADER_COMBO( COLORMODULATE, bColorModulate );
SET_STATIC_PIXEL_SHADER_COMBO( SECONDARY_NORMAL, bSecondaryNormal );
SET_STATIC_PIXEL_SHADER_COMBO( NORMAL_DECODE_MODE, (int) nNormalDecodeMode );
SET_STATIC_PIXEL_SHADER( jl_refract_ps20 );
}
pShader->DefaultFog();
if( bMasked )
{
pShader->EnableAlphaBlending( SHADER_BLEND_ONE_MINUS_SRC_ALPHA, SHADER_BLEND_SRC_ALPHA );
}
bool bAlphaWrites = bFullyOpaque || ( params[ info.m_nForceAlphaWrite ]->GetIntValue() != 0 );
pShaderShadow->EnableAlphaWrites( bAlphaWrites );
}
DYNAMIC_STATE
{
pShaderAPI->SetDefaultState();
if ( params[info.m_nBaseTexture]->IsTexture() )
{
pShader->BindTexture( SHADER_SAMPLER2, info.m_nBaseTexture, info.m_nFrame );
}
else
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_FRAME_BUFFER_FULL_TEXTURE_0 );
}
if ( nNormalDecodeMode == NORMAL_DECODE_ATI2N_ALPHA )
{
pShader->BindTexture( SHADER_SAMPLER3, SHADER_SAMPLER6, info.m_nNormalMap, info.m_nBumpFrame );
}
else
{
pShader->BindTexture( SHADER_SAMPLER3, info.m_nNormalMap, info.m_nBumpFrame );
}
if ( bSecondaryNormal )
{
if ( nNormalDecodeMode == NORMAL_DECODE_ATI2N_ALPHA )
{
pShader->BindTexture( SHADER_SAMPLER1, SHADER_SAMPLER7, info.m_nNormalMap2, info.m_nBumpFrame2 );
}
else
{
pShader->BindTexture( SHADER_SAMPLER1, info.m_nNormalMap2, info.m_nBumpFrame2 );
}
}
if( bHasEnvmap )
{
pShader->BindTexture( SHADER_SAMPLER4, info.m_nEnvmap, info.m_nEnvmapFrame );
}
if( bRefractTintTexture )
{
pShader->BindTexture( SHADER_SAMPLER5, info.m_nRefractTintTexture, info.m_nRefractTintTextureFrame );
}
DECLARE_DYNAMIC_VERTEX_SHADER( jl_refract_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER( jl_refract_vs20 );
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() || g_pHardwareConfig->ShouldAlwaysUseShaderModel2bShaders() ) // always send Posix down the ps2b path
{
DECLARE_DYNAMIC_PIXEL_SHADER( jl_refract_ps20b );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteZ && bFullyOpaque && pShaderAPI->ShouldWriteDepthToDestAlpha() );
SET_DYNAMIC_PIXEL_SHADER( jl_refract_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( jl_refract_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( jl_refract_ps20 );
}
pShader->SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, info.m_nBumpTransform ); // 1 & 2
pShader->SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_3, info.m_nBumpTransform2 ); // 3 & 4
pShaderAPI->SetPixelShaderFogParams( PSREG_FOG_PARAMS );
float vEyePos_SpecExponent[4];
pShaderAPI->GetWorldSpaceCameraPosition( vEyePos_SpecExponent );
vEyePos_SpecExponent[3] = 0.0f;
pShaderAPI->SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vEyePos_SpecExponent, 1 );
pShader->SetPixelShaderConstantGammaToLinear( 0, info.m_nEnvmapTint );
pShader->SetPixelShaderConstantGammaToLinear( 1, info.m_nRefractTint );
pShader->SetPixelShaderConstant( 2, info.m_nEnvmapContrast );
pShader->SetPixelShaderConstant( 3, info.m_nEnvmapSaturation );
float c5[4] = { params[info.m_nRefractAmount]->GetFloatValue(),
params[info.m_nRefractAmount]->GetFloatValue(), 0.0f, 0.0f };
// Time % 1000
c5[3] = pShaderAPI->CurrentTime();
c5[3] -= (float)( (int)( c5[3] / 1000.0f ) ) * 1000.0f;
pShaderAPI->SetPixelShaderConstant( 5, c5, 1 );
float cVs3[4] = { c5[3], 0.0f, 0.0f, 0.0f };
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_5, cVs3, 1 );
}
pShader->Draw();
}
int CEstrangedSystemCaps::GetCaps( void )
{
int systemCaps = ( CAPS_MATERIAL_POSTPROCESS | CAPS_SHADER_POSTPROCESS | CAPS_ESTRANGED_DEPTHPASS | CAPS_SHADOW_DEPTHPASS );
// If we're in the middle of building cubemaps
ConVarRef building_cubemaps("building_cubemaps");
if ( building_cubemaps.GetBool() )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
systemCaps &= ~CAPS_SHADER_POSTPROCESS;
systemCaps &= ~CAPS_MATERIAL_POSTPROCESS;
}
// Check for null-ness...
if ( g_pMaterialSystemHardwareConfig )
{
// If we don't support shader model 3.0
if ( !g_pMaterialSystemHardwareConfig->SupportsShaderModel_3_0() )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
}
// If we support fetch4 (ATI)
if ( g_pMaterialSystemHardwareConfig->SupportsFetch4() )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
}
// If we use ATI depth formats
int shadowFilterMode = g_pMaterialSystemHardwareConfig->GetShadowFilterMode();
if ( shadowFilterMode != NVIDIA_PCF_POISSON && ( shadowFilterMode == ATI_NO_PCF_FETCH4 || shadowFilterMode == ATI_NOPCF ) )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
}
// If we're not running with DirectX 9
if ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() < 90 )
{
systemCaps &= ~CAPS_SHADER_POSTPROCESS;
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
systemCaps &= ~CAPS_SHADOW_DEPTHPASS;
}
// If we're not running with DirectX 8
if ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() < 80 )
{
systemCaps &= ~CAPS_MATERIAL_POSTPROCESS;
}
}
// If we're not Windows
if ( !IsWindows() )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
}
// ae - temporary bugfix: disable shader
// post processing on mac
if ( IsOSX() )
{
systemCaps &= ~CAPS_SHADER_POSTPROCESS;
}
// If we're in VR mode
if ( UseVR() )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
systemCaps &= ~CAPS_SHADER_POSTPROCESS;
}
// Check null
if ( materials )
{
// If we don't support shadow depth textures
if ( !materials->SupportsShadowDepthTextures() )
{
systemCaps &= ~CAPS_SHADOW_DEPTHPASS;
}
}
return systemCaps;
}
void AppendPlayerInformation(ISteamHTTP *pSteamHttp, HTTPRequestHandle httpRequest, CSteamAPIContext *pSteamAPIContext, CBasePlayer *pPlayer, bool bAnonymous)
{
// Local DS
time_t rawtime;
struct tm* timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);
char* local_ds = asctime(timeinfo);
char* newLine = strstr(local_ds, "\n");
if (newLine)
{
*newLine = 0;
}
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "localdatetime", local_ds);
// Build DS
char build_ds[64];
Q_snprintf(build_ds, sizeof(build_ds), "%s,%s", __DATE__, __TIME__);
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "builddatetime", build_ds);
// DxLevel
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "dxlevel", ConVarRef("mat_dxlevel").GetString());
if (pPlayer)
{
// Position
char player_position[32];
Vector player_pos = pPlayer->GetLocalOrigin();
Q_snprintf(player_position, sizeof(player_position), "%.2f,%.2f,%.2f", player_pos.x, player_pos.y, player_pos.z);
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "position", player_position);
// Angles
char player_angles[32];
QAngle player_ang = pPlayer->GetLocalAngles();
Q_snprintf(player_angles, sizeof(player_angles), "%.2f,%.2f,%.2f", player_ang.x, player_ang.y, player_ang.z);
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "angles", player_angles);
// Health
char player_health[16];
Q_snprintf(player_health, sizeof(player_health), "%i", pPlayer->GetHealth());
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "health", player_health);
// Weapon
CBaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if (pWeapon)
{
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "weapon", pWeapon->GetClassname());
}
}
// Cheats
char cheats_enabled[8];
Q_snprintf(cheats_enabled, sizeof(cheats_enabled), "%i", (ConVarRef("sv_cheats").GetBool() || ConVarRef("developer").GetBool()));
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "cheats", cheats_enabled);
// Map
#ifdef CLIENT_DLL
char mapname[256];
V_FileBase(engine->GetLevelName(), mapname, sizeof(mapname));
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "level", mapname);
#else
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "level", gpGlobals->mapname.ToCStr());
#endif
if (pSteamAPIContext)
{
// Language
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "language", pSteamAPIContext->SteamUtils()->GetSteamUILanguage());
}
// Platform
char * platform = "unknown";
if (IsPC()) platform = "pc";
if (IsOSX()) platform = "osx";
if (IsLinux()) platform = "linux";
if (IsX360()) platform = "360";
if (IsPS3()) platform = "ps3";
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "platform", platform);
// Player ID
if (bAnonymous == false)
{
if (ae_uniqueplayerid.GetInt() == 0)
GenerateUniquePlayerId(pSteamAPIContext);
pSteamHttp->SetHTTPRequestGetOrPostParameter(httpRequest, "playerid", ae_uniqueplayerid.GetString());
}
}
