MapBase/source-sdk-2013-mapbase
1
0
Fork 0
mirror of https://github.com/mapbase-source/source-sdk-2013.git synced 2025-01-09 05:35:30 +03:00
Code Issues Packages Projects Releases Wiki Activity
be71cb487f
source-sdk-2013-mapbase/sp/src/game/server/SkyCamera.cpp
Blixibon c448f194ae Mapbase v5.0 
- Added keyvalue to hl2_gamerules which allows respawning in singleplayer
- Added the game instructor system (including env_instructor_hint) from later Valve games using a VDC tutorial which adjusts the version from the Alien Swarm SDK to FPS rules and a Source 2013 environment; Also added new KV and icons for further control from mappers (tutorial mentioned by Maestra Fenix)
- Added L4D/TF2 glows + point_glow entity as an all-purpose SDK-based off-shoot of tf_glow
- Fixed weapon pickup sound not playing (reported by Sl0th and later Cvoxulary)
- Fixed env_projectedtextures not updating on save/load
- Added func_fake_worldportal, a spatial point_camera inspired by linked_portal_door based on SDK code alone (WIP, may be changed a lot in future updates)
- Added option for point_camera and func_reflective_glass to use different render targets, therefore allowing multiple cameras and mirrors to be active at the same time
- Added additional RT camera textures to choose from with a default of 3, but also controllable through a -numcameratextures command line param
- Added adjustable convars for main view NearZ and skybox NearZ (suggested by someone recently, also suggested by Klems over a year ago)
- Fixed map-specific localization files, cleaned up map-specific file code
- Added a new block to gameinfo.txt which allows mods to automatically append their own command line parameters
- Fixed math_lightpattern corruption when setting pattern/style while active
- Fixed the "Touch" input crashing when given no entity
- Added a way to add EFlags via keyvalue (suggested by Niker107)
- Fixed ai_script_conditions not working without a NPC actor (reported by MetroHam)
- Fixed point_radiation_source causing huge problems when intensity is 0, even though it was already advised against (reported by beefbacon)
- Added "Mapbase" header to Mapbase-specific code files
- Fixed an issue with updating sky_camera not obtaining area correctly, causing some entities to not draw in the skybox
- Added "CopyFogController" and "CopyFogControllerWithScale" inputs to sky_camera, which copy fog parameters directly from a fog controller
- Added "SetScale" input to sky_camera for live scale changing
- Added convar to control player crouch speed multiplier (suggested by ArtyIF)
- Added a ton of fixes for people running the Debug configuration of the codebase (partial credit to stepa2)
- Added support for pre-defined enums and constants in VScript, starting with various values from the SDK code (damage types, trace masks, etc.)
- Added limited support for Valve's Quaternion class in VScript
- Added new instance helper capabilities, destructible game instances, and other misc. changes to VScript library
- Replaced most of the VScript "accessor" classes with direct references to the original classes, as they were getting complicated fast and adding new VScript-only functions to the original classes might not be as bad as previously thought
- Added base NPC hooks for AI sensing in VScript (allows control over sight and hearing), also exposed CSound for it
- Added various functions and hooks for VPhysics integration in VScript
- Added VScript-based custom suit devices
- Expanded trace info exposed to VScript to allow plane and surface access (suggested by krassell)
- Added ability to insert localization strings through VScript
- Added various misc. VScript functions with various purposes, including reading/writing EFlags, movetypes, collision groups, etc.
- Fixed VBSP not being able to correctly parse parallax corrected cubemaps in maps with instances
2020-08-14 21:21:25 +00:00

463 lines
15 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "igamesystem.h"
#include "entitylist.h"
#include "SkyCamera.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// automatically hooks in the system's callbacks
CEntityClassList<CSkyCamera> g_SkyList;
template <> CSkyCamera *CEntityClassList<CSkyCamera>::m_pClassList = NULL;
#ifdef MAPBASE
CHandle<CSkyCamera> g_hActiveSkybox = NULL;
#endif
//-----------------------------------------------------------------------------
// Retrives the current skycamera
//-----------------------------------------------------------------------------
CSkyCamera* GetCurrentSkyCamera()
{
#ifdef MAPBASE
if ( g_hActiveSkybox.Get() == NULL )
{
g_hActiveSkybox = GetSkyCameraList();
}
return g_hActiveSkybox.Get();
#else
return g_SkyList.m_pClassList;
#endif
}
CSkyCamera* GetSkyCameraList()
{
return g_SkyList.m_pClassList;
}
//=============================================================================
LINK_ENTITY_TO_CLASS( sky_camera, CSkyCamera );
BEGIN_DATADESC( CSkyCamera )
DEFINE_KEYFIELD( m_skyboxData.scale, FIELD_INTEGER, "scale" ),
DEFINE_FIELD( m_skyboxData.origin, FIELD_VECTOR ),
DEFINE_FIELD( m_skyboxData.area, FIELD_INTEGER ),
#ifdef MAPBASE
DEFINE_FIELD( m_skyboxData.angles, FIELD_VECTOR ),
DEFINE_FIELD( m_skyboxData.skycamera, FIELD_EHANDLE ),
DEFINE_KEYFIELD( m_skyboxData.skycolor, FIELD_COLOR32, "skycolor" ),
DEFINE_KEYFIELD( m_bUseAnglesForSky, FIELD_BOOLEAN, "use_angles_for_sky" ),
#endif
// Quiet down classcheck
// DEFINE_FIELD( m_skyboxData, sky3dparams_t ),
// This is re-set up in the constructor
// DEFINE_FIELD( m_pNext, CSkyCamera ),
// fog data for 3d skybox
DEFINE_KEYFIELD( m_bUseAngles, FIELD_BOOLEAN, "use_angles" ),
DEFINE_KEYFIELD( m_skyboxData.fog.enable, FIELD_BOOLEAN, "fogenable" ),
DEFINE_KEYFIELD( m_skyboxData.fog.blend, FIELD_BOOLEAN, "fogblend" ),
DEFINE_KEYFIELD( m_skyboxData.fog.dirPrimary, FIELD_VECTOR, "fogdir" ),
DEFINE_KEYFIELD( m_skyboxData.fog.colorPrimary, FIELD_COLOR32, "fogcolor" ),
DEFINE_KEYFIELD( m_skyboxData.fog.colorSecondary, FIELD_COLOR32, "fogcolor2" ),
DEFINE_KEYFIELD( m_skyboxData.fog.start, FIELD_FLOAT, "fogstart" ),
DEFINE_KEYFIELD( m_skyboxData.fog.end, FIELD_FLOAT, "fogend" ),
DEFINE_KEYFIELD( m_skyboxData.fog.maxdensity, FIELD_FLOAT, "fogmaxdensity" ),
#ifdef MAPBASE
DEFINE_KEYFIELD( m_skyboxData.fog.farz, FIELD_FLOAT, "farz" ),
#endif
#ifdef MAPBASE
DEFINE_INPUTFUNC( FIELD_VOID, "ForceUpdate", InputForceUpdate ),
DEFINE_INPUTFUNC( FIELD_VOID, "StartUpdating", InputStartUpdating ),
DEFINE_INPUTFUNC( FIELD_VOID, "StopUpdating", InputStopUpdating ),
DEFINE_INPUTFUNC( FIELD_VOID, "ActivateSkybox", InputActivateSkybox ),
DEFINE_INPUTFUNC( FIELD_VOID, "DeactivateSkybox", InputDeactivateSkybox ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetFogStartDist", InputSetFogStartDist ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetFogEndDist", InputSetFogEndDist ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetFogMaxDensity", InputSetFogMaxDensity ),
DEFINE_INPUTFUNC( FIELD_VOID, "TurnOnFog", InputTurnOnFog ),
DEFINE_INPUTFUNC( FIELD_VOID, "TurnOffFog", InputTurnOffFog ),
DEFINE_INPUTFUNC( FIELD_COLOR32, "SetFogColor", InputSetFogColor ),
DEFINE_INPUTFUNC( FIELD_COLOR32, "SetFogColorSecondary", InputSetFogColorSecondary ),
DEFINE_INPUTFUNC( FIELD_EHANDLE, "CopyFogController", InputCopyFogController ),
DEFINE_INPUTFUNC( FIELD_EHANDLE, "CopyFogControllerWithScale", InputCopyFogControllerWithScale ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetFarZ", InputSetFarZ ),
DEFINE_INPUTFUNC( FIELD_COLOR32, "SetSkyColor", InputSetSkyColor ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetScale", InputSetScale ),
DEFINE_THINKFUNC( UpdateThink ),
#endif
END_DATADESC()
//-----------------------------------------------------------------------------
// List of maps in HL2 that we must apply our skybox fog fixup hack to
//-----------------------------------------------------------------------------
static const char *s_pBogusFogMaps[] =
{
"d1_canals_01",
"d1_canals_01a",
"d1_canals_02",
"d1_canals_03",
"d1_canals_09",
"d1_canals_10",
"d1_canals_11",
"d1_canals_12",
"d1_canals_13",
"d1_eli_01",
"d1_trainstation_01",
"d1_trainstation_03",
"d1_trainstation_04",
"d1_trainstation_05",
"d1_trainstation_06",
"d3_c17_04",
"d3_c17_11",
"d3_c17_12",
"d3_citadel_01",
NULL
};
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CSkyCamera::CSkyCamera()
{
g_SkyList.Insert( this );
m_skyboxData.fog.maxdensity = 1.0f;
#ifdef MAPBASE
m_skyboxData.skycolor.Init(0, 0, 0, 0);
#endif
}
CSkyCamera::~CSkyCamera()
{
g_SkyList.Remove( this );
}
void CSkyCamera::Spawn( void )
{
#ifdef MAPBASE
if (HasSpawnFlags(SF_SKY_MASTER))
g_hActiveSkybox = this;
if (HasSpawnFlags(SF_SKY_START_UPDATING))
{
SetCameraEntityMode();
SetThink( &CSkyCamera::UpdateThink );
SetNextThink( gpGlobals->curtime + TICK_INTERVAL );
}
else
{
SetCameraPositionMode();
}
#else
m_skyboxData.origin = GetLocalOrigin();
#endif
m_skyboxData.area = engine->GetArea( m_skyboxData.origin );
Precache();
}
//-----------------------------------------------------------------------------
// Activate!
//-----------------------------------------------------------------------------
void CSkyCamera::Activate( )
{
BaseClass::Activate();
if ( m_bUseAngles )
{
AngleVectors( GetAbsAngles(), &m_skyboxData.fog.dirPrimary.GetForModify() );
m_skyboxData.fog.dirPrimary.GetForModify() *= -1.0f;
}
#ifdef HL2_DLL
// NOTE! This is a hack. There was a bug in the skybox fog computation
// on the client DLL that caused it to use the average of the primary and
// secondary fog color when blending was enabled. The bug is fixed, but to make
// the maps look the same as before the bug fix without having to download new maps,
// I have to cheat here and slam the primary and secondary colors to be the average of
// the primary and secondary colors.
if ( m_skyboxData.fog.blend )
{
for ( int i = 0; s_pBogusFogMaps[i]; ++i )
{
if ( !Q_stricmp( s_pBogusFogMaps[i], STRING(gpGlobals->mapname) ) )
{
m_skyboxData.fog.colorPrimary.SetR( ( m_skyboxData.fog.colorPrimary.GetR() + m_skyboxData.fog.colorSecondary.GetR() ) * 0.5f );
m_skyboxData.fog.colorPrimary.SetG( ( m_skyboxData.fog.colorPrimary.GetG() + m_skyboxData.fog.colorSecondary.GetG() ) * 0.5f );
m_skyboxData.fog.colorPrimary.SetB( ( m_skyboxData.fog.colorPrimary.GetB() + m_skyboxData.fog.colorSecondary.GetB() ) * 0.5f );
m_skyboxData.fog.colorPrimary.SetA( ( m_skyboxData.fog.colorPrimary.GetA() + m_skyboxData.fog.colorSecondary.GetA() ) * 0.5f );
m_skyboxData.fog.colorSecondary = m_skyboxData.fog.colorPrimary;
}
}
}
#endif
}
#ifdef MAPBASE
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CSkyCamera::AcceptInput( const char *szInputName, CBaseEntity *pActivator, CBaseEntity *pCaller, variant_t Value, int outputID )
{
if (!BaseClass::AcceptInput( szInputName, pActivator, pCaller, Value, outputID ))
return false;
if (g_hActiveSkybox == this)
{
// Most inputs require an update
DoUpdate( true );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSkyCamera::SetCameraEntityMode()
{
m_skyboxData.skycamera = this;
// Ensure the viewrender knows whether this should be using angles
if (m_bUseAnglesForSky)
m_skyboxData.angles.SetX( 1 );
else
m_skyboxData.angles.SetX( 0 );
}
void CSkyCamera::SetCameraPositionMode()
{
// Must be absolute now that the sky_camera can be parented
m_skyboxData.skycamera = NULL;
m_skyboxData.origin = GetAbsOrigin();
if (m_bUseAnglesForSky)
m_skyboxData.angles = GetAbsAngles();
}
//-----------------------------------------------------------------------------
// Purpose: Update sky position mid-game
//-----------------------------------------------------------------------------
bool CSkyCamera::DoUpdate( bool bUpdateData )
{
// Now that sky camera updating uses an entity handle directly transmitted to the client,
// this thinking is only used to update area and other parameters
// Getting into another area is unlikely, but if it's not expensive, I guess it's okay.
int area = engine->GetArea( GetAbsOrigin() );
if (m_skyboxData.area != area)
{
m_skyboxData.area = area;
bUpdateData = true;
}
if ( m_bUseAngles )
{
Vector fogForward;
AngleVectors( GetAbsAngles(), &fogForward );
fogForward *= -1.0f;
if ( m_skyboxData.fog.dirPrimary.Get() != fogForward )
{
m_skyboxData.fog.dirPrimary = fogForward;
bUpdateData = true;
}
}
if (bUpdateData)
{
// Updates client data, this completely ignores m_pOldSkyCamera
CBasePlayer *pPlayer = NULL;
for (int i = 1; i <= gpGlobals->maxClients; i++)
{
pPlayer = UTIL_PlayerByIndex(i);
if (pPlayer)
pPlayer->m_Local.m_skybox3d.CopyFrom(m_skyboxData);
}
}
// Needed for entity interpolation
SetSimulationTime( gpGlobals->curtime );
return bUpdateData;
}
void CSkyCamera::UpdateThink()
{
if (DoUpdate())
{
SetNextThink( gpGlobals->curtime + TICK_INTERVAL );
}
else
{
SetNextThink( gpGlobals->curtime + 0.2f );
}
}
void CSkyCamera::InputForceUpdate( inputdata_t &inputdata )
{
if (m_skyboxData.skycamera == NULL)
{
m_skyboxData.origin = GetAbsOrigin();
if (m_bUseAnglesForSky)
m_skyboxData.angles = GetAbsAngles();
}
DoUpdate( true );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSkyCamera::InputStartUpdating( inputdata_t &inputdata )
{
if (GetCurrentSkyCamera() == this)
{
SetCameraEntityMode();
DoUpdate( true );
SetThink( &CSkyCamera::UpdateThink );
SetNextThink( gpGlobals->curtime + TICK_INTERVAL );
}
// If we become the current sky camera later, remember that we want to update
AddSpawnFlags( SF_SKY_START_UPDATING );
// Must update transmit state so we show up on the client
DispatchUpdateTransmitState();
}
void CSkyCamera::InputStopUpdating( inputdata_t &inputdata )
{
SetThink( NULL );
SetNextThink( TICK_NEVER_THINK );
RemoveSpawnFlags( SF_SKY_START_UPDATING );
DispatchUpdateTransmitState();
SetCameraPositionMode();
DoUpdate( true );
}
//-----------------------------------------------------------------------------
// Activate!
//-----------------------------------------------------------------------------
void CSkyCamera::InputActivateSkybox( inputdata_t &inputdata )
{
CSkyCamera *pActiveSky = GetCurrentSkyCamera();
if (pActiveSky && pActiveSky->GetNextThink() != TICK_NEVER_THINK && pActiveSky != this)
{
// Deactivate that skybox
pActiveSky->SetThink( NULL );
pActiveSky->SetNextThink( TICK_NEVER_THINK );
}
g_hActiveSkybox = this;
if (HasSpawnFlags( SF_SKY_START_UPDATING ))
InputStartUpdating( inputdata );
}
//-----------------------------------------------------------------------------
// Deactivate!
//-----------------------------------------------------------------------------
void CSkyCamera::InputDeactivateSkybox( inputdata_t &inputdata )
{
if (GetCurrentSkyCamera() == this)
{
g_hActiveSkybox = NULL;
// ClientData doesn't catch this immediately
CBasePlayer *pPlayer = NULL;
for (int i = 1; i <= gpGlobals->maxClients; i++)
{
pPlayer = UTIL_PlayerByIndex( i );
if (pPlayer)
pPlayer->m_Local.m_skybox3d.area = 255;
}
}
SetThink( NULL );
SetNextThink( TICK_NEVER_THINK );
}
//------------------------------------------------------------------------------
// Purpose: Input handlers for setting fog stuff.
//------------------------------------------------------------------------------
void CSkyCamera::InputSetFogStartDist( inputdata_t &inputdata ) { m_skyboxData.fog.start = inputdata.value.Float(); }
void CSkyCamera::InputSetFogEndDist( inputdata_t &inputdata ) { m_skyboxData.fog.end = inputdata.value.Float(); }
void CSkyCamera::InputSetFogMaxDensity( inputdata_t &inputdata ) { m_skyboxData.fog.maxdensity = inputdata.value.Float(); }
void CSkyCamera::InputTurnOnFog( inputdata_t &inputdata ) { m_skyboxData.fog.enable = true; }
void CSkyCamera::InputTurnOffFog( inputdata_t &inputdata ) { m_skyboxData.fog.enable = false; }
void CSkyCamera::InputSetFogColor( inputdata_t &inputdata ) { m_skyboxData.fog.colorPrimary = inputdata.value.Color32(); }
void CSkyCamera::InputSetFogColorSecondary( inputdata_t &inputdata ) { m_skyboxData.fog.colorSecondary = inputdata.value.Color32(); }
void CSkyCamera::InputSetFarZ( inputdata_t &inputdata ) { m_skyboxData.fog.farz = inputdata.value.Int(); }
void CSkyCamera::InputCopyFogController( inputdata_t &inputdata )
{
CFogController *pFogController = dynamic_cast<CFogController*>(inputdata.value.Entity().Get());
if (!pFogController)
return;
m_skyboxData.fog.dirPrimary = pFogController->m_fog.dirPrimary;
m_skyboxData.fog.colorPrimary = pFogController->m_fog.colorPrimary;
m_skyboxData.fog.colorSecondary = pFogController->m_fog.colorSecondary;
//m_skyboxData.fog.colorPrimaryLerpTo = pFogController->m_fog.colorPrimaryLerpTo;
//m_skyboxData.fog.colorSecondaryLerpTo = pFogController->m_fog.colorSecondaryLerpTo;
m_skyboxData.fog.start = pFogController->m_fog.start;
m_skyboxData.fog.end = pFogController->m_fog.end;
m_skyboxData.fog.farz = pFogController->m_fog.farz;
m_skyboxData.fog.maxdensity = pFogController->m_fog.maxdensity;
//m_skyboxData.fog.startLerpTo = pFogController->m_fog.startLerpTo;
//m_skyboxData.fog.endLerpTo = pFogController->m_fog.endLerpTo;
//m_skyboxData.fog.lerptime = pFogController->m_fog.lerptime;
//m_skyboxData.fog.duration = pFogController->m_fog.duration;
//m_skyboxData.fog.enable = pFogController->m_fog.enable;
m_skyboxData.fog.blend = pFogController->m_fog.blend;
}
void CSkyCamera::InputCopyFogControllerWithScale( inputdata_t &inputdata )
{
CFogController *pFogController = dynamic_cast<CFogController*>(inputdata.value.Entity().Get());
if (!pFogController)
return;
m_skyboxData.fog.dirPrimary = pFogController->m_fog.dirPrimary;
m_skyboxData.fog.colorPrimary = pFogController->m_fog.colorPrimary;
m_skyboxData.fog.colorSecondary = pFogController->m_fog.colorSecondary;
//m_skyboxData.fog.colorPrimaryLerpTo = pFogController->m_fog.colorPrimaryLerpTo;
//m_skyboxData.fog.colorSecondaryLerpTo = pFogController->m_fog.colorSecondaryLerpTo;
m_skyboxData.fog.start = pFogController->m_fog.start * m_skyboxData.scale;
m_skyboxData.fog.end = pFogController->m_fog.end * m_skyboxData.scale;
m_skyboxData.fog.farz = pFogController->m_fog.farz != -1 ? (pFogController->m_fog.farz * m_skyboxData.scale) : pFogController->m_fog.farz;
m_skyboxData.fog.maxdensity = pFogController->m_fog.maxdensity;
//m_skyboxData.fog.startLerpTo = pFogController->m_fog.startLerpTo;
//m_skyboxData.fog.endLerpTo = pFogController->m_fog.endLerpTo;
//m_skyboxData.fog.lerptime = pFogController->m_fog.lerptime;
//m_skyboxData.fog.duration = pFogController->m_fog.duration;
//m_skyboxData.fog.enable = pFogController->m_fog.enable;
m_skyboxData.fog.blend = pFogController->m_fog.blend;
}
#endif
Reference in New Issue View Git Blame Copy Permalink