Archive/TombEngine
0
0
Fork 0
mirror of https://github.com/TombEngine/TombEngine.git synced 2025-04-28 15:57:59 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'develop' into develop_mirrors;

Browse source 
Removed RendererMirror references in methods calls;
This commit is contained in:
MontyTRC89 2024-12-11 13:43:19 +01:00
commit 4e08942d86
28 changed files with 462 additions and 382 deletions
Download patch file Download diff file Expand all files Collapse all files

4
CHANGELOG.md
View file

@ -31,6 +31,7 @@ TombEngine releases are located in this repository (alongside with Tomb Editor):
* Fixed Lara's Home entry not working.
* Fixed exploding TR3 bosses.
* Fixed original issue with deactivation of Dart Emitter.
* Fixed original issue with weapon hotkeys available in binoculars or lasersight mode.
* Fixed Lens Flare object not functioning properly.
* Fixed lens flares not being occluded by static meshes and moveables.
* Fixed spotlight shadows.
@ -38,7 +39,9 @@ TombEngine releases are located in this repository (alongside with Tomb Editor):
### New Features
* Added fast savegame reloading.
* Added dynamic shadow casting on objects and static meshes.
* Added ricochet sounds and make the effect more prominent.
* Allow camera shake during flybys.
* Allow to run the engine without title level.
* Allow more than 1024 objects in a level.
* Allow more than 1000 static mesh slots in a level.
@ -56,6 +59,7 @@ TombEngine releases are located in this repository (alongside with Tomb Editor):
* Use load camera instead of load screen by playing fixed camera from OnEnd() event and removing loadScreenFile field from level's gameflow entry.
* Fixed DisplayString class not supporting some Unicode characters and empty lines in multiline strings.
* Fixed DisplayString not being deallocated after showing.
* Fixed GameVars not transferring between levels in hub mode.
* Fixed incorrect behaviour of Moveable:GetJointRotation() function.
* Fixed incorrect behaviour of Logic.EnableEvent() and Logic.DisableEvent() functions.
* Fixed Util.HasLineOfSight() not taking static meshes into consideration.

8
TombEngine/Game/Lara/lara_helpers.cpp
View file

@ -342,6 +342,10 @@ void HandlePlayerQuickActions(ItemInfo& item)
g_Gui.UseItem(item, GAME_OBJECT_ID::ID_BIGMEDI_ITEM);
}
// Don't process weapon hotkeys in optics mode.
if (player.Control.Look.IsUsingBinoculars)
return;
// Handle weapon scroll request.
if (IsClicked(In::PreviousWeapon) || IsClicked(In::NextWeapon))
{
@ -888,7 +892,9 @@ void HandlePlayerFlyCheat(ItemInfo& item)
{
if (player.Context.Vehicle == NO_VALUE)
{
GivePlayerItemsCheat(item);
if (KeyMap[OIS::KeyCode::KC_LSHIFT] || KeyMap[OIS::KeyCode::KC_RSHIFT])
GivePlayerItemsCheat(item);
GivePlayerWeaponsCheat(item);
if (player.Control.WaterStatus != WaterStatus::FlyCheat)

71
TombEngine/Game/camera.cpp
View file

@ -215,6 +215,38 @@ inline void RumbleFromBounce()
Rumble(std::clamp((float)abs(Camera.bounce) / 70.0f, 0.0f, 0.8f), 0.2f);
}
void CalculateBounce(bool binocularMode)
{
if (Camera.bounce == 0)
return;
if (Camera.bounce <= 0)
{
if (binocularMode)
{
Camera.target.x += (CLICK(0.25f) / 4) * (GetRandomControl() % (-Camera.bounce) - (-Camera.bounce / 2));
Camera.target.y += (CLICK(0.25f) / 4) * (GetRandomControl() % (-Camera.bounce) - (-Camera.bounce / 2));
Camera.target.z += (CLICK(0.25f) / 4) * (GetRandomControl() % (-Camera.bounce) - (-Camera.bounce / 2));
}
else
{
int bounce = -Camera.bounce;
int bounce2 = bounce / 2;
Camera.target.x += GetRandomControl() % bounce - bounce2;
Camera.target.y += GetRandomControl() % bounce - bounce2;
Camera.target.z += GetRandomControl() % bounce - bounce2;
}
Camera.bounce += 5;
RumbleFromBounce();
}
else
{
Camera.pos.y += Camera.bounce;
Camera.target.y += Camera.bounce;
Camera.bounce = 0;
}
}
void InitializeCamera()
{
@ -313,25 +345,7 @@ void MoveCamera(GameVector* ideal, int speed)
Camera.pos.z += (ideal->z - Camera.pos.z) / speed;
Camera.pos.RoomNumber = ideal->RoomNumber;
if (Camera.bounce)
{
if (Camera.bounce <= 0)
{
int bounce = -Camera.bounce;
int bounce2 = bounce / 2;
Camera.target.x += GetRandomControl() % bounce - bounce2;
Camera.target.y += GetRandomControl() % bounce - bounce2;
Camera.target.z += GetRandomControl() % bounce - bounce2;
Camera.bounce += 5;
RumbleFromBounce();
}
else
{
Camera.pos.y += Camera.bounce;
Camera.target.y += Camera.bounce;
Camera.bounce = 0;
}
}
CalculateBounce(false);
int y = Camera.pos.y;
if (TestEnvironment(ENV_FLAG_SWAMP, Camera.pos.RoomNumber))
@ -1000,23 +1014,8 @@ void BinocularCamera(ItemInfo* item)
Camera.target.RoomNumber = item->RoomNumber;
}
if (Camera.bounce &&
Camera.type == Camera.oldType)
{
if (Camera.bounce <= 0)
{
Camera.target.x += (CLICK(0.25f) / 4) * (GetRandomControl() % (-Camera.bounce) - (-Camera.bounce / 2));
Camera.target.y += (CLICK(0.25f) / 4) * (GetRandomControl() % (-Camera.bounce) - (-Camera.bounce / 2));
Camera.target.z += (CLICK(0.25f) / 4) * (GetRandomControl() % (-Camera.bounce) - (-Camera.bounce / 2));
Camera.bounce += 5;
RumbleFromBounce();
}
else
{
Camera.bounce = 0;
Camera.target.y += Camera.bounce;
}
}
if (Camera.type == Camera.oldType)
CalculateBounce(true);
Camera.target.RoomNumber = GetPointCollision(Camera.pos.ToVector3i(), Camera.target.RoomNumber).GetRoomNumber();
LookAt(&Camera, 0);

1
TombEngine/Game/camera.h
View file

@ -99,6 +99,7 @@ void BounceCamera(ItemInfo* item, short bounce, short maxDistance);
void BinocularCamera(ItemInfo* item);
void ConfirmCameraTargetPos();
void CalculateCamera(const CollisionInfo& coll);
void CalculateBounce(bool binocularMode);
void RumbleScreen();
bool TestBoundsCollideCamera(const GameBoundingBox& bounds, const Pose& pose, short radius);
void ItemPushCamera(GameBoundingBox* bounds, Pose* pos, short radius);

17
TombEngine/Game/control/control.cpp
View file

@ -376,7 +376,6 @@ unsigned CALLBACK GameMain(void *)
GameStatus DoLevel(int levelIndex, bool loadGame)
{
bool isTitle = !levelIndex;
auto loadType = loadGame ? LevelLoadType::Load : (SaveGame::IsOnHub(levelIndex) ? LevelLoadType::Hub : LevelLoadType::New);
TENLog(isTitle ? "DoTitle" : "DoLevel", LogLevel::Info);
@ -392,7 +391,7 @@ GameStatus DoLevel(int levelIndex, bool loadGame)
InitializeItemBoxData();
// Initialize scripting.
InitializeScripting(levelIndex, loadType);
InitializeScripting(levelIndex, loadGame);
InitializeNodeScripts();
// Initialize menu and inventory state.
@ -540,12 +539,12 @@ void CleanUp()
ClearObjCamera();
}
void InitializeScripting(int levelIndex, LevelLoadType type)
void InitializeScripting(int levelIndex, bool loadGame)
{
TENLog("Loading level script...", LogLevel::Info);
g_GameStringsHandler->ClearDisplayStrings();
g_GameScript->ResetScripts(!levelIndex || type != LevelLoadType::New);
g_GameScript->ResetScripts(!levelIndex || loadGame);
const auto& level = *g_GameFlow->GetLevel(levelIndex);
@ -575,7 +574,7 @@ void InitializeScripting(int levelIndex, LevelLoadType type)
}
// Play default background music.
if (type != LevelLoadType::Load)
if (!loadGame)
PlaySoundTrack(level.GetAmbientTrack(), SoundTrackType::BGM, 0, SOUND_XFADETIME_LEVELJUMP);
}
@ -594,8 +593,14 @@ void InitializeOrLoadGame(bool loadGame)
g_Gui.SetEnterInventory(NO_VALUE);
// Restore game?
if (loadGame && SaveGame::Load(g_GameFlow->SelectedSaveGame))
if (loadGame)
{
if (!SaveGame::Load(g_GameFlow->SelectedSaveGame))
{
NextLevel = g_GameFlow->GetNumLevels();
return;
}
InitializeGame = false;
g_GameFlow->SelectedSaveGame = 0;

11
TombEngine/Game/control/control.h
View file

@ -34,13 +34,6 @@ enum class FreezeMode
Player
};
enum class LevelLoadType
{
New,
Hub,
Load
};
enum CardinalDirection
{
NORTH,
@ -106,8 +99,8 @@ void UpdateShatters();
void CleanUp();
void InitializeOrLoadGame(bool loadGame);
void InitializeScripting(int levelIndex, LevelLoadType type);
void DeInitializeScripting(int levelIndex);
void InitializeScripting(int levelIndex, bool loadGame);
void DeInitializeScripting(int levelIndex, GameStatus reason);
void SetupInterpolation();

29
TombEngine/Game/savegame.cpp
View file

@ -206,6 +206,19 @@ bool SaveGame::DoesSaveGameExist(int slot, bool silent)
return true;
}
bool SaveGame::IsSaveGameValid(int slot)
{
SaveGameHeader header;
if (!LoadHeader(slot, &header))
return false;
// Hash mismatch between savegame and level file means that level version has changed.
if (header.LevelHash != LastLevelHash)
return false;
return true;
}
bool SaveGame::IsLoadGamePossible()
{
for (int i = 0; i < SAVEGAME_MAX; i++)
@ -1614,15 +1627,9 @@ bool SaveGame::Save(int slot)
bool SaveGame::Load(int slot)
{
if (!IsSaveGameSlotValid(slot))
if (!IsSaveGameValid(slot))
{
TENLog("Savegame slot " + std::to_string(slot) + " is invalid, load is impossible.", LogLevel::Error);
return false;
}
if (!DoesSaveGameExist(slot))
{
TENLog("Savegame in slot " + std::to_string(slot) + " does not exist.", LogLevel::Error);
TENLog("Loading from savegame in slot " + std::to_string(slot) + " is impossible, data is missing or level has changed.", LogLevel::Error);
return false;
}
@ -1704,7 +1711,7 @@ static void ParseStatistics(const Save::SaveGame* s, bool isHub)
SaveGame::Statistics.Game.Timer = s->game()->timer();
}
static void ParseLua(const Save::SaveGame* s)
static void ParseLua(const Save::SaveGame* s, bool hubMode)
{
// Event sets
@ -1808,7 +1815,7 @@ static void ParseLua(const Save::SaveGame* s)
}
}
g_GameScript->SetVariables(loadedVars);
g_GameScript->SetVariables(loadedVars, hubMode);
auto populateCallbackVecs = [&s](auto callbackFunc)
{
@ -2672,7 +2679,7 @@ void SaveGame::Parse(const std::vector<byte>& buffer, bool hubMode)
const Save::SaveGame* s = Save::GetSaveGame(buffer.data());
ParseLevel(s, hubMode);
ParseLua(s);
ParseLua(s, hubMode);
ParseStatistics(s, hubMode);
// Effects and player data is ignored when loading hub.

1
TombEngine/Game/savegame.h
View file

@ -66,6 +66,7 @@ public:
static bool DoesSaveGameExist(int slot, bool silent = false);
static bool IsLoadGamePossible();
static bool IsSaveGameValid(int slot);
static void SaveHub(int index);
static void LoadHub(int index);

1
TombEngine/Game/spotcam.cpp
View file

@ -494,6 +494,7 @@ void CalculateSpotCameras()
Camera.target.x = ctx;
Camera.target.y = cty;
Camera.target.z = ctz;
CalculateBounce(false);
}
int outsideRoom = IsRoomOutside(cpx, cpy, cpz);

64
TombEngine/Renderer/Renderer.cpp
View file

@ -201,49 +201,68 @@ namespace TEN::Renderer
_context->PSSetSamplers((UINT)registerType, 1, &samplerState);
}
void Renderer::BindLight(RendererLight& light, ShaderLight* lights, int index, RendererMirror* mirror)
int Renderer::BindLight(RendererLight& light, ShaderLight* lights, int index)
{
memcpy(&lights[index], &light, sizeof(ShaderLight));
// Precalculate ranges so that it's not recalculated in shader for every pixel.
if (light.Type == LightType::Spot)
{
lights[index].InRange = cos(light.InRange * (PI / 180.0f));
lights[index].OutRange = cos(light.OutRange * (PI / 180.0f));
}
// If light has hash, interpolate its position with previous position.
if (light.Hash != 0)
{
lights[index].Position = Vector3::Lerp(light.PrevPosition, light.Position, GetInterpolationFactor());
lights[index].Position = Vector3::Lerp(light.PrevPosition, light.Position, GetInterpolationFactor());
lights[index].Direction = Vector3::Lerp(light.PrevDirection, light.Direction, GetInterpolationFactor());
}
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
lights[index].Position = Vector3::Transform(lights[index].Position, mirror->ReflectionMatrix);
lights[index].Direction = Vector3::Transform(lights[index].Direction, mirror->ReflectionMatrix);
lights[index].Position = Vector3::Transform(lights[index].Position, _currentMirror->ReflectionMatrix);
lights[index].Direction = Vector3::Transform(lights[index].Direction, _currentMirror->ReflectionMatrix);
}
// Bitmask light type to filter it in the shader later.
return (1 << (31 - (int)light.Type));
}
void Renderer::BindRoomLights(std::vector<RendererLight*>& lights, RendererMirror* mirror)
void Renderer::BindRoomLights(std::vector<RendererLight*>& lights)
{
for (int i = 0; i < lights.size(); i++)
BindLight(*lights[i], _stRoom.RoomLights, i, mirror);
int lightTypeMask = 0;
_stRoom.NumRoomLights = (int)lights.size();
}
void Renderer::BindStaticLights(std::vector<RendererLight*>& lights, RendererMirror* mirror)
{
for (int i = 0; i < lights.size(); i++)
BindLight(*lights[i], _stStatic.Lights, i, mirror);
lightTypeMask = lightTypeMask | BindLight(*lights[i], _stRoom.RoomLights, i);
_stStatic.NumLights = (int)lights.size();
_stRoom.NumRoomLights = (int)lights.size() | lightTypeMask;
}
void Renderer::BindInstancedStaticLights(std::vector<RendererLight*>& lights, int instanceID, RendererMirror* mirror)
void Renderer::BindStaticLights(std::vector<RendererLight*>& lights)
{
int lightTypeMask = 0;
for (int i = 0; i < lights.size(); i++)
BindLight(*lights[i], _stInstancedStaticMeshBuffer.StaticMeshes[instanceID].Lights, i, mirror);
_stInstancedStaticMeshBuffer.StaticMeshes[instanceID].NumLights = (int)lights.size();
lightTypeMask = lightTypeMask | BindLight(*lights[i], _stStatic.Lights, i);
_stStatic.NumLights = (int)lights.size() | lightTypeMask;
}
void Renderer::BindMoveableLights(std::vector<RendererLight*>& lights, int roomNumber, int prevRoomNumber, float fade, RendererMirror* mirror)
void Renderer::BindInstancedStaticLights(std::vector<RendererLight*>& lights, int instanceID)
{
int lightTypeMask = 0;
for (int i = 0; i < lights.size(); i++)
lightTypeMask = lightTypeMask | BindLight(*lights[i], _stInstancedStaticMeshBuffer.StaticMeshes[instanceID].Lights, i);
_stInstancedStaticMeshBuffer.StaticMeshes[instanceID].NumLights = (int)lights.size() | lightTypeMask;
}
void Renderer::BindMoveableLights(std::vector<RendererLight*>& lights, int roomNumber, int prevRoomNumber, float fade)
{
int lightTypeMask = 0;
int numLights = 0;
for (int i = 0; i < lights.size(); i++)
{
@ -263,12 +282,13 @@ namespace TEN::Renderer
if (fadedCoeff == 0.0f)
continue;
BindLight(*lights[i], _stItem.Lights, numLights, mirror);
lightTypeMask = lightTypeMask | BindLight(*lights[i], _stItem.Lights, numLights);
_stItem.Lights[numLights].Intensity *= fadedCoeff;
numLights++;
}
_stItem.NumLights = numLights;
_stItem.NumLights = numLights | lightTypeMask;
}
void Renderer::BindConstantBufferVS(ConstantBufferRegister constantBufferType, ID3D11Buffer** buffer)

51
TombEngine/Renderer/Renderer.h
View file

@ -400,6 +400,7 @@ namespace TEN::Renderer
// Special effects
std::vector<Texture2D> _causticTextures;
RendererMirror* _currentMirror = nullptr;
// Transparency
@ -419,11 +420,11 @@ namespace TEN::Renderer
void ApplySMAA(RenderTarget2D* renderTarget, RenderView& view);
void ApplyFXAA(RenderTarget2D* renderTarget, RenderView& view);
void BindTexture(TextureRegister registerType, TextureBase* texture, SamplerStateRegister samplerType);
void BindLight(RendererLight& light, ShaderLight* lights, int index, RendererMirror* mirror);
void BindRoomLights(std::vector<RendererLight*>& lights, RendererMirror* mirror);
void BindStaticLights(std::vector<RendererLight*>& lights, RendererMirror* mirror);
void BindInstancedStaticLights(std::vector<RendererLight*>& lights, int instanceID, RendererMirror* mirror);
void BindMoveableLights(std::vector<RendererLight*>& lights, int roomNumber, int prevRoomNumber, float fade, RendererMirror* mirror);
int BindLight(RendererLight& light, ShaderLight* lights, int index);
void BindRoomLights(std::vector<RendererLight*>& lights);
void BindStaticLights(std::vector<RendererLight*>& lights);
void BindInstancedStaticLights(std::vector<RendererLight*>& lights, int instanceID);
void BindMoveableLights(std::vector<RendererLight*>& lights, int roomNumber, int prevRoomNumber, float fade);
void BindRenderTargetAsTexture(TextureRegister registerType, RenderTarget2D* target, SamplerStateRegister samplerType);
void BindConstantBufferVS(ConstantBufferRegister constantBufferType, ID3D11Buffer** buffer);
void BindConstantBufferPS(ConstantBufferRegister constantBufferType, ID3D11Buffer** buffer);
@ -455,12 +456,12 @@ namespace TEN::Renderer
void PrepareSingleLaserBeam(RenderView& view);
void DrawHorizonAndSky(RenderView& renderView, ID3D11DepthStencilView* depthTarget);
void DrawRooms(RenderView& view, RendererPass rendererPass);
void DrawItems(RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawAnimatingItem(RendererItem* item, RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawWaterfalls(RendererItem* item, RendererMirror* mirror, RenderView& view, int fps, RendererPass rendererPass);
void DrawBaddyGunflashes(RendererMirror* mirror, RenderView& view);
void DrawStatics(RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawLara(RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawItems(RenderView& view, RendererPass rendererPass);
void DrawAnimatingItem(RendererItem* item, RenderView& view, RendererPass rendererPass);
void DrawWaterfalls(RendererItem* item, RenderView& view, int fps, RendererPass rendererPass);
void DrawBaddyGunflashes(RenderView& view);
void DrawStatics(RenderView& view, RendererPass rendererPass);
void DrawLara(RenderView& view, RendererPass rendererPass);
void PrepareFires(RenderView& view);
void PrepareParticles(RenderView& view);
void PrepareSmokes(RenderView& view);
@ -470,12 +471,12 @@ namespace TEN::Renderer
void PrepareWeatherParticles(RenderView& view);
void PrepareDrips(RenderView& view);
void PrepareBubbles(RenderView& view);
void DrawEffects(RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawEffect(RendererMirror* mirror, RenderView& view, RendererEffect* effect, RendererPass rendererPass);
void DrawEffects(RenderView& view, RendererPass rendererPass);
void DrawEffect(RenderView& view, RendererEffect* effect, RendererPass rendererPass);
void PrepareSplashes(RenderView& view);
void DrawSprites(RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawSprites(RenderView& view, RendererPass rendererPass);
void DrawDisplaySprites(RenderView& view);
void DrawSortedFaces(RendererMirror* mirror, RenderView& view);
void DrawSortedFaces(RenderView& view);
void DrawSingleSprite(RendererSortableObject* object, RendererObjectType lastObjectType, RenderView& view);
void DrawRoomSorted(RendererSortableObject* objectInfo, RendererObjectType lastObjectType, RenderView& view);
void DrawItemSorted(RendererSortableObject* objectInfo, RendererObjectType lastObjectType, RenderView& view);
@ -488,17 +489,17 @@ namespace TEN::Renderer
void DrawOverlays(RenderView& view);
void PrepareRopes(RenderView& view);
void DrawFishSwarm(RenderView& view, RendererPass rendererPass);
void DrawBats(RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawRats(RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawScarabs(RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawBats(RenderView& view, RendererPass rendererPass);
void DrawRats(RenderView& view, RendererPass rendererPass);
void DrawScarabs(RenderView& view, RendererPass rendererPass);
void DrawSpiders(RenderView& view, RendererPass rendererPass);
bool DrawGunFlashes(RendererMirror* mirror, RenderView& view);
void DrawGunShells(RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawLocusts(RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
bool DrawGunFlashes(RenderView& view);
void DrawGunShells(RenderView& view, RendererPass rendererPass);
void DrawLocusts(RenderView& view, RendererPass rendererPass);
void DrawStatistics();
void DrawExamines();
void DrawDiary();
void DrawDebris(RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawDebris(RenderView& view, RendererPass rendererPass);
void DrawFullScreenImage(ID3D11ShaderResourceView* texture, float fade, ID3D11RenderTargetView* target,
ID3D11DepthStencilView* depthTarget);
void PrepareShockwaves(RenderView& view);
@ -509,9 +510,9 @@ namespace TEN::Renderer
void PrepareSmokeParticles(RenderView& view);
void PrepareSparkParticles(RenderView& view);
void PrepareExplosionParticles(RenderView& view);
void DrawLaraHolsters(RendererItem* itemToDraw, RendererRoom* room, RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawLaraJoints(RendererItem* itemToDraw, RendererRoom* room, RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawLaraHair(RendererItem* itemToDraw, RendererRoom* room, RendererMirror* mirror, RenderView& view, RendererPass rendererPass);
void DrawLaraHolsters(RendererItem* itemToDraw, RendererRoom* room, RenderView& view, RendererPass rendererPass);
void DrawLaraJoints(RendererItem* itemToDraw, RendererRoom* room, RenderView& view, RendererPass rendererPass);
void DrawLaraHair(RendererItem* itemToDraw, RendererRoom* room, RenderView& view, RendererPass rendererPass);
void DrawMoveableMesh(RendererItem* itemToDraw, RendererMesh* mesh, RendererRoom* room, int boneIndex, RenderView& view, RendererPass rendererPass);
void PrepareSimpleParticles(RenderView& view);
void PrepareStreamers(RenderView& view);

261
TombEngine/Renderer/RendererDraw.cpp
View file

@ -231,14 +231,14 @@ namespace TEN::Renderer
{
RendererRoom& room = _rooms[item->RoomNumber];
DrawLaraHolsters(item, &room, nullptr, renderView, RendererPass::ShadowMap);
DrawLaraJoints(item, &room, nullptr, renderView, RendererPass::ShadowMap);
DrawLaraHair(item, &room, nullptr, renderView, RendererPass::ShadowMap);
DrawLaraHolsters(item, &room, renderView, RendererPass::ShadowMap);
DrawLaraJoints(item, &room, renderView, RendererPass::ShadowMap);
DrawLaraHair(item, &room, renderView, RendererPass::ShadowMap);
}
}
}
void Renderer::DrawGunShells(RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawGunShells(RenderView& view, RendererPass rendererPass)
{
auto& room = _rooms[LaraItem->RoomNumber];
auto* item = &_items[LaraItem->Index];
@ -253,6 +253,11 @@ namespace TEN::Renderer
if (gunshell->counter <= 0)
continue;
if (_currentMirror != nullptr && gunshell->roomNumber != _currentMirror->RealRoom)
{
continue;
}
objectID = gunshell->objectNumber;
auto translation = Matrix::CreateTranslation(gunshell->pos.Position.ToVector3());
@ -268,16 +273,16 @@ namespace TEN::Renderer
worldMatrix = Matrix::Lerp(prevWorldMatrix, worldMatrix, GetInterpolationFactor());
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
worldMatrix = worldMatrix * mirror->ReflectionMatrix;
worldMatrix = worldMatrix * _currentMirror->ReflectionMatrix;
}
_stInstancedStaticMeshBuffer.StaticMeshes[gunShellCount].World = worldMatrix;
_stInstancedStaticMeshBuffer.StaticMeshes[gunShellCount].Ambient = room.AmbientLight;
_stInstancedStaticMeshBuffer.StaticMeshes[gunShellCount].Color = room.AmbientLight;
_stInstancedStaticMeshBuffer.StaticMeshes[gunShellCount].LightMode = (int)LightMode::Dynamic;
BindInstancedStaticLights(item->LightsToDraw, gunShellCount, mirror);
BindInstancedStaticLights(item->LightsToDraw, gunShellCount);
gunShellCount++;
}
@ -467,7 +472,7 @@ namespace TEN::Renderer
}*/
}
void Renderer::DrawRats(RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawRats(RenderView& view, RendererPass rendererPass)
{
if (!Objects[ID_RATS_EMITTER].loaded)
{
@ -480,7 +485,7 @@ namespace TEN::Renderer
{
auto* rat = &Rats[i];
if (mirror != nullptr && rat->RoomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && rat->RoomNumber != _currentMirror->RealRoom)
continue;
if (rat->On)
@ -523,7 +528,7 @@ namespace TEN::Renderer
{
auto* rat = &Rats[i];
if (mirror != nullptr && rat->RoomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && rat->RoomNumber != _currentMirror->RealRoom)
continue;
if (rat->On)
@ -565,9 +570,9 @@ namespace TEN::Renderer
RendererMesh* mesh = GetMesh(Objects[ID_RATS_EMITTER].meshIndex + (rand() % 8));
Matrix world = rat->Transform;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
world = world * mirror->ReflectionMatrix;
world = world * _currentMirror->ReflectionMatrix;
}
_stStatic.World = world;
_stStatic.Color = Vector4::One;
@ -575,7 +580,7 @@ namespace TEN::Renderer
if (rendererPass != RendererPass::GBuffer)
{
BindStaticLights(_rooms[rat->RoomNumber].LightsToDraw, mirror);
BindStaticLights(_rooms[rat->RoomNumber].LightsToDraw);
}
_cbStatic.UpdateData(_stStatic, _context.Get());
@ -696,7 +701,7 @@ namespace TEN::Renderer
_stStatic.AmbientLight = _rooms[fish.RoomNumber].AmbientLight;
if (rendererPass != RendererPass::GBuffer)
BindStaticLights(_rooms[fish.RoomNumber].LightsToDraw, nullptr);
BindStaticLights(_rooms[fish.RoomNumber].LightsToDraw);
_cbStatic.UpdateData(_stStatic, _context.Get());
@ -724,7 +729,7 @@ namespace TEN::Renderer
}
}
void Renderer::DrawBats(RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawBats(RenderView& view, RendererPass rendererPass)
{
if (!Objects[ID_BATS_EMITTER].loaded)
return;
@ -738,7 +743,7 @@ namespace TEN::Renderer
if (!bat.On)
continue;
if (mirror != nullptr && bat.RoomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && bat.RoomNumber != _currentMirror->RealRoom)
continue;
for (auto& bucket : mesh.Buckets)
@ -774,7 +779,7 @@ namespace TEN::Renderer
{
const auto& bat = Bats[i];
if (mirror != nullptr && bat.RoomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && bat.RoomNumber != _currentMirror->RealRoom)
continue;
if (bat.On)
@ -784,9 +789,9 @@ namespace TEN::Renderer
auto transformMatrix = Matrix::Lerp(bat.PrevTransform, bat.Transform, GetInterpolationFactor());
Matrix world = transformMatrix;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
world = world * mirror->ReflectionMatrix;
world = world * _currentMirror->ReflectionMatrix;
}
_stInstancedStaticMeshBuffer.StaticMeshes[batCount].World = world;
@ -795,7 +800,7 @@ namespace TEN::Renderer
_stInstancedStaticMeshBuffer.StaticMeshes[batCount].LightMode = (int)mesh.LightMode;
if (rendererPass != RendererPass::GBuffer)
BindInstancedStaticLights(room.LightsToDraw, batCount, mirror);
BindInstancedStaticLights(room.LightsToDraw, batCount);
batCount++;
}
@ -848,7 +853,7 @@ namespace TEN::Renderer
}
}
void Renderer::DrawScarabs(RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawScarabs(RenderView& view, RendererPass rendererPass)
{
if (!Objects[ID_LITTLE_BEETLE].loaded)
return;
@ -896,7 +901,7 @@ namespace TEN::Renderer
{
const auto& beetle = TEN::Entities::TR4::BeetleSwarm[i];
if (mirror != nullptr && beetle.RoomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && beetle.RoomNumber != _currentMirror->RealRoom)
continue;
if (beetle.On)
@ -906,9 +911,9 @@ namespace TEN::Renderer
auto transformMatrix = Matrix::Lerp(beetle.PrevTransform, beetle.Transform, GetInterpolationFactor());
Matrix world = transformMatrix;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
world = world * mirror->ReflectionMatrix;
world = world * _currentMirror->ReflectionMatrix;
}
_stInstancedStaticMeshBuffer.StaticMeshes[beetleCount].World = world;
@ -922,7 +927,7 @@ namespace TEN::Renderer
for (int i = 0; i < std::min((int)room.LightsToDraw.size(), MAX_LIGHTS_PER_ITEM); i++)
lights.push_back(room.LightsToDraw[i]);
BindInstancedStaticLights(lights, beetleCount, mirror);
BindInstancedStaticLights(lights, beetleCount);
}
beetleCount++;
@ -976,7 +981,7 @@ namespace TEN::Renderer
}
}
void Renderer::DrawLocusts(RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawLocusts(RenderView& view, RendererPass rendererPass)
{
if (!Objects[ID_LOCUSTS].loaded)
return;
@ -991,7 +996,7 @@ namespace TEN::Renderer
if (!locust.on)
continue;
if (mirror != nullptr && locust.roomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && locust.roomNumber != _currentMirror->RealRoom)
continue;
auto& mesh = *GetMesh(Objects[ID_LOCUSTS].meshIndex + (-locust.counter & 3));
@ -1030,7 +1035,7 @@ namespace TEN::Renderer
if (!locust.on)
continue;
if (mirror != nullptr && locust.roomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && locust.roomNumber != _currentMirror->RealRoom)
continue;
activeLocustsExist = true;
@ -1069,9 +1074,9 @@ namespace TEN::Renderer
auto& mesh = *GetMesh(Objects[ID_LOCUSTS].meshIndex + (-locust.counter & 3));
Matrix world = Matrix::Lerp(locust.PrevTransform, locust.Transform, GetInterpolationFactor());
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
world = world * mirror->ReflectionMatrix;
world = world * _currentMirror->ReflectionMatrix;
}
_stStatic.World = world;
@ -1885,15 +1890,15 @@ namespace TEN::Renderer
_context->OMSetRenderTargets(2, &pRenderViewPtrs[0], _renderTarget.DepthStencilView.Get());
DrawRooms(view, RendererPass::GBuffer);
DrawItems(nullptr, view, RendererPass::GBuffer);
DrawStatics(nullptr, view, RendererPass::GBuffer);
DrawItems(view, RendererPass::GBuffer);
DrawStatics(view, RendererPass::GBuffer);
DrawSpiders(view, RendererPass::GBuffer);
DrawScarabs(nullptr, view, RendererPass::GBuffer);
DrawGunShells(nullptr, view, RendererPass::GBuffer);
DrawBats(nullptr, view, RendererPass::GBuffer);
DrawEffects(nullptr, view, RendererPass::GBuffer);
DrawRats(nullptr, view, RendererPass::GBuffer);
DrawLocusts(nullptr, view, RendererPass::GBuffer);
DrawScarabs(view, RendererPass::GBuffer);
DrawGunShells(view, RendererPass::GBuffer);
DrawBats(view, RendererPass::GBuffer);
DrawEffects(view, RendererPass::GBuffer);
DrawRats(view, RendererPass::GBuffer);
DrawLocusts(view, RendererPass::GBuffer);
// Calculate ambient occlusion.
if (g_Configuration.EnableAmbientOcclusion)
@ -1918,17 +1923,17 @@ namespace TEN::Renderer
// Draw opaque, alpha test, and fast alpha blend faces.
DrawRooms(view, RendererPass::Opaque);
DrawItems(nullptr, view, RendererPass::Opaque);
DrawStatics(nullptr, view, RendererPass::Opaque);
DrawItems(view, RendererPass::Opaque);
DrawStatics(view, RendererPass::Opaque);
DrawSpiders(view, RendererPass::Opaque);
DrawScarabs(nullptr, view, RendererPass::Opaque);
DrawGunShells(nullptr, view, RendererPass::Opaque);
DrawBats(nullptr, view, RendererPass::Opaque);
DrawEffects(nullptr, view, RendererPass::Opaque);
DrawRats(nullptr, view, RendererPass::Opaque);
DrawLocusts(nullptr, view, RendererPass::Opaque);
DrawDebris(nullptr, view, RendererPass::Opaque);
DrawSprites(nullptr, view, RendererPass::Opaque);
DrawScarabs(view, RendererPass::Opaque);
DrawGunShells(view, RendererPass::Opaque);
DrawBats(view, RendererPass::Opaque);
DrawEffects(view, RendererPass::Opaque);
DrawRats(view, RendererPass::Opaque);
DrawLocusts(view, RendererPass::Opaque);
DrawDebris(view, RendererPass::Opaque);
DrawSprites(view, RendererPass::Opaque);
DrawFishSwarm(view, RendererPass::Opaque);
// Draw mirrored opaque geometry only if Lara is inside a mirror room
@ -1938,16 +1943,20 @@ namespace TEN::Renderer
for (auto& mirror : view.Mirrors)
{
DrawItems(&mirror, view, RendererPass::Opaque);
DrawStatics(&mirror, view, RendererPass::Opaque);
DrawScarabs(&mirror, view, RendererPass::Opaque);
DrawGunShells(&mirror, view, RendererPass::Opaque);
DrawBats(&mirror, view, RendererPass::Opaque);
DrawEffects(&mirror, view, RendererPass::Opaque);
DrawRats(&mirror, view, RendererPass::Opaque);
DrawLocusts(&mirror, view, RendererPass::Opaque);
DrawDebris(&mirror, view, RendererPass::Opaque);
DrawSprites(&mirror, view, RendererPass::Opaque);
_currentMirror = &mirror;
DrawItems(view, RendererPass::Opaque);
DrawStatics(view, RendererPass::Opaque);
DrawScarabs(view, RendererPass::Opaque);
DrawGunShells(view, RendererPass::Opaque);
DrawBats(view, RendererPass::Opaque);
DrawEffects(view, RendererPass::Opaque);
DrawRats(view, RendererPass::Opaque);
DrawLocusts(view, RendererPass::Opaque);
DrawDebris(view, RendererPass::Opaque);
DrawSprites(view, RendererPass::Opaque);
_currentMirror = nullptr;
}
SetCullMode(CullMode::CounterClockwise);
@ -1955,16 +1964,16 @@ namespace TEN::Renderer
// Draw additive faces.
DrawRooms(view, RendererPass::Additive);
DrawItems(nullptr, view, RendererPass::Additive);
DrawStatics(nullptr, view, RendererPass::Additive);
DrawItems(view, RendererPass::Additive);
DrawStatics(view, RendererPass::Additive);
DrawSpiders(view, RendererPass::Additive);
DrawScarabs(nullptr, view, RendererPass::Additive);
DrawBats(nullptr, view, RendererPass::Additive);
DrawEffects(nullptr, view, RendererPass::Additive);
DrawRats(nullptr, view, RendererPass::Additive);
DrawLocusts(nullptr, view, RendererPass::Additive);
DrawDebris(nullptr, view, RendererPass::Additive);
DrawSprites(nullptr, view, RendererPass::Additive);
DrawScarabs(view, RendererPass::Additive);
DrawBats(view, RendererPass::Additive);
DrawEffects(view, RendererPass::Additive);
DrawRats(view, RendererPass::Additive);
DrawLocusts(view, RendererPass::Additive);
DrawDebris(view, RendererPass::Additive);
DrawSprites(view, RendererPass::Additive);
DrawFishSwarm(view, RendererPass::Additive);
// Draw mirrored additive geometry only if Lara is inside a mirror room
@ -1974,15 +1983,19 @@ namespace TEN::Renderer
for (auto& mirror : view.Mirrors)
{
DrawItems(&mirror, view, RendererPass::Additive);
DrawStatics(&mirror, view, RendererPass::Additive);
DrawScarabs(&mirror, view, RendererPass::Additive);
DrawBats(&mirror, view, RendererPass::Additive);
DrawEffects(&mirror, view, RendererPass::Additive);
DrawRats(&mirror, view, RendererPass::Additive);
DrawLocusts(&mirror, view, RendererPass::Additive);
DrawDebris(&mirror, view, RendererPass::Additive);
DrawSprites(&mirror, view, RendererPass::Additive);
_currentMirror = &mirror;
DrawItems(view, RendererPass::Additive);
DrawStatics(view, RendererPass::Additive);
DrawScarabs(view, RendererPass::Additive);
DrawBats(view, RendererPass::Additive);
DrawEffects(view, RendererPass::Additive);
DrawRats(view, RendererPass::Additive);
DrawLocusts(view, RendererPass::Additive);
DrawDebris(view, RendererPass::Additive);
DrawSprites(view, RendererPass::Additive);
_currentMirror = nullptr;
}
SetCullMode(CullMode::CounterClockwise);
@ -1991,16 +2004,16 @@ namespace TEN::Renderer
// Collect all non-commutative transparent faces.
// NOTE: Sorted sprites already collected at beginning of frame.
DrawRooms(view, RendererPass::CollectTransparentFaces);
DrawItems(nullptr, view, RendererPass::CollectTransparentFaces);
DrawStatics(nullptr, view, RendererPass::CollectTransparentFaces);
DrawBats(nullptr, view, RendererPass::CollectTransparentFaces);
DrawEffects(nullptr, view, RendererPass::CollectTransparentFaces);
DrawRats(nullptr, view, RendererPass::CollectTransparentFaces);
DrawLocusts(nullptr, view, RendererPass::CollectTransparentFaces);
DrawItems(view, RendererPass::CollectTransparentFaces);
DrawStatics(view, RendererPass::CollectTransparentFaces);
DrawBats(view, RendererPass::CollectTransparentFaces);
DrawEffects(view, RendererPass::CollectTransparentFaces);
DrawRats(view, RendererPass::CollectTransparentFaces);
DrawLocusts(view, RendererPass::CollectTransparentFaces);
DrawFishSwarm(view, RendererPass::CollectTransparentFaces);
// Draw sorted faces.
DrawSortedFaces(nullptr, view);
DrawSortedFaces(view);
// Draw mirrored sorted faces only if Lara is inside a mirror room
if (view.Mirrors.size() > 0)
@ -2009,15 +2022,19 @@ namespace TEN::Renderer
for (auto& mirror : view.Mirrors)
{
DrawSortedFaces(&mirror, view);
_currentMirror = &mirror;
DrawSortedFaces(view);
_currentMirror = nullptr;
}
SetCullMode(CullMode::CounterClockwise);
}
// HACK: Gunflashes drawn after everything because they are very near the camera.
DrawGunFlashes(nullptr, view);
DrawBaddyGunflashes(nullptr, view);
DrawGunFlashes(view);
DrawBaddyGunflashes( view);
// Draw mirrored gunflashes only if Lara is inside a mirror room
if (view.Mirrors.size() > 0)
@ -2026,8 +2043,12 @@ namespace TEN::Renderer
for (auto& mirror : view.Mirrors)
{
DrawGunFlashes(&mirror, view);
DrawBaddyGunflashes(&mirror, view);
_currentMirror = &mirror;
DrawGunFlashes(view);
DrawBaddyGunflashes(view);
_currentMirror = nullptr;
}
SetCullMode(CullMode::CounterClockwise);
@ -2355,7 +2376,7 @@ namespace TEN::Renderer
RenderScene(&_dumpScreenRenderTarget, _gameCamera, renderMode);
}
void Renderer::DrawItems(RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawItems(RenderView& view, RendererPass rendererPass)
{
unsigned int stride = sizeof(Vertex);
unsigned int offset = 0;
@ -2384,7 +2405,7 @@ namespace TEN::Renderer
switch (itemToDraw->ObjectID)
{
case ID_LARA:
DrawLara(mirror, view, rendererPass);
DrawLara(view, rendererPass);
break;
case ID_WATERFALL1:
@ -2395,11 +2416,11 @@ namespace TEN::Renderer
case ID_WATERFALL6:
case ID_WATERFALLSS1:
case ID_WATERFALLSS2:
DrawWaterfalls(itemToDraw, mirror, view, 10, rendererPass);
DrawWaterfalls(itemToDraw, view, 10, rendererPass);
continue;
default:
DrawAnimatingItem(itemToDraw, mirror, view, rendererPass);
DrawAnimatingItem(itemToDraw, view, rendererPass);
break;
}
}
@ -2418,12 +2439,10 @@ namespace TEN::Renderer
}
}
void Renderer::DrawWaterfalls(RendererItem* item, RendererMirror* mirror, RenderView& view, int fps, RendererPass rendererPass)
void Renderer::DrawWaterfalls(RendererItem* item, RenderView& view, int fps, RendererPass rendererPass)
{
if (mirror != nullptr && item->RoomNumber != mirror->RealRoom)
{
if (_currentMirror != nullptr && item->RoomNumber != _currentMirror->RealRoom)
return;
}
// Extremely hacky function to get first rendered face of a waterfall object mesh, calculate
// its texture height and scroll all the textures according to that height.
@ -2459,16 +2478,16 @@ namespace TEN::Renderer
_cbAnimated.UpdateData(_stAnimated, _context.Get());
DrawAnimatingItem(item, mirror, view, rendererPass);
DrawAnimatingItem(item, view, rendererPass);
// Reset animated buffer after rendering just in case
_stAnimated.Fps = _stAnimated.NumFrames = _stAnimated.Type = 0;
_cbAnimated.UpdateData(_stAnimated, _context.Get());
}
void Renderer::DrawAnimatingItem(RendererItem* item, RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawAnimatingItem(RendererItem* item, RenderView& view, RendererPass rendererPass)
{
if (mirror != nullptr && item->RoomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && item->RoomNumber != _currentMirror->RealRoom)
return;
ItemInfo* nativeItem = &g_Level.Items[item->ItemNumber];
@ -2477,9 +2496,9 @@ namespace TEN::Renderer
// Bind item main properties
_stItem.World = item->InterpolatedWorld;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
_stItem.World = _stItem.World * mirror->ReflectionMatrix;
_stItem.World = _stItem.World * _currentMirror->ReflectionMatrix;
}
_stItem.Color = item->Color;
_stItem.AmbientLight = item->AmbientLight;
@ -2488,7 +2507,7 @@ namespace TEN::Renderer
for (int k = 0; k < moveableObj.ObjectMeshes.size(); k++)
_stItem.BoneLightModes[k] = (int)moveableObj.ObjectMeshes[k]->LightMode;
BindMoveableLights(item->LightsToDraw, item->RoomNumber, item->PrevRoomNumber, item->LightFade, mirror);
BindMoveableLights(item->LightsToDraw, item->RoomNumber, item->PrevRoomNumber, item->LightFade);
_cbItem.UpdateData(_stItem, _context.Get());
for (int k = 0; k < moveableObj.ObjectMeshes.size(); k++)
@ -2500,7 +2519,7 @@ namespace TEN::Renderer
}
}
void Renderer::DrawStatics(RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawStatics(RenderView& view, RendererPass rendererPass)
{
if (_staticTextures.size() == 0 || view.SortedStaticsToDraw.size() == 0)
{
@ -2634,15 +2653,15 @@ namespace TEN::Renderer
RendererStatic* current = statics[s];
RendererRoom* room = &_rooms[current->RoomNumber];
if (mirror != nullptr && current->RoomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && current->RoomNumber != _currentMirror->RealRoom)
{
continue;
}
Matrix world = current->World;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
world = world * mirror->ReflectionMatrix;
world = world * _currentMirror->ReflectionMatrix;
}
_stInstancedStaticMeshBuffer.StaticMeshes[k].World = world;
@ -2652,7 +2671,7 @@ namespace TEN::Renderer
if (rendererPass != RendererPass::GBuffer)
{
BindInstancedStaticLights(current->LightsToDraw, k, mirror);
BindInstancedStaticLights(current->LightsToDraw, k);
}
k++;
@ -2698,9 +2717,6 @@ namespace TEN::Renderer
}
else
{
if (mirror != nullptr)
return;
// Collect sorted blend modes faces ordered by room, if transparent pass
for (auto it = view.SortedStaticsToDraw.begin(); it != view.SortedStaticsToDraw.end(); it++)
@ -2716,11 +2732,6 @@ namespace TEN::Renderer
for (int i = 0; i < statics.size(); i++)
{
if (mirror != nullptr && statics[i]->RoomNumber != mirror->RealRoom)
{
continue;
}
for (int j = 0; j < refMesh->Buckets.size(); j++)
{
auto& bucket = refMesh->Buckets[j];
@ -2829,7 +2840,7 @@ namespace TEN::Renderer
// Set shadow map data and bind shadow map texture.
if (_shadowLight != nullptr)
{
memcpy(&_stShadowMap.Light, _shadowLight, sizeof(ShaderLight));
BindLight(*_shadowLight, &_stShadowMap.Light, 0);
_stShadowMap.ShadowMapSize = g_Configuration.ShadowMapSize;
_stShadowMap.CastShadows = true;
@ -2857,7 +2868,7 @@ namespace TEN::Renderer
{
_stRoom.Caustics = int(g_Configuration.EnableCaustics && (nativeRoom.flags & ENV_FLAG_WATER));
_stRoom.AmbientColor = room.AmbientLight;
BindRoomLights(view.LightsToDraw, nullptr);
BindRoomLights(view.LightsToDraw);
}
_stRoom.Water = (nativeRoom.flags & ENV_FLAG_WATER) != 0 ? 1 : 0;
@ -3407,9 +3418,9 @@ namespace TEN::Renderer
return true;
}
void Renderer::DrawSortedFaces(RendererMirror* mirror, RenderView& view)
void Renderer::DrawSortedFaces(RenderView& view)
{
if (mirror == nullptr)
if (_currentMirror == nullptr)
{
std::sort(
view.TransparentObjectsToDraw.begin(),
@ -3429,7 +3440,7 @@ namespace TEN::Renderer
_sortedPolygonsVertices.clear();
_sortedPolygonsIndices.clear();
if (mirror != nullptr && object->ObjectType == RendererObjectType::Room)
if (_currentMirror != nullptr && object->ObjectType == RendererObjectType::Room)
{
continue;
}
@ -3584,7 +3595,7 @@ namespace TEN::Renderer
uv2 = spr->Sprite->UV[2];
uv3 = spr->Sprite->UV[3];
Matrix world = GetWorldMatrixForSprite(currentObject->Sprite, mirror, view);
Matrix world = GetWorldMatrixForSprite(currentObject->Sprite, _currentMirror, view);
Vertex v0;
v0.Position = Vector3::Transform(p0t, world);
@ -3645,7 +3656,7 @@ namespace TEN::Renderer
_stRoom.Caustics = (int)(g_Configuration.EnableCaustics && (nativeRoom->flags & ENV_FLAG_WATER));
_stRoom.AmbientColor = objectInfo->Room->AmbientLight;
BindRoomLights(view.LightsToDraw, nullptr);
BindRoomLights(view.LightsToDraw);
_stRoom.Water = (nativeRoom->flags & ENV_FLAG_WATER) != 0 ? 1 : 0;
_cbRoom.UpdateData(_stRoom, _context.Get());
@ -3738,7 +3749,7 @@ namespace TEN::Renderer
for (int k = 0; k < moveableObj.ObjectMeshes.size(); k++)
_stItem.BoneLightModes[k] = (int)moveableObj.ObjectMeshes[k]->LightMode;
BindMoveableLights(objectInfo->Item->LightsToDraw, objectInfo->Item->RoomNumber, objectInfo->Item->PrevRoomNumber, objectInfo->Item->LightFade, nullptr);
BindMoveableLights(objectInfo->Item->LightsToDraw, objectInfo->Item->RoomNumber, objectInfo->Item->PrevRoomNumber, objectInfo->Item->LightFade);
_cbItem.UpdateData(_stItem, _context.Get());
BindTexture(
@ -3774,7 +3785,7 @@ namespace TEN::Renderer
_stStatic.Color = objectInfo->Static->Color;
_stStatic.AmbientLight = objectInfo->Room->AmbientLight;
_stStatic.LightMode = (int)GetStaticRendererObject(objectInfo->Static->ObjectNumber).ObjectMeshes[0]->LightMode;
BindStaticLights(objectInfo->Static->LightsToDraw, nullptr);
BindStaticLights(objectInfo->Static->LightsToDraw);
_cbStatic.UpdateData(_stStatic, _context.Get());
SetDepthState(DepthState::Read);
@ -3813,7 +3824,7 @@ namespace TEN::Renderer
_stStatic.Color = Vector4::One;
_stStatic.AmbientLight = objectInfo->Room->AmbientLight;
_stStatic.LightMode = (int)objectInfo->Mesh->LightMode;
BindStaticLights(objectInfo->Room->LightsToDraw, nullptr);
BindStaticLights(objectInfo->Room->LightsToDraw);
_cbStatic.UpdateData(_stStatic, _context.Get());
SetDepthState(DepthState::Read);

52
TombEngine/Renderer/RendererDrawEffect.cpp
View file

@ -1009,7 +1009,7 @@ namespace TEN::Renderer
}
}
bool Renderer::DrawGunFlashes(RendererMirror* mirror, RenderView& view)
bool Renderer::DrawGunFlashes(RenderView& view)
{
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
@ -1033,7 +1033,7 @@ namespace TEN::Renderer
_stStatic.Color = Vector4::One;
_stStatic.AmbientLight = room.AmbientLight;
_stStatic.LightMode = (int)LightMode::Static;
BindStaticLights(itemPtr->LightsToDraw, mirror);
BindStaticLights(itemPtr->LightsToDraw);
short length = 0;
short zOffset = 0;
@ -1106,9 +1106,9 @@ namespace TEN::Renderer
worldMatrix = tMatrix * worldMatrix;
worldMatrix = rotMatrix * worldMatrix;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
worldMatrix = worldMatrix * mirror->ReflectionMatrix;
worldMatrix = worldMatrix * _currentMirror->ReflectionMatrix;
}
_stStatic.World = worldMatrix;
@ -1125,9 +1125,9 @@ namespace TEN::Renderer
worldMatrix = tMatrix * worldMatrix;
worldMatrix = rotMatrix * worldMatrix;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
worldMatrix = worldMatrix * mirror->ReflectionMatrix;
worldMatrix = worldMatrix * _currentMirror->ReflectionMatrix;
}
_stStatic.World = worldMatrix;
@ -1144,7 +1144,7 @@ namespace TEN::Renderer
return true;
}
void Renderer::DrawBaddyGunflashes(RendererMirror* mirror, RenderView& view)
void Renderer::DrawBaddyGunflashes(RenderView& view)
{
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
@ -1161,7 +1161,7 @@ namespace TEN::Renderer
{
auto& nativeItem = g_Level.Items[rItemPtr->ItemNumber];
if (mirror != nullptr && nativeItem.RoomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && nativeItem.RoomNumber != _currentMirror->RealRoom)
{
continue;
}
@ -1176,7 +1176,7 @@ namespace TEN::Renderer
_stStatic.AmbientLight = rRoom.AmbientLight;
_stStatic.LightMode = (int)LightMode::Static;
BindStaticLights(rItemPtr->LightsToDraw, mirror); // FIXME: Is it really needed for gunflashes? -- Lwmte, 15.07.22
BindStaticLights(rItemPtr->LightsToDraw); // FIXME: Is it really needed for gunflashes? -- Lwmte, 15.07.22
SetBlendMode(BlendMode::Additive);
SetAlphaTest(AlphaTestMode::GreatherThan, ALPHA_TEST_THRESHOLD);
@ -1211,9 +1211,9 @@ namespace TEN::Renderer
if (creature.MuzzleFlash[0].ApplyZRotation)
worldMatrix = rotMatrixZ * worldMatrix;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
worldMatrix = worldMatrix * mirror->ReflectionMatrix;
worldMatrix = worldMatrix * _currentMirror->ReflectionMatrix;
}
_stStatic.World = worldMatrix;
@ -1256,9 +1256,9 @@ namespace TEN::Renderer
if (creature.MuzzleFlash[1].ApplyZRotation)
worldMatrix = rotMatrixZ * worldMatrix;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
worldMatrix = worldMatrix * mirror->ReflectionMatrix;
worldMatrix = worldMatrix * _currentMirror->ReflectionMatrix;
}
_stStatic.World = worldMatrix;
@ -1341,21 +1341,21 @@ namespace TEN::Renderer
return spriteMatrix;
}
void Renderer::DrawEffect(RendererMirror* mirror, RenderView& view, RendererEffect* effect, RendererPass rendererPass)
void Renderer::DrawEffect(RenderView& view, RendererEffect* effect, RendererPass rendererPass)
{
const auto& room = _rooms[effect->RoomNumber];
Matrix world = effect->InterpolatedWorld;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
world = world * mirror->ReflectionMatrix;
world = world * _currentMirror->ReflectionMatrix;
}
_stStatic.World = world;
_stStatic.Color = effect->Color;
_stStatic.AmbientLight = effect->AmbientLight;
_stStatic.LightMode = (int)LightMode::Dynamic;
BindStaticLights(effect->LightsToDraw, mirror);
BindStaticLights(effect->LightsToDraw);
_cbStatic.UpdateData(_stStatic, _context.Get());
auto& mesh = *effect->Mesh;
@ -1381,7 +1381,7 @@ namespace TEN::Renderer
}
}
void Renderer::DrawEffects(RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawEffects(RenderView& view, RendererPass rendererPass)
{
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
@ -1396,26 +1396,26 @@ namespace TEN::Renderer
{
for (auto* effectPtr : roomPtr->EffectsToDraw)
{
if (mirror != nullptr && effectPtr->RoomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && effectPtr->RoomNumber != _currentMirror->RealRoom)
continue;
const auto& room = _rooms[effectPtr->RoomNumber];
const auto& object = Objects[effectPtr->ObjectID];
if (object.drawRoutine && object.loaded)
DrawEffect(mirror, view, effectPtr, rendererPass);
DrawEffect(view, effectPtr, rendererPass);
}
}
}
void Renderer::DrawDebris(RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawDebris(RenderView& view, RendererPass rendererPass)
{
bool activeDebrisExist = false;
for (auto& deb : DebrisFragments)
{
if (deb.active)
{
if (mirror != nullptr && deb.roomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && deb.roomNumber != _currentMirror->RealRoom)
continue;
activeDebrisExist = true;
@ -1434,7 +1434,7 @@ namespace TEN::Renderer
{
if (deb.active)
{
if (mirror != nullptr && deb.roomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && deb.roomNumber != _currentMirror->RealRoom)
continue;
if (!SetupBlendModeAndAlphaTest(deb.mesh.blendMode, rendererPass, 0))
@ -1450,9 +1450,9 @@ namespace TEN::Renderer
}
Matrix world = Matrix::Lerp(deb.PrevTransform, deb.Transform, GetInterpolationFactor());
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
world = world * mirror->ReflectionMatrix;
world = world * _currentMirror->ReflectionMatrix;
}
_stStatic.World = world;
@ -1495,7 +1495,7 @@ namespace TEN::Renderer
SetBlendMode(BlendMode::Opaque, true);
SetDepthState(DepthState::Write, true);
SetCullMode(mirror != nullptr ? CullMode::Clockwise : CullMode::CounterClockwise, true);
SetCullMode(_currentMirror != nullptr ? CullMode::Clockwise : CullMode::CounterClockwise, true);
}
}

2
TombEngine/Renderer/RendererFrame.cpp
View file

@ -692,7 +692,7 @@ namespace TEN::Renderer
std::vector<RendererLight*> lightsToDraw;
CollectLights(Vector3(Camera.pos.x, Camera.pos.y, Camera.pos.z), CAMERA_LIGHT_COLLECTION_RADIUS, Camera.pos.RoomNumber, NO_VALUE, true, false, nullptr, &lightsToDraw);
if (!lightsToDraw.empty() && lightsToDraw.front()->CastShadows)
if (g_Configuration.ShadowType != ShadowMode::None && !lightsToDraw.empty() && lightsToDraw.front()->CastShadows)
{
_shadowLight = lightsToDraw.front();
}

30
TombEngine/Renderer/RendererLara.cpp
View file

@ -278,9 +278,9 @@ void Renderer::UpdateLaraAnimations(bool force)
rItem.DoneAnimations = true;
}
void TEN::Renderer::Renderer::DrawLara(RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void TEN::Renderer::Renderer::DrawLara(RenderView& view, RendererPass rendererPass)
{
if (mirror != nullptr && LaraItem->RoomNumber != mirror->RealRoom)
if (_currentMirror != nullptr && LaraItem->RoomNumber != _currentMirror->RealRoom)
return;
// Don't draw player if using optics.
@ -309,9 +309,9 @@ void TEN::Renderer::Renderer::DrawLara(RendererMirror* mirror, RenderView& view,
RendererRoom* room = &_rooms[LaraItem->RoomNumber];
_stItem.World = item->InterpolatedWorld;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
_stItem.World = _stItem.World * mirror->ReflectionMatrix;
_stItem.World = _stItem.World * _currentMirror->ReflectionMatrix;
}
_stItem.Color = item->Color;
@ -321,7 +321,7 @@ void TEN::Renderer::Renderer::DrawLara(RendererMirror* mirror, RenderView& view,
{
_stItem.BoneLightModes[k] = (int)GetMesh(nativeItem->Model.MeshIndex[k])->LightMode;
}
BindMoveableLights(item->LightsToDraw, item->RoomNumber, item->PrevRoomNumber, item->LightFade, mirror);
BindMoveableLights(item->LightsToDraw, item->RoomNumber, item->PrevRoomNumber, item->LightFade);
_cbItem.UpdateData(_stItem, _context.Get());
for (int k = 0; k < laraSkin.ObjectMeshes.size(); k++)
@ -332,12 +332,12 @@ void TEN::Renderer::Renderer::DrawLara(RendererMirror* mirror, RenderView& view,
DrawMoveableMesh(item, GetMesh(nativeItem->Model.MeshIndex[k]), room, k, view, rendererPass);
}
DrawLaraHolsters(item, room, mirror, view, rendererPass);
DrawLaraJoints(item, room, mirror, view, rendererPass);
DrawLaraHair(item, room, mirror, view, rendererPass);
DrawLaraHolsters(item, room, view, rendererPass);
DrawLaraJoints(item, room, view, rendererPass);
DrawLaraHair(item, room, view, rendererPass);
}
void Renderer::DrawLaraHair(RendererItem* itemToDraw, RendererRoom* room, RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawLaraHair(RendererItem* itemToDraw, RendererRoom* room, RenderView& view, RendererPass rendererPass)
{
bool forceValue = g_GameFlow->CurrentFreezeMode == FreezeMode::Player;
@ -355,9 +355,9 @@ void Renderer::DrawLaraHair(RendererItem* itemToDraw, RendererRoom* room, Render
_stItem.World = Matrix::Identity;
_stItem.BonesMatrices[0] = itemToDraw->InterpolatedAnimTransforms[LM_HEAD] * itemToDraw->InterpolatedWorld;
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
_stItem.BonesMatrices[0] = _stItem.BonesMatrices[0] * mirror->ReflectionMatrix;
_stItem.BonesMatrices[0] = _stItem.BonesMatrices[0] * _currentMirror->ReflectionMatrix;
}
for (int i = 0; i < unit.Segments.size(); i++)
@ -369,9 +369,9 @@ void Renderer::DrawLaraHair(RendererItem* itemToDraw, RendererRoom* room, Render
Matrix::CreateTranslation(
Vector3::Lerp(segment.PrevPosition, segment.Position, GetInterpolationFactor(forceValue)));
if (mirror != nullptr)
if (_currentMirror != nullptr)
{
worldMatrix = worldMatrix * mirror->ReflectionMatrix;
worldMatrix = worldMatrix * _currentMirror->ReflectionMatrix;
}
_stItem.BonesMatrices[i + 1] = worldMatrix;
@ -388,7 +388,7 @@ void Renderer::DrawLaraHair(RendererItem* itemToDraw, RendererRoom* room, Render
}
}
void Renderer::DrawLaraJoints(RendererItem* itemToDraw, RendererRoom* room, RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawLaraJoints(RendererItem* itemToDraw, RendererRoom* room, RenderView& view, RendererPass rendererPass)
{
if (!_moveableObjects[ID_LARA_SKIN_JOINTS].has_value())
return;
@ -402,7 +402,7 @@ void Renderer::DrawLaraJoints(RendererItem* itemToDraw, RendererRoom* room, Rend
}
}
void Renderer::DrawLaraHolsters(RendererItem* itemToDraw, RendererRoom* room, RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawLaraHolsters(RendererItem* itemToDraw, RendererRoom* room, RenderView& view, RendererPass rendererPass)
{
HolsterSlot leftHolsterID = Lara.Control.Weapon.HolsterInfo.LeftHolster;
HolsterSlot rightHolsterID = Lara.Control.Weapon.HolsterInfo.RightHolster;

4
TombEngine/Renderer/RendererSprites.cpp
View file

@ -256,7 +256,7 @@ namespace TEN::Renderer
_spriteBuckets.push_back(currentSpriteBucket);
}
void Renderer::DrawSprites(RendererMirror* mirror, RenderView& view, RendererPass rendererPass)
void Renderer::DrawSprites(RenderView& view, RendererPass rendererPass)
{
if (view.SpritesToDraw.empty())
return;
@ -296,7 +296,7 @@ namespace TEN::Renderer
{
auto& rDrawSprite = spriteBucket.SpritesToDraw[i];
_stInstancedSpriteBuffer.Sprites[i].World = GetWorldMatrixForSprite(&rDrawSprite, mirror, view);
_stInstancedSpriteBuffer.Sprites[i].World = GetWorldMatrixForSprite(&rDrawSprite, _currentMirror, view);
_stInstancedSpriteBuffer.Sprites[i].Color = rDrawSprite.color;
_stInstancedSpriteBuffer.Sprites[i].IsBillboard = 1;
_stInstancedSpriteBuffer.Sprites[i].IsSoftParticle = rDrawSprite.SoftParticle ? 1 : 0;

2
TombEngine/Scripting/Include/ScriptInterfaceGame.h
View file

@ -69,7 +69,7 @@ public:
virtual void ExecuteFunction(const std::string& luaFuncName, short idOne, short idTwo = 0) = 0;
virtual void GetVariables(std::vector<SavedVar>& vars) = 0;
virtual void SetVariables(const std::vector<SavedVar>& vars) = 0;
virtual void SetVariables(const std::vector<SavedVar>& vars, bool onlyLevelVars) = 0;
virtual void GetCallbackStrings(
std::vector<std::string>& preStart,

9
TombEngine/Scripting/Internal/TEN/Logic/LogicHandler.cpp
View file

@ -485,9 +485,11 @@ void LogicHandler::FreeLevelScripts()
}
// Used when loading.
void LogicHandler::SetVariables(const std::vector<SavedVar>& vars)
void LogicHandler::SetVariables(const std::vector<SavedVar>& vars, bool onlyLevelVars)
{
ResetGameTables();
if (!onlyLevelVars)
ResetGameTables();
ResetLevelTables();
std::unordered_map<unsigned int, sol::table> solTables;
@ -565,6 +567,9 @@ void LogicHandler::SetVariables(const std::vector<SavedVar>& vars)
for (auto& [first, second] : levelVars)
(*m_handler.GetState())[ScriptReserved_LevelVars][first] = second;
if (onlyLevelVars)
return;
sol::table gameVars = rootTable[ScriptReserved_GameVars];
for (auto& [first, second] : gameVars)
(*m_handler.GetState())[ScriptReserved_GameVars][first] = second;

2
TombEngine/Scripting/Internal/TEN/Logic/LogicHandler.h
View file

@ -145,7 +145,7 @@ public:
void ExecuteFunction(const std::string& name, short idOne, short idTwo) override;
void GetVariables(std::vector<SavedVar>& vars) override;
void SetVariables(const std::vector<SavedVar>& vars) override;
void SetVariables(const std::vector<SavedVar>& vars, bool onlyLevelVars) override;
void ResetVariables();
void SetCallbackStrings(const std::vector<std::string>& preStart,

2
TombEngine/Shaders/Blending.hlsli
View file

@ -7,7 +7,7 @@
#define ALPHATEST_GREATER_THAN 1
#define ALPHATEST_LESS_THAN 2
#define BLENDMODE_OPAQUE 0,
#define BLENDMODE_OPAQUE 0
#define BLENDMODE_ALPHATEST 1
#define BLENDMODE_ADDITIVE 2
#define BLENDMODE_NOZTEST 4

3
TombEngine/Shaders/InstancedStatics.fx
View file

@ -4,6 +4,7 @@
#include "./VertexEffects.hlsli"
#include "./VertexInput.hlsli"
#include "./Blending.hlsli"
#include "./Shadows.hlsli"
#define INSTANCED_STATIC_MESH_BUCKET_SIZE 100
@ -124,6 +125,8 @@ PixelShaderOutput PS(PixelShaderInput input)
input.FogBulbs.w) :
StaticLight(input.Color.xyz, tex.xyz, input.FogBulbs.w);
color = DoShadow(input.WorldPosition, normal, color, -0.5f);
output.Color = float4(color * occlusion, tex.w);
output.Color = DoFogBulbsForPixel(output.Color, float4(input.FogBulbs.xyz, 1.0f));
output.Color = DoDistanceFogForPixel(output.Color, FogColor, input.DistanceFog);

4
TombEngine/Shaders/Items.fx
View file

@ -5,7 +5,7 @@
#include "./VertexInput.hlsli"
#include "./Blending.hlsli"
#include "./AnimatedTextures.hlsli"
//#include "./Shadows.hlsli"
#include "./Shadows.hlsli"
#define MAX_BONES 32
@ -155,6 +155,8 @@ PixelShaderOutput PS(PixelShaderInput input)
input.FogBulbs.w) :
StaticLight(input.Color.xyz, tex.xyz, input.FogBulbs.w);
color = DoShadow(input.WorldPosition, normal, color, -0.5f);
output.Color = saturate(float4(color * occlusion, tex.w));
output.Color = DoFogBulbsForPixel(output.Color, float4(input.FogBulbs.xyz, 1.0f));
output.Color = DoDistanceFogForPixel(output.Color, FogColor, input.DistanceFog);

15
TombEngine/Shaders/Math.hlsli
View file

@ -3,12 +3,19 @@
#define PI 3.1415926535897932384626433832795028841971693993751058209749445923
#define PI2 6.2831853071795864769252867665590057683943387987502116419498891846
#define EPSILON 1e-38
#define OCTAVES 6
#define LT_SUN 0
#define LT_POINT 1
#define LT_SPOT 2
#define LT_SHADOW 3
#define LT_SUN 0
#define LT_POINT 1
#define LT_SPOT 2
#define LT_SHADOW 3
#define LT_MASK 0xFFFF
#define LT_MASK_SUN (1 << (31 - LT_SUN))
#define LT_MASK_POINT (1 << (31 - LT_POINT))
#define LT_MASK_SPOT (1 << (31 - LT_SPOT))
#define LT_MASK_SHADOW (1 << (31 - LT_SHADOW))
#define MAX_LIGHTS_PER_ROOM 48
#define MAX_LIGHTS_PER_ITEM 8

43
TombEngine/Shaders/Rooms.fx
View file

@ -7,6 +7,8 @@
#include "./Shadows.hlsli"
#include "./ShaderLight.hlsli"
#define ROOM_LIGHT_COEFF 0.7f
cbuffer RoomBuffer : register(b5)
{
int Water;
@ -141,28 +143,31 @@ PixelShaderOutput PS(PixelShaderInput input)
occlusion = pow(SSAOTexture.Sample(SSAOSampler, samplePosition).x, AmbientOcclusionExponent);
}
if (CastShadows)
lighting = DoShadow(input.WorldPosition, normal, lighting, -2.5f);
lighting = DoBlobShadows(input.WorldPosition, lighting);
bool onlyPointLights = (NumRoomLights & ~LT_MASK) == LT_MASK_POINT;
int numLights = NumRoomLights & LT_MASK;
for (int i = 0; i < numLights; i++)
{
float isPointLight = step(0.5f, Light.Type == LT_POINT); // 1.0 if LT_POINT, 0.0 otherwise
float isSpotLight = step(0.5f, Light.Type == LT_SPOT); // 1.0 if LT_SPOT, 0.0 otherwise
float isOtherLight = 1.0 - (isPointLight + isSpotLight); // 1.0 if neither LT_POINT nor LT_SPOT
float3 pointLightShadow = DoPointLightShadow(input.WorldPosition, lighting);
float3 spotLightShadow = DoSpotLightShadow(input.WorldPosition, normal, lighting);
// Blend the shadows based on the light type
lighting = pointLightShadow * isPointLight + spotLightShadow * isSpotLight + lighting * isOtherLight;
}
if (onlyPointLights)
{
lighting += DoPointLight(input.WorldPosition, normal, RoomLights[i]) * ROOM_LIGHT_COEFF;
}
else
{
// Room dynamic lights can only be spot or point, so we use simplified function for that.
lighting = DoBlobShadows(input.WorldPosition, lighting);
float isPoint = step(0.5f, RoomLights[i].Type == LT_POINT);
float isSpot = step(0.5f, RoomLights[i].Type == LT_SPOT);
for (int i = 0; i < NumRoomLights; i++)
{
float isPointLightRoom = step(0.5f, RoomLights[i].Type == LT_POINT);
float isSpotLightRoom = step(0.5f, RoomLights[i].Type == LT_SPOT);
lighting += DoPointLight(input.WorldPosition, normal, RoomLights[i]) * isPointLightRoom;
lighting += DoSpotLight(input.WorldPosition, normal, RoomLights[i]) * isSpotLightRoom;
float3 pointLight = float3(0.0f, 0.0f, 0.0f);
float3 spotLight = float3(0.0f, 0.0f, 0.0f);
DoPointAndSpotLight(input.WorldPosition, normal, RoomLights[i], pointLight, spotLight);
lighting += pointLight * isPoint * ROOM_LIGHT_COEFF + spotLight * isSpot * ROOM_LIGHT_COEFF;
}
}
if (Caustics)

65
TombEngine/Shaders/ShaderLight.hlsli
View file

@ -129,21 +129,30 @@ float3 DoSpotLight(float3 pos, float3 normal, ShaderLight light)
float3 lightVec = pos - light.Position.xyz;
float distance = length(lightVec);
float3 lightDir = normalize(lightVec);
float cosine = dot(lightDir, light.Direction.xyz);
// Angle attenuation
float coneInCos = cos(light.InRange * (PI / 180.0f));
float coneOutCos = cos(light.OutRange * (PI / 180.0f));
float angleAttenuation = saturate((cosine - coneOutCos) / (coneInCos - coneOutCos));
// Distance attenuation
float cosine = dot(lightDir, light.Direction.xyz);
float angleAttenuation = saturate((cosine - light.OutRange) / (light.InRange - light.OutRange));
float distanceAttenuation = saturate((light.Out - distance) / (light.Out - light.In));
// Surface lighting
float d = saturate(dot(normal, -lightDir));
return saturate(light.Color.xyz * light.Intensity * angleAttenuation * distanceAttenuation * d);
}
void DoPointAndSpotLight(float3 pos, float3 normal, ShaderLight light, out float3 pointOutput, out float3 spotOutput)
{
float3 lightVec = light.Position.xyz - pos;
float distance = length(lightVec);
float3 lightDir = normalize(lightVec);
float cosine = dot(-lightDir, light.Direction.xyz);
float distanceAttenuation = saturate((light.Out - distance) / (light.Out - light.In));
float angleAttenuation = saturate((cosine - light.OutRange) / (light.InRange - light.OutRange));
float d = saturate(dot(normal, lightDir));
pointOutput = saturate(light.Color.xyz * light.Intensity * distanceAttenuation * d);
spotOutput = saturate(light.Color.xyz * light.Intensity * angleAttenuation * distanceAttenuation * d);
}
float3 DoDirectionalLight(float3 pos, float3 normal, ShaderLight light)
{
float d = saturate(dot(-light.Direction.xyz, normal));
@ -364,23 +373,37 @@ float3 CombineLights(float3 ambient, float3 vertex, float3 tex, float3 pos, floa
float3 shadow = 0;
float3 spec = 0;
int lightTypeMask = (numLights & ~LT_MASK);
numLights = numLights & LT_MASK;
for (int i = 0; i < numLights; i++)
{
float isPoint = step(0.5f, float(lights[i].Type == LT_POINT));
float isSpot = step(0.5f, float(lights[i].Type == LT_SPOT));
float isSun = step(0.5f, float(lights[i].Type == LT_SUN));
float isShadow = step(0.5f, float(lights[i].Type == LT_SHADOW));
if (lightTypeMask & LT_MASK_SUN)
{
float isSun = step(0.5f, float(lights[i].Type == LT_SUN));
diffuse += isSun * DoDirectionalLight(pos, normal, lights[i]);
spec += isSun * DoSpecularSun(normal, lights[i], sheen);
}
diffuse += isPoint * DoPointLight(pos, normal, lights[i]);
spec += isPoint * DoSpecularPoint(pos, normal, lights[i], sheen);
if (lightTypeMask & LT_MASK_POINT)
{
float isPoint = step(0.5f, float(lights[i].Type == LT_POINT));
diffuse += isPoint * DoPointLight(pos, normal, lights[i]);
spec += isPoint * DoSpecularPoint(pos, normal, lights[i], sheen);
}
diffuse += isSpot * DoSpotLight(pos, normal, lights[i]);
spec += isSpot * DoSpecularSpot(pos, normal, lights[i], sheen);
diffuse += isSun * DoDirectionalLight(pos, normal, lights[i]);
spec += isSun * DoSpecularSun(normal, lights[i], sheen);
shadow += isShadow * DoShadowLight(pos, normal, lights[i]);
if (lightTypeMask & LT_MASK_SPOT)
{
float isSpot = step(0.5f, float(lights[i].Type == LT_SPOT));
diffuse += isSpot * DoSpotLight(pos, normal, lights[i]);
spec += isSpot * DoSpecularSpot(pos, normal, lights[i], sheen);
}
if (lightTypeMask & LT_MASK_SHADOW)
{
float isShadow = step(0.5f, float(lights[i].Type == LT_SHADOW));
shadow += isShadow * DoShadowLight(pos, normal, lights[i]);
}
}
shadow = saturate(shadow);

84
TombEngine/Shaders/Shadows.hlsli
View file

@ -1,3 +1,5 @@
#include "./Blending.hlsli"
#include "./Math.hlsli"
#include "./ShaderLight.hlsli"
#define SHADOW_INTENSITY (0.55f)
@ -86,20 +88,32 @@ float3 DoBlobShadows(float3 worldPos, float3 lighting)
return lighting * saturate(shadowFactor + SHADOW_INTENSITY);
}
float3 DoPointLightShadow(float3 worldPos, float3 lighting)
float3 DoShadow(float3 worldPos, float3 normal, float3 lighting, float bias)
{
if (!CastShadows)
return lighting;
if (BlendMode != BLENDMODE_OPAQUE && BlendMode != BLENDMODE_ALPHATEST && BlendMode != BLENDMODE_ALPHABLEND)
return lighting;
float shadowFactor = 1.0f;
float3 dir = normalize(Light.Position - worldPos);
float ndot = dot(normal, dir);
float facingFactor = saturate((ndot - bias) / (1.0f - bias + EPSILON));
[unroll]
for (int i = 0; i < 6; i++)
{
float3 dir = normalize(worldPos - Light.Position);
float4 lightClipSpace = mul(float4(worldPos, 1.0f), LightViewProjections[i]);
lightClipSpace.xyz /= lightClipSpace.w;
if (lightClipSpace.x >= -1.0f && lightClipSpace.x <= 1.0f &&
lightClipSpace.y >= -1.0f && lightClipSpace.y <= 1.0f &&
lightClipSpace.z >= 0.0f && lightClipSpace.z <= 1.0f)
float insideLightBounds =
step(-1.0f, lightClipSpace.x) * step(lightClipSpace.x, 1.0f) *
step(-1.0f, lightClipSpace.y) * step(lightClipSpace.y, 1.0f) *
step( 0.0f, lightClipSpace.z) * step(lightClipSpace.z, 1.0f);
if (insideLightBounds > 0.0f)
{
lightClipSpace.x = lightClipSpace.x / 2 + 0.5;
lightClipSpace.y = lightClipSpace.y / -2 + 0.5;
@ -108,63 +122,29 @@ float3 DoPointLightShadow(float3 worldPos, float3 lighting)
float x, y;
// Perform PCF filtering on a 4 x 4 texel neighborhood.
[unroll]
[unroll]
for (y = -1.5; y <= 1.5; y += 1.0)
{
[unroll]
[unroll]
for (x = -1.5; x <= 1.5; x += 1.0)
{
sum += ShadowMap.SampleCmpLevelZero(ShadowMapSampler, float3(lightClipSpace.xy + TexOffset(x, y), i), lightClipSpace.z);
}
}
shadowFactor = sum / 16.0;
shadowFactor = lerp(shadowFactor, sum / 16.0, facingFactor * insideLightBounds);
}
}
// Compute attenuation and combine lighting contribution with shadow factor
float distanceFactor = saturate(((distance(worldPos, Light.Position)) / (Light.Out)));
return lighting * saturate((shadowFactor + SHADOW_INTENSITY) + (pow(distanceFactor, 4) * INV_SHADOW_INTENSITY));
}
float3 DoSpotLightShadow(float3 worldPos, float3 normal, float3 lighting)
{
float influence = 1.0f - Luma(DoSpotLight(worldPos, normal, Light));
float shadowFactor = 1.0f;
[unroll]
for (int i = 0; i < 6; i++)
{
float3 dir = normalize(worldPos - Light.Position);
float4 lightClipSpace = mul(float4(worldPos, 1.0f), LightViewProjections[i]);
lightClipSpace.xyz /= lightClipSpace.w;
float isPoint = step(0.5f, Light.Type == LT_POINT); // 1.0 if LT_POINT, 0.0 otherwise
float isSpot = step(0.5f, Light.Type == LT_SPOT); // 1.0 if LT_SPOT, 0.0 otherwise
float isOther = 1.0 - (isPoint + isSpot); // 1.0 if neither LT_POINT nor LT_SPOT
if (lightClipSpace.x >= -1.0f && lightClipSpace.x <= 1.0f &&
lightClipSpace.y >= -1.0f && lightClipSpace.y <= 1.0f &&
lightClipSpace.z >= 0.0f && lightClipSpace.z <= 1.0f)
{
lightClipSpace.x = lightClipSpace.x / 2 + 0.5;
lightClipSpace.y = lightClipSpace.y / -2 + 0.5;
float pointFactor = 1.0f - Luma(DoPointLight(worldPos, normal, Light));
float spotFactor = 1.0f - Luma(DoSpotLight(worldPos, normal, Light));
float sum = 0;
float x, y;
float3 pointShadow = lighting * saturate((shadowFactor + SHADOW_INTENSITY) + (pow(pointFactor, 4) * INV_SHADOW_INTENSITY));
float3 spotShadow = lighting * saturate((shadowFactor + SHADOW_INTENSITY) + (pow(spotFactor, 4) * INV_SHADOW_INTENSITY));
// Perform PCF filtering on a 4 x 4 texel neighborhood.
[unroll]
for (y = -1.5; y <= 1.5; y += 1.0)
{
[unroll]
for (x = -1.5; x <= 1.5; x += 1.0)
{
sum += ShadowMap.SampleCmpLevelZero(ShadowMapSampler, float3(lightClipSpace.xy + TexOffset(x, y), i), lightClipSpace.z);
}
}
shadowFactor = sum / 16.0;
}
}
// Compute attenuation and combine lighting contribution with shadow factor
return lighting * saturate((shadowFactor + SHADOW_INTENSITY) + (pow(influence, 4) * INV_SHADOW_INTENSITY));
}
return pointShadow * isPoint + spotShadow * isSpot + lighting * isOther;
}

3
TombEngine/Shaders/Statics.fx
View file

@ -5,6 +5,7 @@
#include "./VertexInput.hlsli"
#include "./Blending.hlsli"
#include "./CBStatic.hlsli"
#include "./Shadows.hlsli"
struct PixelShaderInput
{
@ -92,6 +93,8 @@ PixelShaderOutput PS(PixelShaderInput input)
input.FogBulbs.w) :
StaticLight(input.Color.xyz, tex.xyz, input.FogBulbs.w);
color = DoShadow(input.WorldPosition, normal, color, -0.5f);
output.Color = float4(color, tex.w);
output.Color = DoFogBulbsForPixel(output.Color, float4(input.FogBulbs.xyz, 1.0f));
output.Color = DoDistanceFogForPixel(output.Color, FogColor, input.DistanceFog);

5
TombEngine/TombEngine.vcxproj
View file

@ -1380,7 +1380,10 @@ if not exist "%ScriptsDir%\Strings.lua" xcopy /Y "$(SolutionDir)Scripts\Strings.
<DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</DeploymentContent>
<FileType>Text</FileType>
</None>
<None Include="Shaders\Blending.hlsli" />
<None Include="Shaders\Blending.hlsli">
<DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</DeploymentContent>
<FileType>Document</FileType>
</None>
<None Include="Shaders\CBPostProcess.hlsli">
<DeploymentContent>true</DeploymentContent>
</None>