Archive/TombEngine
0
0
Fork 0
mirror of https://github.com/TombEngine/TombEngine.git synced 2025-05-11 04:56:49 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into renderdatarefactor

Browse source 
# Conflicts:
#	TR5Main/Renderer/Render11Helper.cpp
#	TR5Main/Renderer/Renderer11Compatibility.cpp
#	TR5Main/Renderer/Renderer11Draw.cpp
#	TR5Main/Renderer/Renderer11Frame.cpp
#	TR5Main/Renderer/Renderer11Lara.cpp
This commit is contained in:
Nils Gaitzsch 2020-07-03 10:09:13 +02:00
commit 822ec19f08
40 changed files with 1302 additions and 2676 deletions
Download patch file Download diff file Expand all files Collapse all files

10
TR5Main/Game/Box.h
View file

@ -36,14 +36,14 @@ typedef enum ZoneType
ZONE_APE, // only 2 click climb
};
typedef struct OBJECT_BONES
typedef struct OBJECT_Bones
{
short bone0;
short bone1;
short bone2;
short bone3;
OBJECT_BONES()
OBJECT_Bones()
{
this->bone0 = 0;
this->bone1 = 0;
@ -51,7 +51,7 @@ typedef struct OBJECT_BONES
this->bone3 = 0;
}
OBJECT_BONES(short all)
OBJECT_Bones(short all)
{
this->bone0 = all;
this->bone1 = all;
@ -59,7 +59,7 @@ typedef struct OBJECT_BONES
this->bone3 = all;
}
OBJECT_BONES(short angleY, short angleX)
OBJECT_Bones(short angleY, short angleX)
{
this->bone0 = angleY;
this->bone1 = angleX;
@ -67,7 +67,7 @@ typedef struct OBJECT_BONES
this->bone3 = angleX;
}
OBJECT_BONES(short angleY, short angleX, bool total)
OBJECT_Bones(short angleY, short angleX, bool total)
{
this->bone0 = angleY;
this->bone1 = angleX;

8
TR5Main/Game/control.cpp
View file

@ -2625,7 +2625,7 @@ int DoRayBox(GAME_VECTOR *start, GAME_VECTOR *end, short *box, PHD_3DPOS *itemOr
hitPos->z = collidedPoint.z - itemOrStaticPos->zPos;
// Now in the case of items we need to test single spheres
short *meshPtr = NULL;
MESH* meshPtr = NULL;
int bit = 0;
int sp = -2;
float minDistance = SECTOR(1024);
@ -2651,7 +2651,7 @@ int DoRayBox(GAME_VECTOR *start, GAME_VECTOR *end, short *box, PHD_3DPOS *itemOr
if (obj->nmeshes <= 0)
return 0;
meshPtr = Meshes[obj->meshIndex];
meshPtr = &Meshes[obj->meshIndex];
for (int i = 0; i < obj->nmeshes; i++)
{
@ -2674,7 +2674,7 @@ int DoRayBox(GAME_VECTOR *start, GAME_VECTOR *end, short *box, PHD_3DPOS *itemOr
if (newDist < minDistance)
{
minDistance = newDist;
meshPtr = Meshes[obj->meshIndex + i];
meshPtr = &Meshes[obj->meshIndex + i];
bit = 1 << i;
sp = i;
}
@ -3070,7 +3070,7 @@ int ExplodeItemNode(ITEM_INFO *item, int Node, int NoXZVel, int bits)
GetSpheres(item, CreatureSpheres, SPHERES_SPACE_WORLD | SPHERES_SPACE_BONE_ORIGIN, Matrix::Identity);
ShatterItem.yRot = item->pos.yRot;
ShatterItem.bit = 1 << Node;
ShatterItem.meshp = Meshes[Objects[item->objectNumber].meshIndex + Node];
ShatterItem.meshp = &Meshes[Objects[item->objectNumber].meshIndex + Node];
ShatterItem.sphere.x = CreatureSpheres[Node].x;
ShatterItem.sphere.y = CreatureSpheres[Node].y;
ShatterItem.sphere.z = CreatureSpheres[Node].z;

6
TR5Main/Game/debris.cpp
View file

@ -24,12 +24,12 @@ DebrisFragment* GetFreeDebrisFragment()
void ShatterObject(SHATTER_ITEM* item, MESH_INFO* mesh, int num,short roomNumber,int noZXVel)
{
short* meshPtr = nullptr;
MESH* meshPtr = nullptr;
RendererMesh* fragmentsMesh;
short yRot = 0;
Vector3 pos;
if (mesh) {
meshPtr = Meshes[StaticObjects[mesh->staticNumber].meshNumber];
meshPtr = &Meshes[StaticObjects[mesh->staticNumber].meshNumber];
yRot = mesh->yRot;
pos = Vector3(mesh->x, mesh->y, mesh->z);
}
@ -38,7 +38,7 @@ void ShatterObject(SHATTER_ITEM* item, MESH_INFO* mesh, int num,short roomNumber
yRot = item->yRot;
pos = Vector3(item->sphere.x, item->sphere.y, item->sphere.z);
}
fragmentsMesh = g_Renderer.getMeshFromMeshPtr(reinterpret_cast<unsigned int>(meshPtr));
fragmentsMesh = g_Renderer.getMesh(0);
for (int bucket = RENDERER_BUCKET_SOLID; bucket <= RENDERER_BUCKET_TRANSPARENT; bucket++) {
RendererBucket renderBucket = fragmentsMesh->Buckets[bucket];
vector<RendererVertex>* meshVertices = &renderBucket.Vertices;

8
TR5Main/Game/debris.h
View file

@ -1,6 +1,8 @@
#pragma once
#include "sphere.h"
#include "Renderer11.h"
#include <sphere.h>
#include <Renderer11.h>
#include <newtypes.h>
#include <level.h>
#define MAX_DEBRIS 256
@ -25,7 +27,7 @@ typedef struct SHATTER_ITEM
{
SPHERE sphere;
ITEM_LIGHT* il;
short* meshp;
MESH* meshp;
int bit;
short yRot;
short flags;

8
TR5Main/Game/effect.cpp
View file

@ -380,12 +380,10 @@ void ExplosionFX(ITEM_INFO* item)//39694(<), 39B94(<) (F)
void SwapCrowbar(ITEM_INFO* item)//39638(<), 39B38(<) (F)
{
short* tmp = Meshes[Objects[ID_LARA].meshIndex + LM_RHAND];
if (Lara.meshPtrs[LM_RHAND] == tmp)
Lara.meshPtrs[LM_RHAND] = Meshes[Objects[ID_LARA_CROWBAR_ANIM].meshIndex + LM_RHAND];
if (Lara.meshPtrs[LM_RHAND] == Objects[ID_LARA].meshIndex + LM_RHAND)
Lara.meshPtrs[LM_RHAND] = Objects[ID_LARA_CROWBAR_ANIM].meshIndex + LM_RHAND;
else
Lara.meshPtrs[LM_RHAND] = tmp;
Lara.meshPtrs[LM_RHAND] = Objects[ID_LARA].meshIndex + LM_RHAND;
}
void ActivateKey(ITEM_INFO* item)//39624(<), 39B24(<) (F)

10
TR5Main/Game/flmtorch.cpp
View file

@ -110,7 +110,8 @@ void DoFlameTorch() // (F) (D)
}
else if (Lara.leftArm.frameNumber == 12)
{
LARA_MESHES(ID_LARA, LM_LHAND);
//LARA_MESHES(ID_LARA, LM_LHAND);
Lara.meshPtrs[LM_LHAND] = Objects[ID_LARA_SKIN].meshIndex + LM_LHAND;
CreateFlare(ID_BURNING_TORCH_ITEM, 1);
}
}
@ -130,7 +131,8 @@ void DoFlameTorch() // (F) (D)
}
else if (Lara.leftArm.frameNumber == 36)
{
LARA_MESHES(ID_LARA, LM_LHAND);
//LARA_MESHES(ID_LARA, LM_LHAND);
Lara.meshPtrs[LM_LHAND] = Objects[ID_LARA_SKIN].meshIndex + LM_LHAND;
CreateFlare(ID_BURNING_TORCH_ITEM, 0);
}
break;
@ -187,7 +189,9 @@ void GetFlameTorch() // (F) (D)
Lara.leftArm.lock = false;
Lara.leftArm.frameNumber = 0;
Lara.leftArm.frameBase = Anims[Lara.leftArm.animNumber].framePtr;
LARA_MESHES(ID_LARA_TORCH_ANIM, LM_LHAND);
//LARA_MESHES(ID_LARA_TORCH_ANIM, LM_LHAND);
Lara.meshPtrs[LM_LHAND] = Objects[ID_LARA_TORCH_ANIM].meshIndex + LM_LHAND;
}
void TorchControl(short itemNumber) // (F) (D)

30
TR5Main/Game/hair.cpp
View file

@ -100,47 +100,47 @@ void HairControl(int cutscene, int ponytail, short* framePtr)
}
// Get Lara's spheres in absolute coords, for head, torso, hips and upper arms
short* objptr = Lara.meshPtrs[LM_HIPS];
PHD_VECTOR pos = { objptr[0], objptr[1], objptr[2] };
MESH* objptr = &Meshes[Lara.meshPtrs[LM_HIPS]];
PHD_VECTOR pos = { (int)objptr->sphere.Center.x, (int)objptr->sphere.Center.y, (int)objptr->sphere.Center.z };
GetLaraJointPosition(&pos, LM_HIPS);
sphere[0].x = pos.x;
sphere[0].y = pos.y;
sphere[0].z = pos.z;
sphere[0].r = (int) * (objptr + 3);
sphere[0].r = (int)objptr->sphere.Radius;
objptr = Lara.meshPtrs[LM_TORSO];
pos = { objptr[0], objptr[1], objptr[2] };
objptr = &Meshes[Lara.meshPtrs[LM_TORSO]];
pos = { (int)objptr->sphere.Center.x, (int)objptr->sphere.Center.y, (int)objptr->sphere.Center.z };
GetLaraJointPosition(&pos, LM_TORSO);
sphere[1].x = pos.x;
sphere[1].y = pos.y;
sphere[1].z = pos.z;
sphere[1].r = (int) * (objptr + 3);
sphere[1].r = (int)objptr->sphere.Radius;
if (youngLara)
sphere[1].r = sphere[1].r - ((sphere[1].r >> 2) + (sphere[1].r >> 3));
objptr = Lara.meshPtrs[LM_HEAD];
pos = { objptr[0], objptr[1], objptr[2] };
objptr = &Meshes[Lara.meshPtrs[LM_HEAD]];
pos = { (int)objptr->sphere.Center.x, (int)objptr->sphere.Center.y, (int)objptr->sphere.Center.z };
GetLaraJointPosition(&pos, LM_HEAD);
sphere[2].x = pos.x;
sphere[2].y = pos.y;
sphere[2].z = pos.z;
sphere[2].r = (int) * (objptr + 3);
sphere[2].r = (int)objptr->sphere.Radius;
objptr = Lara.meshPtrs[LM_RINARM];
pos = { objptr[0], objptr[1], objptr[2] };
objptr = &Meshes[Lara.meshPtrs[LM_RINARM]];
pos = { (int)objptr->sphere.Center.x, (int)objptr->sphere.Center.y, (int)objptr->sphere.Center.z };
GetLaraJointPosition(&pos, LM_RINARM);
sphere[3].x = pos.x;
sphere[3].y = pos.y;
sphere[3].z = pos.z;
sphere[3].r = (int) * (objptr + 3) * 3 / 2;
sphere[3].r = (int)objptr->sphere.Radius * 3 / 2;
objptr = Lara.meshPtrs[LM_LINARM];
pos = { objptr[0], objptr[1], objptr[2] };
objptr = &Meshes[Lara.meshPtrs[LM_LINARM]];
pos = { (int)objptr->sphere.Center.x, (int)objptr->sphere.Center.y, (int)objptr->sphere.Center.z };
GetLaraJointPosition(&pos, LM_LINARM);
sphere[4].x = pos.x;
sphere[4].y = pos.y;
sphere[4].z = pos.z;
sphere[4].r = (int) * (objptr + 3) * 3 / 2;
sphere[4].r = (int)objptr->sphere.Radius * 3 / 2;
if (youngLara)
{

6
TR5Main/Game/lara1gun.cpp
View file

@ -1511,13 +1511,15 @@ void undraw_shotgun(int weapon)
void undraw_shotgun_meshes(int weapon)
{
Lara.backGun = WeaponObject(weapon);
LARA_MESHES(ID_LARA, LM_RHAND);
//LARA_MESHES(ID_LARA, LM_RHAND);
Lara.meshPtrs[LM_RHAND] = Objects[ID_LARA_SKIN].meshIndex + LM_RHAND;
}
void draw_shotgun_meshes(int weaponType)
{
Lara.backGun = WEAPON_NONE;
LARA_MESHES(WeaponObjectMesh(weaponType), LM_RHAND);
//LARA_MESHES(WeaponObjectMesh(weaponType), LM_RHAND);
Lara.meshPtrs[LM_RHAND] = Objects[WeaponObjectMesh(weaponType)].meshIndex + LM_RHAND;
}
void DoCrossbowDamage(ITEM_INFO* item1, ITEM_INFO* item2, signed int search)

12
TR5Main/Game/lara2gun.cpp
View file

@ -351,7 +351,8 @@ void PistolHandler(int weaponType)
void undraw_pistol_mesh_right(int weaponType)
{
LARA_MESHES(ID_LARA, LM_RHAND);
//LARA_MESHES(ID_LARA, LM_RHAND);
Lara.meshPtrs[LM_RHAND] = Objects[ID_LARA_SKIN].meshIndex + LM_RHAND;
switch (weaponType)
{
@ -372,7 +373,8 @@ void undraw_pistol_mesh_left(int weaponType)
{
if (weaponType != WEAPON_REVOLVER)
{
LARA_MESHES(ID_LARA, LM_LHAND);
//LARA_MESHES(ID_LARA, LM_LHAND);
Lara.meshPtrs[LM_LHAND] = Objects[ID_LARA_SKIN].meshIndex + LM_LHAND;
switch (weaponType)
{
@ -390,9 +392,11 @@ void draw_pistol_meshes(int weaponType)
{
Lara.holster = ID_LARA_HOLSTERS;
LARA_MESHES(WeaponObjectMesh(weaponType), LM_RHAND);
//LARA_MESHES(WeaponObjectMesh(weaponType), LM_RHAND);
Lara.meshPtrs[LM_RHAND] = Objects[WeaponObjectMesh(weaponType)].meshIndex + LM_RHAND;
if (weaponType != WEAPON_REVOLVER)
LARA_MESHES(WeaponObjectMesh(weaponType), LM_LHAND);
//LARA_MESHES(WeaponObjectMesh(weaponType), LM_LHAND);
Lara.meshPtrs[LM_LHAND] = Objects[WeaponObjectMesh(weaponType)].meshIndex + LM_LHAND;
}
void ready_pistols(int weaponType)

2
TR5Main/Game/lara_struct.h
View file

@ -835,7 +835,7 @@ typedef struct LaraInfo
PHD_VECTOR lastPos;
FX_INFO* spazEffect;
int meshEffects;
short* meshPtrs[NUM_LARA_MESHES];
int meshPtrs[NUM_LARA_MESHES];
ITEM_INFO* target;
short targetAngles[2];
short turnRate;

13
TR5Main/Game/larafire.cpp
View file

@ -310,7 +310,7 @@ void AimWeapon(WEAPON_INFO* winfo, LARA_ARM* arm) // (F) (D)
rotX -= speed;
arm->xRot = rotX;
// TODO: set arm rotations to inherit rotations of parent bones. -Sezz
// TODO: set arm rotations to inherit rotations of parent Bones. -Sezz
arm->zRot = 0;
}
@ -472,7 +472,8 @@ void LaraGun() // (F) (D)
break;
case LG_UNDRAW_GUNS:
LARA_MESHES(ID_LARA, LM_HEAD);
//LARA_MESHES(ID_LARA, LM_HEAD);
Lara.meshPtrs[LM_HEAD] = Objects[ID_LARA_SKIN].meshIndex + LM_HEAD;
switch (Lara.gunType)
{
@ -504,9 +505,11 @@ void LaraGun() // (F) (D)
case LG_READY:
if (!(TrInput & IN_ACTION))
LARA_MESHES(ID_LARA, LM_HEAD);
//LARA_MESHES(ID_LARA, LM_HEAD);
Lara.meshPtrs[LM_HEAD] = Objects[ID_LARA_SKIN].meshIndex + LM_HEAD;
else
LARA_MESHES(ID_LARA_SCREAM, LM_HEAD);
//LARA_MESHES(ID_LARA_SCREAM, LM_HEAD);
Lara.meshPtrs[LM_HEAD] = Objects[ID_LARA_SCREAM].meshIndex + LM_HEAD;
if (Camera.type != CINEMATIC_CAMERA && Camera.type != LOOK_CAMERA && Camera.type != HEAVY_CAMERA)
Camera.type = COMBAT_CAMERA;
@ -580,7 +583,7 @@ void LaraGun() // (F) (D)
case LG_HANDS_BUSY:
if (Lara.gunType == WEAPON_FLARE)
{
if (CHECK_LARA_MESHES(ID_LARA_FLARE_ANIM, LM_LHAND))
if (Lara.meshPtrs[LM_LHAND] == Objects[ID_LARA_FLARE_ANIM].meshIndex + LM_LHAND /*CHECK_LARA_MESHES(ID_LARA_FLARE_ANIM, LM_LHAND)*/)
{
#if 0
Lara.flareControlLeft = (Lara.Vehicle != NO_ITEM || CheckForHoldingState(LaraItem->currentAnimState));

6
TR5Main/Game/laraflar.cpp
View file

@ -104,12 +104,14 @@ void ready_flare() // (F) (D)
void undraw_flare_meshes() // (F) (D)
{
LARA_MESHES(ID_LARA, LM_LHAND);
//LARA_MESHES(ID_LARA, LM_LHAND);
Lara.meshPtrs[LM_LHAND] = Objects[ID_LARA_SKIN].meshIndex + LM_LHAND;
}
void draw_flare_meshes() // (F) (D)
{
LARA_MESHES(ID_LARA_FLARE_ANIM, LM_LHAND);
//LARA_MESHES(ID_LARA_FLARE_ANIM, LM_LHAND);
Lara.meshPtrs[LM_LHAND] = Objects[ID_LARA_FLARE_ANIM].meshIndex + LM_LHAND;
}
void undraw_flare() // (F) (D)

5
TR5Main/Game/laramisc.cpp
View file

@ -742,8 +742,9 @@ void LaraInitialiseMeshes() // (AF) (D)
{
for (int i = 0; i < NUM_LARA_MESHES; i++)
{
MESHES(ID_LARA, i) = MESHES(ID_LARA_SKIN, i);
LARA_MESHES(ID_LARA, i);
//Meshes[i] = Meshes[MESHES(ID_LARA_SKIN, i)];
//LARA_MESHES(ID_LARA, MESHES(ID_LARA_SKIN, i));
Lara.meshPtrs[i] = Objects[ID_LARA_SKIN].meshIndex + i;
}
/* Hardcoded code */

71
TR5Main/Game/room.h
View file

@ -1,34 +1,6 @@
#pragma once
#include <framework.h>
typedef struct tr5_room_layer
{
unsigned int NumLayerVertices; // Number of vertices in this layer (4 bytes)
unsigned short UnknownL1;
unsigned short NumLayerRectangles; // Number of rectangles in this layer (2 bytes)
unsigned short NumLayerTriangles; // Number of triangles in this layer (2 bytes)
unsigned short UnknownL2;
unsigned short Filler; // Always 0
unsigned short Filler2; // Always 0
/// The following 6 floats define the bounding box for the layer
float LayerBoundingBoxX1;
float LayerBoundingBoxY1;
float LayerBoundingBoxZ1;
float LayerBoundingBoxX2;
float LayerBoundingBoxY2;
float LayerBoundingBoxZ2;
unsigned int Filler3; // Always 0 (4 bytes)
void* VerticesOffset;
void* PolyOffset;
void* PolyOffset2;
};
typedef struct tr5_vertex
{
float x;
float y;
float z;
};
#include <newtypes.h>
struct ROOM_VERTEX
{
@ -37,6 +9,7 @@ struct ROOM_VERTEX
Vector2 textureCoordinates;
Vector3 color;
int effects;
int index;
};
struct ROOM_DOOR
@ -46,20 +19,6 @@ struct ROOM_DOOR
Vector3 vertices[4];
};
typedef struct tr4_mesh_face3 // 10 bytes
{
short Vertices[3];
short Texture;
short Effects; // TR4-5 ONLY: alpha blending and environment mapping strength
};
typedef struct tr4_mesh_face4 // 12 bytes
{
short Vertices[4];
short Texture;
short Effects;
};
struct POLYGON
{
int shape;
@ -67,24 +26,6 @@ struct POLYGON
int texture;
};
struct BUCKET
{
int texture;
byte blendMode;
bool animated;
std::vector<int> indices;
};
typedef struct tr_room_sector // 8 bytes
{
unsigned short FDindex; // Index into FloorData[]
unsigned short BoxIndex; // Index into Boxes[] (-1 if none)
unsigned char RoomBelow; // 255 is none
signed char Floor; // Absolute height of floor
unsigned char RoomAbove; // 255 if none
signed char Ceiling; // Absolute height of ceiling
};
typedef struct ROOM_LIGHT
{
float x, y, z; // Position of light, in world coordinates
@ -157,7 +98,7 @@ struct SECTOR_COLLISION_INFO
SECTOR_PLANE planes[2];
};
typedef struct FLOOR_INFO
struct FLOOR_INFO
{
int index;
int box;
@ -171,7 +112,7 @@ typedef struct FLOOR_INFO
SECTOR_COLLISION_INFO ceilingCollision;
};
typedef enum RoomEnumFlag
enum RoomEnumFlag
{
ENV_FLAG_WATER = 0x0001,
ENV_FLAG_SWAMP = 0x0004,
@ -185,7 +126,7 @@ typedef enum RoomEnumFlag
ENV_FLAG_UNKNOWN3 = 0x0400
};
typedef struct ROOM_INFO
struct ROOM_INFO
{
int x;
int y;
@ -211,7 +152,7 @@ typedef struct ROOM_INFO
bool boundActive;
};
typedef struct ANIM_STRUCT
struct ANIM_STRUCT
{
short* framePtr;
short interpolation;

8
TR5Main/Game/savegame.cpp
View file

@ -215,9 +215,6 @@ void SaveGame::saveLara(int arg1, int arg2)
LaraInfo lara;
memcpy(&lara, &Lara, sizeof(Lara));
for (int i = 0; i < 15; i++)
lara.meshPtrs[i] = (short*)((char*)lara.meshPtrs[i] - (ptrdiff_t)MeshBase);
lara.leftArm.frameBase = (short*)((char *)lara.leftArm.frameBase - (ptrdiff_t)Objects[ID_LARA].frameBase);
lara.rightArm.frameBase = (short*)((char *)lara.rightArm.frameBase - (ptrdiff_t)Objects[ID_LARA].frameBase);
lara.generalPtr = (char *)lara.generalPtr - (ptrdiff_t)malloc_buffer;
@ -512,11 +509,6 @@ bool SaveGame::readLara()
memcpy(&Lara, lara, sizeof(LaraInfo));
free(buffer);
for (int i = 0; i < NUM_LARA_MESHES; i++)
{
Lara.meshPtrs[i] = AddPtr(Lara.meshPtrs[i], short, MeshBase);
}
Lara.leftArm.frameBase = AddPtr(Lara.leftArm.frameBase, short, Objects[ID_LARA].frameBase);
Lara.rightArm.frameBase = AddPtr(Lara.rightArm.frameBase, short, Objects[ID_LARA].frameBase);

4
TR5Main/Game/sound.h
View file

@ -619,7 +619,7 @@ typedef enum sound_effects
SFX_TR1_BULLET_HITTING_LARA = 500,
SFX_TR1_LARA_HEH_STARTING_TO_PULL_BLOCK = 501,
SFX_TR1_LARA_TREADING_WATER = 502,
SFX_TR1_LARA_S_BONES_BREAKING_DYING = 503,
SFX_TR1_LARA_S_Bones_BREAKING_DYING = 503,
SFX_TR1_LEDGE_GRAB_BY_LARA = 504,
SFX_TR1_LARA_OOMPH_HITTING_WALL_AFTER_GRABBING_LEDGE = 505,
SFX_TR1_FOOTSTEP_LEDGE_SHIMMY_BY_LARA = 506,
@ -877,7 +877,7 @@ typedef enum sound_effects
SFX_TR2_BULLET_HITTING_LARA = 756,
SFX_TR2_LARA_HEH_PULLING_UP = 757,
SFX_TR2_LARA_TREADING_WATER1 = 758,
SFX_TR2_LARA_S_BONES_BREAKING_DYING = 759,
SFX_TR2_LARA_S_Bones_BREAKING_DYING = 759,
SFX_TR2_LEDGE_GRAB_BY_LARA = 760,
SFX_TR2_LARA_OOMPH_HITTING_WALL_AFTER_GRABBING_LEDGE = 761,
SFX_TR2_FOOTSTEP_LEDGE_SHIMMY_BY_LARA = 762,

2
TR5Main/Objects/Effects/tr4_bubbles.cpp
View file

@ -176,7 +176,7 @@ void BubblesEffect4(short fxNum, short xVel, short yVel, short zVel)
void BubblesShatterFunction(FX_INFO* fx, int param1, int param2)
{
ShatterItem.yRot = fx->pos.yRot;
ShatterItem.meshp = Meshes[fx->frameNumber];
ShatterItem.meshp = &Meshes[fx->frameNumber];
ShatterItem.sphere.x = fx->pos.xPos;
ShatterItem.sphere.y = fx->pos.yPos;
ShatterItem.sphere.z = fx->pos.zPos;

5
TR5Main/Objects/TR2/Entity/tr2_dragon.cpp
View file

@ -134,7 +134,7 @@ static void createExplosion(ITEM_INFO* item)
static void createDragonBone(short front_number)
{
/* Create the bones of the dragon */
/* Create the Bones of the dragon */
short bone_back, bone_front;
ITEM_INFO* back_dragon, *front_dragon, *item;
@ -239,7 +239,8 @@ void DragonCollision(short itemNum, ITEM_INFO* laraitem, COLL_INFO* coll)
Lara.gunStatus = LG_HANDS_BUSY;
Lara.hitDirection = -1;
LARA_MESHES(ID_LARA_EXTRA_ANIMS, LM_RHAND);
//LARA_MESHES(ID_LARA_EXTRA_ANIMS, LM_RHAND);
Lara.meshPtrs[LM_RHAND] = Objects[ID_LARA_EXTRA_ANIMS].meshIndex + LM_RHAND;
/* Do cinematic camera */
Camera.type = CINEMATIC_CAMERA;

10
TR5Main/Objects/TR2/tr2_objects.cpp
View file

@ -247,7 +247,7 @@ static void StartBaddy(ObjectInfo* obj)
obj->savePosition = true;
//Bones[obj->boneIndex + 5*4] |= (ROT_X | ROT_Y);
//Bones[obj->boneIndex + 14*4] |= (ROT_X | ROT_Y);
// TODO: get the correct torso and head bones value and assign ROT_X and ROT_Y to it !
// TODO: get the correct torso and head Bones value and assign ROT_X and ROT_Y to it !
}
obj = &Objects[ID_WORKER_MACHINEGUN];
@ -267,7 +267,7 @@ static void StartBaddy(ObjectInfo* obj)
obj->savePosition = true;
//Bones[obj->boneIndex + 5*4] |= (ROT_X | ROT_Y);
//Bones[obj->boneIndex + 14*4] |= (ROT_X | ROT_Y);
// TODO: get the correct torso and head bones value and assign ROT_X and ROT_Y to it !
// TODO: get the correct torso and head Bones value and assign ROT_X and ROT_Y to it !
}
obj = &Objects[ID_SMALL_SPIDER];
@ -377,7 +377,7 @@ static void StartBaddy(ObjectInfo* obj)
obj->savePosition = true;
//Bones[obj->boneIndex + 8 * 4] |= (ROT_X | ROT_Y);
//Bones[obj->boneIndex + 0 * 4] |= (ROT_X | ROT_Y);
// TODO: find the correct for bones (knifethrower).
// TODO: find the correct for Bones (knifethrower).
}
obj = &Objects[ID_KNIFETHROWER_KNIFE];
@ -505,7 +505,7 @@ static void StartBaddy(ObjectInfo* obj)
obj->savePosition = true;
Bones[obj->boneIndex + 6 * 4] |= (ROT_X | ROT_Y);
Bones[obj->boneIndex + 16 * 4] |= (ROT_X | ROT_Y);
// TODO: bones value is not correct (shiva) !
// TODO: Bones value is not correct (shiva) !
// need the correct one.
}
@ -527,7 +527,7 @@ static void StartBaddy(ObjectInfo* obj)
obj->savePosition = true;
//Bones[obj->boneIndex + 6 * 4] |= (ROT_X | ROT_Y);
//Bones[obj->boneIndex + 12 * 4] |= (ROT_X | ROT_Y);
// TODO: get the correct id for bones ! (spear)
// TODO: get the correct id for Bones ! (spear)
}
obj = &Objects[ID_DRAGON_FRONT];

14
TR5Main/Objects/TR3/Vehicles/kayak.cpp
View file

@ -954,11 +954,11 @@ static void KayakUserInput(ITEM_INFO* kayak, ITEM_INFO* lara, KAYAK_INFO* kinfo)
/* --------------------- */
if ((lara->animNumber == Objects[ID_KAYAK_LARA_ANIMS].animIndex + 4) && (frame == 24) && (!(kinfo->Flags & 0x80)))
{
short* tmp;
tmp = Lara.meshPtrs[LM_RHAND];
/*MESH tmp = Meshes[Lara.meshPtrs[LM_RHAND]];
LARA_MESHES(ID_KAYAK_LARA_ANIMS, LM_RHAND);
Meshes[Objects[ID_KAYAK_LARA_ANIMS].meshIndex + LM_RHAND] = tmp;
Meshes[Objects[ID_KAYAK_LARA_ANIMS].meshIndex + LM_RHAND] = tmp;*/
Lara.meshPtrs[LM_RHAND] = Objects[ID_KAYAK_LARA_ANIMS].meshIndex + LM_RHAND;
lara->meshBits &= ~LARA_LEG_BITS;
kinfo->Flags |= 0x80;
@ -968,11 +968,11 @@ static void KayakUserInput(ITEM_INFO* kayak, ITEM_INFO* lara, KAYAK_INFO* kinfo)
case KS_JUMPOUT:
if ((lara->animNumber == Objects[ID_KAYAK_LARA_ANIMS].animIndex + 14) && (frame == 27) && (kinfo->Flags & 0x80))
{
short* tmp;
tmp = Lara.meshPtrs[LM_RHAND];
/*MESH tmp = Meshes[Lara.meshPtrs[LM_RHAND]];
Lara.meshPtrs[LM_RHAND] = Meshes[Objects[ID_KAYAK_LARA_ANIMS].meshIndex + LM_RHAND];
Meshes[Objects[ID_KAYAK_LARA_ANIMS].meshIndex + LM_RHAND] = tmp;
LARA_MESHES(ID_KAYAK_LARA_ANIMS, LM_RHAND);
Meshes[Objects[ID_KAYAK_LARA_ANIMS].meshIndex + LM_RHAND] = tmp;*/
Lara.meshPtrs[LM_RHAND] = Objects[ID_LARA_SKIN].meshIndex + LM_RHAND;
lara->meshBits |= LARA_LEG_BITS;
kinfo->Flags &= ~0x80;

13
TR5Main/Objects/TR3/Vehicles/minecart.cpp
View file

@ -612,12 +612,11 @@ static void DoUserInput(ITEM_INFO* v, ITEM_INFO* l, CART_INFO* cart)
{
if ((l->frameNumber == GF2(ID_MINECART, 7, 0) + 20) && (cart->Flags & CF_MESH))
{
short* tmp;
tmp = Lara.meshPtrs[LM_RHAND];
/*MESH tmp = Meshes[Lara.meshPtrs[LM_RHAND]];
LARA_MESHES(ID_MINECART_LARA_ANIMS, LM_RHAND);
Meshes[Objects[ID_MINECART_LARA_ANIMS].meshIndex + LM_RHAND] = tmp;
Meshes[Objects[ID_MINECART_LARA_ANIMS].meshIndex + LM_RHAND] = tmp;*/
Lara.meshPtrs[LM_RHAND] = Objects[ID_MINECART_LARA_ANIMS].meshIndex + LM_RHAND;
cart->Flags &= ~CF_MESH;
}
@ -674,11 +673,9 @@ static void DoUserInput(ITEM_INFO* v, ITEM_INFO* l, CART_INFO* cart)
case CART_GETIN:
if ((l->animNumber == Objects[ID_MINECART_LARA_ANIMS].animIndex + 5) && (l->frameNumber == GF2(ID_MINECART, 5, 0) + 20) && (!cart->Flags & CF_MESH))
{
short* tmp;
MESH tmp = Meshes[Lara.meshPtrs[LM_RHAND]];
tmp = Lara.meshPtrs[LM_RHAND];
Lara.meshPtrs[LM_RHAND] = Meshes[Objects[ID_MINECART_LARA_ANIMS].meshIndex + LM_RHAND];
Lara.meshPtrs[LM_RHAND] = Objects[ID_MINECART_LARA_ANIMS].meshIndex + LM_RHAND;
Meshes[Objects[ID_MINECART_LARA_ANIMS].meshIndex + LM_RHAND] = tmp;
cart->Flags |= CF_MESH;

2
TR5Main/Objects/TR4/Entity/tr4_crocodile.cpp
View file

@ -104,7 +104,7 @@ void CrocodileControl(short itemNumber)
ObjectInfo* obj;
CREATURE_INFO* crocodile;
AI_INFO info;
OBJECT_BONES boneRot;
OBJECT_Bones boneRot;
short angle;
short boneAngle;

6
TR5Main/Objects/TR4/Entity/tr4_mutant.cpp
View file

@ -261,7 +261,7 @@ void MutantControl(short itemNumber)
ITEM_INFO* item;
CREATURE_INFO* mutant;
AI_INFO info;
OBJECT_BONES mutant_joint;
OBJECT_Bones mutant_joint;
short frameNumber;
short headY;
short angle;
@ -337,9 +337,9 @@ void MutantControl(short itemNumber)
}
if (item->currentAnimState != MUTANT_LOCUST1)
mutant_joint = OBJECT_BONES(headY, info.xAngle, true);
mutant_joint = OBJECT_Bones(headY, info.xAngle, true);
else
mutant_joint = OBJECT_BONES(0);
mutant_joint = OBJECT_Bones(0);
CreatureJoint(item, 0, mutant_joint.bone0);
CreatureJoint(item, 1, mutant_joint.bone1);

4
TR5Main/Objects/TR5/Object/tr5_missile.cpp
View file

@ -221,10 +221,10 @@ void MissileControl(short itemNumber)
void ExplodeFX(FX_INFO* fx, int noXZVel, int bits)
{
short** meshpp = &Meshes[fx->frameNumber];
MESH* meshpp = &Meshes[fx->frameNumber];
ShatterItem.yRot = fx->pos.yRot;
ShatterItem.meshp = *meshpp;
ShatterItem.meshp = meshpp;
ShatterItem.sphere.x = fx->pos.xPos;
ShatterItem.sphere.y = fx->pos.yPos;
ShatterItem.sphere.z = fx->pos.zPos;

4
TR5Main/Objects/Utils/object_helper.cpp
View file

@ -67,8 +67,8 @@ void InitAnimating(ObjectInfo* obj, int objectNumber)
obj->saveFlags = true;
obj->saveAnim = true;
obj->saveMesh = true;
Bones[obj->boneIndex + (0 * 4)] |= ROT_Y;
Bones[obj->boneIndex + (1 * 4)] |= ROT_X;
//Bones[obj->boneIndex + (0 * 4)] |= ROT_Y;
//Bones[obj->boneIndex + (1 * 4)] |= ROT_X;
}
}

634
TR5Main/Renderer/Render11Helper.cpp
View file

File diff suppressed because it is too large Load diff

11
TR5Main/Renderer/Renderer11.h
View file

@ -23,6 +23,8 @@
struct CAMERA_INFO;
#include <level.h>
namespace T5M::Renderer
{
#define MESH_BITS(x) (1 << x)
@ -32,7 +34,7 @@ namespace T5M::Renderer
constexpr auto MAX_LIGHTS_DRAW = 16384;
constexpr auto MAX_DYNAMIC_LIGHTS = 16384;
constexpr auto MAX_DRAW_STATICS = 16384;
constexpr auto MAX_BONES = 32;
constexpr auto MAX_Bones = 32;
constexpr auto MAX_SPRITES = 16384;
constexpr auto REFERENCE_RES_WIDTH = 800;
constexpr auto REFERENCE_RES_HEIGHT = 450;
@ -60,6 +62,7 @@ namespace T5M::Renderer
DirectX::SimpleMath::Vector2 UV;
DirectX::SimpleMath::Vector4 Color;
float Bone;
//int Index;
};
@ -481,7 +484,7 @@ namespace T5M::Renderer
int m_numSprites;
int m_numSpritesSequences;
std::vector<RendererSpriteSequence> m_spriteSequences;
std::unordered_map<unsigned int, RendererMesh*> m_meshPointersToMesh;
std::unordered_map<int, RendererMesh*> m_meshPointersToMesh;
DirectX::SimpleMath::Matrix m_LaraWorldMatrix;
std::vector<RendererAnimatedTextureSet> m_animatedTextureSets;
int m_numAnimatedTextureSets;
@ -531,7 +534,7 @@ namespace T5M::Renderer
ID3D11Buffer* createConstantBuffer(size_t size);
int getAnimatedTextureInfo(short textureId);
void initialiseHairRemaps();
RendererMesh* getRendererMeshFromTrMesh(RendererObject* obj, short* meshPtr, short boneIndex, int isJoints, int isHairs);
RendererMesh* getRendererMeshFromTrMesh(RendererObject* obj, MESH* meshPtr, short boneIndex, int isJoints, int isHairs);
void fromTrAngle(DirectX::SimpleMath::Matrix* matrix, short* frameptr, int index);
void buildHierarchy(RendererObject* obj);
void buildHierarchyRecursive(RendererObject* obj, RendererBone* node, RendererBone* parentNode);
@ -665,7 +668,7 @@ namespace T5M::Renderer
int GetSpheres(short itemNumber, BoundingSphere* ptr, char worldSpace, DirectX::SimpleMath::Matrix local);
void GetBoneMatrix(short itemNumber, int joint, DirectX::SimpleMath::Matrix* outMatrix);
RendererMesh* getMeshFromMeshPtr(unsigned int meshp);
RendererMesh* getMesh(int meshIndex);
private:
void drawFootprints();

327
TR5Main/Renderer/Renderer11Compatibility.cpp
View file

@ -5,11 +5,13 @@
#include "setup.h"
#include "control.h"
#include "objects.h"
using std::vector;
using std::stack;
using std::optional;
namespace T5M::Renderer {
bool Renderer11::PrepareDataForTheRenderer() {
using std::stack;
using std::vector;
namespace T5M::Renderer
{
bool Renderer11::PrepareDataForTheRenderer()
{
m_moveableObjects.resize(ID_NUMBER_OBJECTS);
m_spriteSequences.resize(ID_NUMBER_OBJECTS);
m_staticObjects.resize(MAX_STATICS);
@ -19,7 +21,7 @@ namespace T5M::Renderer {
// Step 0: prepare animated textures
short numSets = *AnimTextureRanges;
short* animatedPtr = AnimTextureRanges;
short *animatedPtr = AnimTextureRanges;
animatedPtr++;
m_animatedTextureSets = vector<RendererAnimatedTextureSet>(NUM_ANIMATED_SETS);
@ -28,7 +30,7 @@ namespace T5M::Renderer {
for (int i = 0; i < numSets; i++)
{
m_animatedTextureSets[i] = RendererAnimatedTextureSet();
RendererAnimatedTextureSet& const set = m_animatedTextureSets[i];
RendererAnimatedTextureSet &const set = m_animatedTextureSets[i];
short numTextures = *animatedPtr + 1;
animatedPtr++;
@ -40,10 +42,10 @@ namespace T5M::Renderer {
short textureId = *animatedPtr;
animatedPtr++;
OBJECT_TEXTURE* texture = &ObjectTextures[textureId];
OBJECT_TEXTURE *texture = &ObjectTextures[textureId];
int tile = texture->tileAndFlag & 0x7FFF;
set.Textures[j] = RendererAnimatedTexture();
RendererAnimatedTexture& const newTexture = set.Textures[j];
RendererAnimatedTexture &const newTexture = set.Textures[j];
newTexture.Id = textureId;
for (int k = 0; k < 4; k++)
@ -53,7 +55,6 @@ namespace T5M::Renderer {
newTexture.UV[k] = Vector2(x, y);
}
}
}
@ -99,34 +100,37 @@ namespace T5M::Renderer {
if (m_skyTexture == NULL)
return false;*/
//D3DX11SaveTextureToFileA(m_context, m_skyTexture->Texture, D3DX11_IFF_PNG, "H:\\sky.png");
//D3DX11SaveTextureToFileA(m_context, m_skyTexture->Texture, D3DX11_IFF_PNG, "H:\\sky.png");
//free(buffer);
//free(buffer);
// Upload textures to GPU memory
for (int i = 0; i < RoomTextures.size(); i++) {
TEXTURE* texture = &RoomTextures[i];
// Upload textures to GPU memory
for (int i = 0; i < RoomTextures.size(); i++)
{
TEXTURE *texture = &RoomTextures[i];
m_roomTextures.push_back(Texture2D(m_device, texture->data.data(), texture->size));
}
for (int i = 0; i < MoveablesTextures.size(); i++) {
TEXTURE* texture = &MoveablesTextures[i];
for (int i = 0; i < MoveablesTextures.size(); i++)
{
TEXTURE *texture = &MoveablesTextures[i];
m_moveablesTextures.push_back(Texture2D(m_device, texture->data.data(), texture->size));
}
for (int i = 0; i < StaticsTextures.size(); i++) {
TEXTURE* texture = &StaticsTextures[i];
for (int i = 0; i < StaticsTextures.size(); i++)
{
TEXTURE *texture = &StaticsTextures[i];
m_staticsTextures.push_back(Texture2D(m_device, texture->data.data(), texture->size));
}
for (int i = 0; i < SpritesTextures.size(); i++) {
TEXTURE* texture = &SpritesTextures[i];
for (int i = 0; i < SpritesTextures.size(); i++)
{
TEXTURE *texture = &SpritesTextures[i];
m_spritesTextures.push_back(Texture2D(m_device, texture->data.data(), texture->size));
}
m_skyTexture = Texture2D(m_device, MiscTextures.data.data(), MiscTextures.size);
// Step 2: prepare rooms
vector<RendererVertex> roomVertices;
vector<int> roomIndices;
@ -136,10 +140,10 @@ namespace T5M::Renderer {
for (int i = 0; i < Rooms.size(); i++)
{
ROOM_INFO* room = &Rooms[i];
ROOM_INFO *room = &Rooms[i];
m_rooms[i] = RendererRoom();
RendererRoom& r = m_rooms[i];
RendererRoom &r = m_rooms[i];
r.RoomNumber = i;
r.Room = room;
r.AmbientLight = Vector4(room->ambient.x, room->ambient.y, room->ambient.z, 1.0f);
@ -149,12 +153,12 @@ namespace T5M::Renderer {
if (room->vertices.size() == 0)
continue;
ROOM_VERTEX * vertices = room->vertices.data();
ROOM_VERTEX *vertices = room->vertices.data();
for (int n = 0; n < room->buckets.size(); n++)
{
BUCKET* levelBucket = &room->buckets[n];
RendererBucket* bucket;
BUCKET *levelBucket = &room->buckets[n];
RendererBucket *bucket;
int bucketIndex;
if (levelBucket->blendMode != 0)
@ -174,7 +178,7 @@ namespace T5M::Renderer {
for (int v = 0; v < levelBucket->indices.size(); v++)
{
int index = levelBucket->indices[v];
ROOM_VERTEX* levelVertex = &vertices[index];
ROOM_VERTEX *levelVertex = &vertices[index];
RendererVertex vertex;
@ -207,7 +211,7 @@ namespace T5M::Renderer {
for (int l = 0; l < room->lights.size(); l++)
{
RendererLight light;
ROOM_LIGHT* oldLight = &room->lights[l];
ROOM_LIGHT *oldLight = &room->lights[l];
if (oldLight->type == LIGHT_TYPES::LIGHT_TYPE_SUN)
{
@ -262,7 +266,7 @@ namespace T5M::Renderer {
// Merge vertices and indices in a single list
for (int j = 0; j < NUM_BUCKETS; j++)
{
RendererBucket* bucket = &r.Buckets[j];
RendererBucket *bucket = &r.Buckets[j];
bucket->StartVertex = baseRoomVertex;
bucket->StartIndex = baseRoomIndex;
@ -292,13 +296,15 @@ namespace T5M::Renderer {
int baseMoveablesIndex = 0;
// Step 3: prepare moveables
for (int i = 0; i < MoveablesIds.size(); i++) {
for (int i = 0; i < MoveablesIds.size(); i++)
{
int objNum = MoveablesIds[i];
ObjectInfo* obj = &Objects[objNum];
ObjectInfo *obj = &Objects[objNum];
if (obj->nmeshes > 0) {
if (obj->nmeshes > 0)
{
m_moveableObjects[MoveablesIds[i]] = RendererObject();
RendererObject& moveable = *m_moveableObjects[MoveablesIds[i]];
RendererObject &moveable = *m_moveableObjects[MoveablesIds[i]];
moveable.Id = MoveablesIds[i];
// Assign the draw routine
@ -311,99 +317,108 @@ namespace T5M::Renderer {
objNum == ID_CAMERA_TARGET || objNum == ID_WATERFALLMIST || objNum == ID_SMOKE_EMITTER_BLACK ||
objNum == ID_SMOKE_EMITTER_WHITE)
{
moveable->DoNotDraw = true;
moveable.DoNotDraw = true;
}
else
{
moveable->DoNotDraw = false;
moveable.DoNotDraw = false;
}*/
moveable.DoNotDraw = (obj->drawRoutine == NULL);
for (int j = 0; j < obj->nmeshes; j++) {
for (int j = 0; j < obj->nmeshes; j++)
{
// HACK: mesh pointer 0 is the placeholder for Lara's body parts and is right hand with pistols
// We need to override the bone index because the engine will take mesh 0 while drawing pistols anim,
// and vertices have bone index 0 and not 10
RendererMesh* mesh = getRendererMeshFromTrMesh(&moveable,
Meshes[obj->meshIndex + j],
RendererMesh *mesh = getRendererMeshFromTrMesh(&moveable,
&Meshes[obj->meshIndex + j],
j, MoveablesIds[i] == ID_LARA_SKIN_JOINTS,
MoveablesIds[i] == ID_LARA_HAIR);
moveable.ObjectMeshes.push_back(mesh);
}
if (objNum == ID_IMP_ROCK || objNum == ID_ENERGY_BUBBLES || objNum == ID_BUBBLES || objNum == ID_BODY_PART) {
if (objNum == ID_IMP_ROCK || objNum == ID_ENERGY_BUBBLES || objNum == ID_BUBBLES || objNum == ID_BODY_PART)
{
// HACK: these objects must have nmeshes = 0 because engine will use them in a different way while drawing Effects.
// In Core's code this was done in SETUP.C but we must do it here because we need to create renderer's meshes.
obj->nmeshes = 0;
}
else {
int* bone = &Bones[obj->boneIndex];
stack<RendererBone*> stack;
for (int j = 0; j < obj->nmeshes; j++) {
else
{
for (int j = 0; j < obj->nmeshes; j++)
{
moveable.LinearizedBones.push_back(new RendererBone(j));
moveable.AnimationTransforms.push_back(Matrix::Identity);
moveable.BindPoseTransforms.push_back(Matrix::Identity);
}
RendererBone* currentBone = moveable.LinearizedBones[0];
RendererBone* stackBone = moveable.LinearizedBones[0];
if (obj->nmeshes > 1)
{
int *bone = &Bones[obj->boneIndex];
for (int mi = 0; mi < obj->nmeshes - 1; mi++) {
int j = mi + 1;
stack<RendererBone *> stack;
int opcode = *(bone++);
int linkX = *(bone++);
int linkY = *(bone++);
int linkZ = *(bone++);
RendererBone *currentBone = moveable.LinearizedBones[0];
RendererBone *stackBone = moveable.LinearizedBones[0];
byte flags = opcode & 0x1C;
for (int mi = 0; mi < obj->nmeshes - 1; mi++)
{
int j = mi + 1;
moveable.LinearizedBones[j]->ExtraRotationFlags = flags;
int opcode = *(bone++);
int linkX = *(bone++);
int linkY = *(bone++);
int linkZ = *(bone++);
switch (opcode & 0x03) {
case 0:
moveable.LinearizedBones[j]->Parent = currentBone;
moveable.LinearizedBones[j]->Translation = Vector3(linkX, linkY, linkZ);
currentBone->Children.push_back(moveable.LinearizedBones[j]);
currentBone = moveable.LinearizedBones[j];
byte flags = opcode & 0x1C;
break;
case 1:
if (stack.empty())
continue;
currentBone = stack.top();
stack.pop();
moveable.LinearizedBones[j]->ExtraRotationFlags = flags;
moveable.LinearizedBones[j]->Parent = currentBone;
moveable.LinearizedBones[j]->Translation = Vector3(linkX, linkY, linkZ);
currentBone->Children.push_back(moveable.LinearizedBones[j]);
currentBone = moveable.LinearizedBones[j];
switch (opcode & 0x03)
{
case 0:
moveable.LinearizedBones[j]->Parent = currentBone;
moveable.LinearizedBones[j]->Translation = Vector3(linkX, linkY, linkZ);
currentBone->Children.push_back(moveable.LinearizedBones[j]);
currentBone = moveable.LinearizedBones[j];
break;
case 2:
stack.push(currentBone);
break;
case 1:
if (stack.empty())
continue;
currentBone = stack.top();
stack.pop();
moveable.LinearizedBones[j]->Translation = Vector3(linkX, linkY, linkZ);
moveable.LinearizedBones[j]->Parent = currentBone;
currentBone->Children.push_back(moveable.LinearizedBones[j]);
currentBone = moveable.LinearizedBones[j];
moveable.LinearizedBones[j]->Parent = currentBone;
moveable.LinearizedBones[j]->Translation = Vector3(linkX, linkY, linkZ);
currentBone->Children.push_back(moveable.LinearizedBones[j]);
currentBone = moveable.LinearizedBones[j];
break;
case 3:
if (stack.empty())
continue;
RendererBone* theBone = stack.top();
stack.pop();
break;
case 2:
stack.push(currentBone);
moveable.LinearizedBones[j]->Translation = Vector3(linkX, linkY, linkZ);
moveable.LinearizedBones[j]->Parent = theBone;
theBone->Children.push_back(moveable.LinearizedBones[j]);
currentBone = moveable.LinearizedBones[j];
stack.push(theBone);
moveable.LinearizedBones[j]->Translation = Vector3(linkX, linkY, linkZ);
moveable.LinearizedBones[j]->Parent = currentBone;
currentBone->Children.push_back(moveable.LinearizedBones[j]);
currentBone = moveable.LinearizedBones[j];
break;
break;
case 3:
if (stack.empty())
continue;
RendererBone *theBone = stack.top();
stack.pop();
moveable.LinearizedBones[j]->Translation = Vector3(linkX, linkY, linkZ);
moveable.LinearizedBones[j]->Parent = theBone;
theBone->Children.push_back(moveable.LinearizedBones[j]);
currentBone = moveable.LinearizedBones[j];
stack.push(theBone);
break;
}
}
}
@ -417,34 +432,41 @@ namespace T5M::Renderer {
buildHierarchy(&moveable);
// Fix Lara skin joints and hairs
if (MoveablesIds[i] == ID_LARA_SKIN_JOINTS) {
int bonesToCheck[2] = { 0,0 };
if (MoveablesIds[i] == ID_LARA_SKIN_JOINTS)
{
int BonesToCheck[2] = {0, 0};
RendererObject& objSkin = *m_moveableObjects[ID_LARA_SKIN];
RendererObject &objSkin = *m_moveableObjects[ID_LARA_SKIN];
for (int j = 1; j < obj->nmeshes; j++) {
RendererMesh* jointMesh = moveable.ObjectMeshes[j];
RendererBone* jointBone = moveable.LinearizedBones[j];
for (int j = 1; j < obj->nmeshes; j++)
{
RendererMesh *jointMesh = moveable.ObjectMeshes[j];
RendererBone *jointBone = moveable.LinearizedBones[j];
bonesToCheck[0] = jointBone->Parent->Index;
bonesToCheck[1] = j;
BonesToCheck[0] = jointBone->Parent->Index;
BonesToCheck[1] = j;
for (int b1 = 0; b1 < NUM_BUCKETS; b1++) {
RendererBucket* jointBucket = &jointMesh->Buckets[b1];
for (int b1 = 0; b1 < NUM_BUCKETS; b1++)
{
RendererBucket *jointBucket = &jointMesh->Buckets[b1];
for (int v1 = 0; v1 < jointBucket->Vertices.size(); v1++) {
RendererVertex* jointVertex = &jointBucket->Vertices[v1];
for (int v1 = 0; v1 < jointBucket->Vertices.size(); v1++)
{
RendererVertex *jointVertex = &jointBucket->Vertices[v1];
bool done = false;
for (int k = 0; k < 2; k++) {
RendererMesh* skinMesh = objSkin.ObjectMeshes[bonesToCheck[k]];
RendererBone* skinBone = objSkin.LinearizedBones[bonesToCheck[k]];
for (int k = 0; k < 2; k++)
{
RendererMesh *skinMesh = objSkin.ObjectMeshes[BonesToCheck[k]];
RendererBone *skinBone = objSkin.LinearizedBones[BonesToCheck[k]];
for (int b2 = 0; b2 < NUM_BUCKETS; b2++) {
RendererBucket* skinBucket = &skinMesh->Buckets[b2];
for (int v2 = 0; v2 < skinBucket->Vertices.size(); v2++) {
RendererVertex* skinVertex = &skinBucket->Vertices[v2];
for (int b2 = 0; b2 < NUM_BUCKETS; b2++)
{
RendererBucket *skinBucket = &skinMesh->Buckets[b2];
for (int v2 = 0; v2 < skinBucket->Vertices.size(); v2++)
{
RendererVertex *skinVertex = &skinBucket->Vertices[v2];
int x1 = jointBucket->Vertices[v1].Position.x + jointBone->GlobalTranslation.x;
int y1 = jointBucket->Vertices[v1].Position.y + jointBone->GlobalTranslation.y;
@ -454,12 +476,12 @@ namespace T5M::Renderer {
int y2 = skinBucket->Vertices[v2].Position.y + skinBone->GlobalTranslation.y;
int z2 = skinBucket->Vertices[v2].Position.z + skinBone->GlobalTranslation.z;
if (abs(x1 - x2) < 2 && abs(y1 - y2) < 2 && abs(z1 - z2) < 2) {
jointVertex->Bone = bonesToCheck[k];
jointVertex->Position.x = skinVertex->Position.x;
jointVertex->Position.y = skinVertex->Position.y;
jointVertex->Position.z = skinVertex->Position.z;
if (abs(x1 - x2) < 2 && abs(y1 - y2) < 2 && abs(z1 - z2) < 2)
{
jointVertex->Bone = BonesToCheck[k];
jointVertex->Position = skinVertex->Position;
jointVertex->Normal = skinVertex->Normal;
done = true;
break;
}
@ -477,12 +499,15 @@ namespace T5M::Renderer {
}
}
if (MoveablesIds[i] == ID_LARA_HAIR) {
for (int j = 0; j < moveable.ObjectMeshes.size(); j++) {
RendererMesh* mesh = moveable.ObjectMeshes[j];
for (int n = 0; n < NUM_BUCKETS; n++) {
if (MoveablesIds[i] == ID_LARA_HAIR)
{
for (int j = 0; j < moveable.ObjectMeshes.size(); j++)
{
RendererMesh *mesh = moveable.ObjectMeshes[j];
for (int n = 0; n < NUM_BUCKETS; n++)
{
m_numHairVertices += mesh->Buckets[n].NumVertices;
m_numHairIndices += mesh->Buckets[n].NumIndices;
m_numHairIndices += mesh->Buckets[n].Indices.size();
}
}
@ -497,13 +522,14 @@ namespace T5M::Renderer {
}
}
// Merge vertices and indices in a single list
for (int m = 0; m < moveable.ObjectMeshes.size(); m++) {
RendererMesh* msh = moveable.ObjectMeshes[m];
for (int m = 0; m < moveable.ObjectMeshes.size(); m++)
{
RendererMesh *msh = moveable.ObjectMeshes[m];
for (int j = 0; j < NUM_BUCKETS; j++) {
RendererBucket* bucket = &msh->Buckets[j];
for (int j = 0; j < NUM_BUCKETS; j++)
{
RendererBucket *bucket = &msh->Buckets[j];
bucket->StartVertex = baseMoveablesVertex;
bucket->StartIndex = baseMoveablesIndex;
@ -531,24 +557,25 @@ namespace T5M::Renderer {
int baseStaticsVertex = 0;
int baseStaticsIndex = 0;
for (int i = 0; i < StaticObjectsIds.size(); i++) {
StaticInfo* obj = &StaticObjects[StaticObjectsIds[i]];
for (int i = 0; i < StaticObjectsIds.size(); i++)
{
StaticInfo *obj = &StaticObjects[StaticObjectsIds[i]];
m_staticObjects[StaticObjectsIds[i]] = RendererObject();
RendererObject& staticObject = *m_staticObjects[StaticObjectsIds[i]];
RendererObject &staticObject = *m_staticObjects[StaticObjectsIds[i]];
staticObject.Id = StaticObjectsIds[i];
short* meshPtr = Meshes[obj->meshNumber];
RendererMesh* mesh = getRendererMeshFromTrMesh(&staticObject, Meshes[obj->meshNumber], 0, false, false);
RendererMesh *mesh = getRendererMeshFromTrMesh(&staticObject, &Meshes[obj->meshNumber], 0, false, false);
staticObject.ObjectMeshes.push_back(mesh);
m_staticObjects[StaticObjectsIds[i]] = staticObject;
// Merge vertices and indices in a single list
RendererMesh* msh = staticObject.ObjectMeshes[0];
RendererMesh *msh = staticObject.ObjectMeshes[0];
for (int j = 0; j < NUM_BUCKETS; j++) {
RendererBucket* bucket = &msh->Buckets[j];
for (int j = 0; j < NUM_BUCKETS; j++)
{
RendererBucket *bucket = &msh->Buckets[j];
bucket->StartVertex = baseStaticsVertex;
bucket->StartIndex = baseStaticsIndex;
@ -571,30 +598,32 @@ namespace T5M::Renderer {
// Step 5: prepare sprites
m_sprites.resize(g_NumSprites);
for (int i = 0; i < g_NumSprites; i++) {
SPRITE* oldSprite = &Sprites[i];
for (int i = 0; i < g_NumSprites; i++)
{
SPRITE *oldSprite = &Sprites[i];
m_sprites[i] = RendererSprite();
RendererSprite& sprite = m_sprites[i];
RendererSprite &sprite = m_sprites[i];
sprite.UV[0] = Vector2(oldSprite->x1, oldSprite->y1);
sprite.UV[1] = Vector2(oldSprite->x2, oldSprite->y2);
sprite.UV[2] = Vector2(oldSprite->x3, oldSprite->y3);
sprite.UV[3] = Vector2(oldSprite->x4, oldSprite->y4);
sprite.Texture = &m_spritesTextures[oldSprite->tile];
}
for (int i = 0; i < MoveablesIds.size(); i++) {
ObjectInfo* obj = &Objects[MoveablesIds[i]];
if (obj->nmeshes < 0) {
for (int i = 0; i < MoveablesIds.size(); i++)
{
ObjectInfo *obj = &Objects[MoveablesIds[i]];
if (obj->nmeshes < 0)
{
short numSprites = abs(obj->nmeshes);
short baseSprite = obj->meshIndex;
m_spriteSequences[MoveablesIds[i]] = RendererSpriteSequence(MoveablesIds[i], numSprites);
RendererSpriteSequence& sequence = m_spriteSequences[MoveablesIds[i]];
RendererSpriteSequence &sequence = m_spriteSequences[MoveablesIds[i]];
for (int j = baseSprite; j < baseSprite + numSprites; j++) {
for (int j = baseSprite; j < baseSprite + numSprites; j++)
{
sequence.SpritesList[j - baseSprite] = &m_sprites[j];
}
@ -602,10 +631,12 @@ namespace T5M::Renderer {
}
}
for (int i = 0; i < 6; i++) {
if (Objects[ID_WATERFALL1 + i].loaded) {
for (int i = 0; i < 6; i++)
{
if (Objects[ID_WATERFALL1 + i].loaded)
{
// Get the first textured bucket
RendererBucket* bucket = NULL;
RendererBucket *bucket = NULL;
for (int j = 0; j < NUM_BUCKETS; j++)
if (m_moveableObjects[ID_WATERFALL1 + i]->ObjectMeshes[0]->Buckets[j].Polygons.size() > 0)
bucket = &m_moveableObjects[ID_WATERFALL1 + i]->ObjectMeshes[0]->Buckets[j];
@ -613,7 +644,7 @@ namespace T5M::Renderer {
if (bucket == NULL)
continue;
OBJECT_TEXTURE * texture = &ObjectTextures[bucket->Polygons[0].TextureId];
OBJECT_TEXTURE *texture = &ObjectTextures[bucket->Polygons[0].TextureId];
WaterfallTextures[i] = texture;
WaterfallY[i] = texture->vertices[0].y;
}
@ -621,4 +652,4 @@ namespace T5M::Renderer {
return true;
}
}
} // namespace T5M::Renderer

777
TR5Main/Renderer/Renderer11Draw.cpp
View file

File diff suppressed because it is too large Load diff

8
TR5Main/Renderer/Renderer11DrawEffect.cpp
View file

@ -558,7 +558,7 @@ namespace T5M::Renderer {
updateConstantBuffer<CItemBuffer>(m_cbItem, m_stItem);
m_context->VSSetConstantBuffers(1, 1, &m_cbItem);
m_context->DrawIndexed(flashBucket->NumIndices, flashBucket->StartIndex, 0);
m_context->DrawIndexed(flashBucket->Indices.size(), flashBucket->StartIndex, 0);
m_numDrawCalls++;
}
@ -571,7 +571,7 @@ namespace T5M::Renderer {
updateConstantBuffer<CItemBuffer>(m_cbItem, m_stItem);
m_context->VSSetConstantBuffers(1, 1, &m_cbItem);
m_context->DrawIndexed(flashBucket->NumIndices, flashBucket->StartIndex, 0);
m_context->DrawIndexed(flashBucket->Indices.size(), flashBucket->StartIndex, 0);
m_numDrawCalls++;
}
}
@ -646,7 +646,7 @@ namespace T5M::Renderer {
updateConstantBuffer<CItemBuffer>(m_cbItem, m_stItem);
m_context->VSSetConstantBuffers(1, 1, &m_cbItem);
m_context->DrawIndexed(flashBucket->NumIndices, flashBucket->StartIndex, 0);
m_context->DrawIndexed(flashBucket->Indices.size(), flashBucket->StartIndex, 0);
m_numDrawCalls++;
}
}
@ -909,7 +909,7 @@ namespace T5M::Renderer {
continue;
// Draw vertices
m_context->DrawIndexed(bucket->NumIndices, bucket->StartIndex, 0);
m_context->DrawIndexed(bucket->Indices.size(), bucket->StartIndex, 0);
m_numDrawCalls++;
}

231
TR5Main/Renderer/Renderer11Frame.cpp
View file

@ -7,35 +7,41 @@
#include "level.h"
#include "setup.h"
#include "RenderView\RenderView.h"
namespace T5M::Renderer {
namespace T5M::Renderer
{
using namespace T5M::Renderer;
using std::vector;
void Renderer11::collectRooms(RenderView& renderView) {
void Renderer11::collectRooms(RenderView &renderView)
{
short baseRoomIndex = renderView.camera.RoomNumber;
for (int i = 0; i < Rooms.size(); i++) {
for (int i = 0; i < Rooms.size(); i++)
{
m_rooms[i].Visited = false;
}
Vector4 vp = Vector4(-1.0f, -1.0f, 1.0f, 1.0f);
vector<RendererRoom*> collectedRooms;
vector<RendererRoom *> collectedRooms;
collectedRooms.reserve(128);
getVisibleObjects(-1, baseRoomIndex, &vp, false, 0,renderView);
getVisibleObjects(-1, baseRoomIndex, &vp, false, 0, renderView);
}
void Renderer11::collectItems(short roomNumber,RenderView& renderView) {
if (m_rooms.size() <= roomNumber) {
void Renderer11::collectItems(short roomNumber, RenderView &renderView)
{
if (m_rooms.size() <= roomNumber)
{
return;
}
RendererRoom& const room = m_rooms[roomNumber];
RendererRoom &const room = m_rooms[roomNumber];
ROOM_INFO* r = room.Room;
ROOM_INFO *r = room.Room;
short itemNum = NO_ITEM;
for (itemNum = r->itemNumber; itemNum != NO_ITEM; itemNum = Items[itemNum].nextItem) {
for (itemNum = r->itemNumber; itemNum != NO_ITEM; itemNum = Items[itemNum].nextItem)
{
//printf("ItemNum: %d, NextItem: %d\n", itemNum, Items[itemNum].nextItem);
ITEM_INFO* item = &Items[itemNum];
ITEM_INFO *item = &Items[itemNum];
if (item->objectNumber == ID_LARA && itemNum == Items[itemNum].nextItem)
break;
@ -48,8 +54,8 @@ namespace T5M::Renderer {
if (!m_moveableObjects[item->objectNumber].has_value())
continue;
RendererItem* newItem = &m_items[itemNum];
short* bounds = GetBoundsAccurate(item);
RendererItem *newItem = &m_items[itemNum];
short *bounds = GetBoundsAccurate(item);
Vector3 min = (Vector3(bounds[0], bounds[2], bounds[4])) + Vector3(item->pos.xPos, item->pos.yPos, item->pos.zPos);
Vector3 max = (Vector3(bounds[1], bounds[3], bounds[5])) + Vector3(item->pos.xPos, item->pos.yPos, item->pos.zPos);
if (!renderView.camera.frustum.AABBInFrustum(min, max))
@ -63,24 +69,27 @@ namespace T5M::Renderer {
TO_RAD(item->pos.zRot));
newItem->Scale = Matrix::CreateScale(1.0f);
newItem->World = newItem->Rotation * newItem->Translation;
collectLightsForItem(item->roomNumber, newItem,renderView);
collectLightsForItem(item->roomNumber, newItem, renderView);
renderView.itemsToDraw.push_back(newItem);
}
}
void Renderer11::collectStatics(short roomNumber, RenderView& renderView) {
if (m_rooms.size() <= roomNumber) {
void Renderer11::collectStatics(short roomNumber, RenderView &renderView)
{
if (m_rooms.size() <= roomNumber)
{
return;
}
RendererRoom& const room = m_rooms[roomNumber];
ROOM_INFO* r = room.Room;
RendererRoom &const room = m_rooms[roomNumber];
ROOM_INFO *r = room.Room;
if (r->mesh.size() <= 0)
return;
int numStatics = r->mesh.size();
for (int i = 0; i < numStatics; i++) {
MESH_INFO* mesh = &r->mesh[i];
RendererStatic* newStatic = &room.Statics[i];
StaticInfo* staticInfo = &StaticObjects[mesh->staticNumber];
for (int i = 0; i < numStatics; i++)
{
MESH_INFO *mesh = &r->mesh[i];
RendererStatic *newStatic = &room.Statics[i];
StaticInfo *staticInfo = &StaticObjects[mesh->staticNumber];
Vector3 min = Vector3(staticInfo->xMinc, staticInfo->yMinc, staticInfo->zMinc);
Vector3 max = Vector3(staticInfo->xMaxc, staticInfo->yMaxc, staticInfo->zMaxc);
min += Vector3(mesh->x, mesh->y, mesh->z);
@ -96,14 +105,16 @@ namespace T5M::Renderer {
}
}
void Renderer11::collectLightsForEffect(short roomNumber, RendererEffect* effect, RenderView& renderView) {
void Renderer11::collectLightsForEffect(short roomNumber, RendererEffect *effect, RenderView &renderView)
{
effect->Lights.clear();
if (m_rooms.size() <= roomNumber) {
if (m_rooms.size() <= roomNumber)
{
return;
}
RendererRoom& const room = m_rooms[roomNumber];
RendererRoom &const room = m_rooms[roomNumber];
ROOM_INFO* r = room.Room;
ROOM_INFO *r = room.Room;
if (r->lights.size() <= 0)
return;
@ -113,8 +124,9 @@ namespace T5M::Renderer {
Vector3 itemPosition = Vector3(effect->Effect->pos.xPos, effect->Effect->pos.yPos, effect->Effect->pos.zPos);
// Dynamic lights have the priority
for (int i = 0; i < m_dynamicLights.size(); i++) {
RendererLight* light = m_dynamicLights[i];
for (int i = 0; i < m_dynamicLights.size(); i++)
{
RendererLight *light = m_dynamicLights[i];
Vector3 lightPosition = Vector3(light->Position.x, light->Position.y, light->Position.z);
@ -128,16 +140,20 @@ namespace T5M::Renderer {
int numLights = room.Lights.size();
m_shadowLight = NULL;
RendererLight* brightestLight = NULL;
RendererLight *brightestLight = NULL;
float brightest = 0.0f;
for (int j = 0; j < numLights; j++) {
RendererLight* light = &room.Lights[j];
for (int j = 0; j < numLights; j++)
{
RendererLight *light = &room.Lights[j];
// Check only lights different from sun
if (light->Type == LIGHT_TYPE_SUN) {
if (light->Type == LIGHT_TYPE_SUN)
{
// Sun is added without checks
} else if (light->Type == LIGHT_TYPE_POINT || light->Type == LIGHT_TYPE_SHADOW) {
}
else if (light->Type == LIGHT_TYPE_POINT || light->Type == LIGHT_TYPE_SHADOW)
{
Vector3 lightPosition = Vector3(light->Position.x, light->Position.y, light->Position.z);
float distance = (itemPosition - lightPosition).Length();
@ -151,16 +167,20 @@ namespace T5M::Renderer {
continue;
// If Lara, try to collect shadow casting light
if (effect->Effect->objectNumber == ID_LARA) {
if (effect->Effect->objectNumber == ID_LARA)
{
float attenuation = 1.0f - distance / light->Out;
float intensity = max(0.0f, attenuation * (light->Color.x + light->Color.y + light->Color.z) / 3.0f);
if (intensity >= brightest) {
if (intensity >= brightest)
{
brightest = intensity;
brightestLight = light;
}
}
} else if (light->Type == LIGHT_TYPE_SPOT) {
}
else if (light->Type == LIGHT_TYPE_SPOT)
{
Vector3 lightPosition = Vector3(light->Position.x, light->Position.y, light->Position.z);
float distance = (itemPosition - lightPosition).Length();
@ -172,7 +192,9 @@ namespace T5M::Renderer {
// Check the range
if (distance > light->Range)
continue;
} else {
}
else
{
// Invalid light type
continue;
}
@ -180,19 +202,22 @@ namespace T5M::Renderer {
m_tempItemLights.push_back(light);
}
for (int i = 0; i < min(MAX_LIGHTS_PER_ITEM, m_tempItemLights.size()); i++) {
for (int i = 0; i < min(MAX_LIGHTS_PER_ITEM, m_tempItemLights.size()); i++)
{
renderView.lightsToDraw.push_back(m_tempItemLights[i]);
}
}
void Renderer11::collectLightsForItem(short roomNumber, RendererItem* item,RenderView& renderView) {
void Renderer11::collectLightsForItem(short roomNumber, RendererItem *item, RenderView &renderView)
{
item->Lights.clear();
if (m_rooms.size() <= roomNumber) {
if (m_rooms.size() <= roomNumber)
{
return;
}
RendererRoom& const room = m_rooms[roomNumber];
RendererRoom &const room = m_rooms[roomNumber];
ROOM_INFO* r = room.Room;
ROOM_INFO *r = room.Room;
if (r->lights.size() <= 0)
return;
@ -202,8 +227,9 @@ namespace T5M::Renderer {
Vector3 itemPosition = Vector3(item->Item->pos.xPos, item->Item->pos.yPos, item->Item->pos.zPos);
// Dynamic lights have the priority
for (int i = 0; i < m_dynamicLights.size(); i++) {
RendererLight* light = m_dynamicLights[i];
for (int i = 0; i < m_dynamicLights.size(); i++)
{
RendererLight *light = m_dynamicLights[i];
Vector3 lightPosition = Vector3(light->Position.x, light->Position.y, light->Position.z);
@ -217,16 +243,20 @@ namespace T5M::Renderer {
int numLights = room.Lights.size();
m_shadowLight = NULL;
RendererLight* brightestLight = NULL;
RendererLight *brightestLight = NULL;
float brightest = 0.0f;
for (int j = 0; j < numLights; j++) {
RendererLight* light = &room.Lights[j];
for (int j = 0; j < numLights; j++)
{
RendererLight *light = &room.Lights[j];
// Check only lights different from sun
if (light->Type == LIGHT_TYPE_SUN) {
if (light->Type == LIGHT_TYPE_SUN)
{
// Sun is added without checks
} else if (light->Type == LIGHT_TYPE_POINT || light->Type == LIGHT_TYPE_SHADOW) {
}
else if (light->Type == LIGHT_TYPE_POINT || light->Type == LIGHT_TYPE_SHADOW)
{
Vector3 lightPosition = Vector3(light->Position.x, light->Position.y, light->Position.z);
float distance = (itemPosition - lightPosition).Length();
@ -240,16 +270,20 @@ namespace T5M::Renderer {
continue;
// If Lara, try to collect shadow casting light
if (item->Item->objectNumber == ID_LARA) {
if (item->Item->objectNumber == ID_LARA)
{
float attenuation = 1.0f - distance / light->Out;
float intensity = max(0.0f, attenuation * (light->Color.x + light->Color.y + light->Color.z) / 3.0f);
if (intensity >= brightest) {
if (intensity >= brightest)
{
brightest = intensity;
brightestLight = light;
}
}
} else if (light->Type == LIGHT_TYPE_SPOT) {
}
else if (light->Type == LIGHT_TYPE_SPOT)
{
Vector3 lightPosition = Vector3(light->Position.x, light->Position.y, light->Position.z);
float distance = (itemPosition - lightPosition).Length();
@ -263,16 +297,20 @@ namespace T5M::Renderer {
continue;
// If Lara, try to collect shadow casting light
if (item->Item->objectNumber == ID_LARA) {
if (item->Item->objectNumber == ID_LARA)
{
float attenuation = 1.0f - distance / light->Range;
float intensity = max(0.0f, attenuation * (light->Color.x + light->Color.y + light->Color.z) / 3.0f);
if (intensity >= brightest) {
if (intensity >= brightest)
{
brightest = intensity;
brightestLight = light;
}
}
} else {
}
else
{
// Invalid light type
continue;
}
@ -280,27 +318,32 @@ namespace T5M::Renderer {
m_tempItemLights.push_back(light);
}
for (int i = 0; i < min(MAX_LIGHTS_PER_ITEM, m_tempItemLights.size()); i++) {
for (int i = 0; i < min(MAX_LIGHTS_PER_ITEM, m_tempItemLights.size()); i++)
{
item->Lights.push_back(m_tempItemLights[i]);
}
if (item->Item->objectNumber == ID_LARA) {
if (item->Item->objectNumber == ID_LARA)
{
m_shadowLight = brightestLight;
}
}
void Renderer11::collectLightsForRoom(short roomNumber,RenderView& renderView) {
if (m_rooms.size() <= roomNumber) {
void Renderer11::collectLightsForRoom(short roomNumber, RenderView &renderView)
{
if (m_rooms.size() <= roomNumber)
{
return;
}
RendererRoom& const room = m_rooms[roomNumber];
ROOM_INFO* r = &Rooms[roomNumber];
RendererRoom &const room = m_rooms[roomNumber];
ROOM_INFO *r = &Rooms[roomNumber];
int numLights = room.Lights.size();
// Collect dynamic lights for rooms
for (int i = 0; i < m_dynamicLights.size(); i++) {
RendererLight* light = m_dynamicLights[i];
for (int i = 0; i < m_dynamicLights.size(); i++)
{
RendererLight *light = m_dynamicLights[i];
Vector3 boxMin = Vector3(r->x - WALL_SIZE, -r->minfloor, r->z - WALL_SIZE);
Vector3 boxMax = Vector3(r->x + r->xSize * WALL_SIZE, -r->maxceiling, r->z + r->ySize * WALL_SIZE);
@ -311,7 +354,8 @@ namespace T5M::Renderer {
}
}
void Renderer11::prepareLights() {
void Renderer11::prepareLights()
{
// Add dynamic lights
for (int i = 0; i < m_dynamicLights.size(); i++)
m_lightsToDraw.push_back(m_dynamicLights[i]);
@ -325,16 +369,18 @@ namespace T5M::Renderer {
// m_lightsToDraw.resize(32);
// Now try to search for a shadow caster, using Lara as reference
RendererRoom& const room = m_rooms[LaraItem->roomNumber];
RendererRoom &const room = m_rooms[LaraItem->roomNumber];
// Search for the brightest light. We do a simple version of the classic calculation done in pixel shader.
RendererLight* brightestLight = NULL;
RendererLight *brightestLight = NULL;
float brightest = 0.0f;
// Try room lights
if (room.Lights.size() != 0) {
for (int j = 0; j < room.Lights.size(); j++) {
RendererLight* light = &room.Lights[j];
if (room.Lights.size() != 0)
{
for (int j = 0; j < room.Lights.size(); j++)
{
RendererLight *light = &room.Lights[j];
Vector4 itemPos = Vector4(LaraItem->pos.xPos, LaraItem->pos.yPos, LaraItem->pos.zPos, 1.0f);
Vector4 lightVector = itemPos - light->Position;
@ -349,7 +395,8 @@ namespace T5M::Renderer {
float attenuationRange;
float attenuationAngle;
switch ((int)light->Type) {
switch ((int)light->Type)
{
case LIGHT_TYPES::LIGHT_TYPE_POINT:
if (distance > light->Out || light->Out < 2048.0f)
continue;
@ -357,21 +404,23 @@ namespace T5M::Renderer {
attenuation = 1.0f - distance / light->Out;
intensity = max(0.0f, attenuation * (light->Color.x + light->Color.y + light->Color.z) / 3.0f);
if (intensity >= brightest) {
if (intensity >= brightest)
{
brightest = intensity;
brightestLight = light;
}
break;
case LIGHT_TYPES::LIGHT_TYPE_SPOT:
case LIGHT_TYPES::LIGHT_TYPE_SPOT:
if (distance > light->Range)
continue;
attenuation = 1.0f - distance / light->Range;
intensity = max(0.0f, attenuation * (light->Color.x + light->Color.y + light->Color.z) / 3.0f);
if (intensity >= brightest) {
if (intensity >= brightest)
{
brightest = intensity;
brightestLight = light;
}
@ -385,40 +434,42 @@ namespace T5M::Renderer {
m_shadowLight = brightestLight;
}
void Renderer11::collectEffects(short roomNumber,RenderView& renderView) {
if (m_rooms.size() <= roomNumber) return;
RendererRoom& const room = m_rooms[roomNumber];
void Renderer11::collectEffects(short roomNumber, RenderView &renderView)
{
if (m_rooms.size() <= roomNumber)
return;
RendererRoom &const room = m_rooms[roomNumber];
ROOM_INFO* r = room.Room;
ROOM_INFO *r = room.Room;
short fxNum = NO_ITEM;
for (fxNum = r->fxNumber; fxNum != NO_ITEM; fxNum = EffectList[fxNum].nextFx) {
FX_INFO* fx = &EffectList[fxNum];
for (fxNum = r->fxNumber; fxNum != NO_ITEM; fxNum = EffectList[fxNum].nextFx)
{
FX_INFO *fx = &EffectList[fxNum];
if (fx->objectNumber < 0)
continue;
ObjectInfo* obj = &Objects[fx->objectNumber];
ObjectInfo *obj = &Objects[fx->objectNumber];
RendererEffect* newEffect = &m_effects[fxNum];
RendererEffect *newEffect = &m_effects[fxNum];
newEffect->Effect = fx;
newEffect->Id = fxNum;
newEffect->World = Matrix::CreateFromYawPitchRoll(fx->pos.yRot, fx->pos.xPos, fx->pos.zPos) * Matrix::CreateTranslation(fx->pos.xPos, fx->pos.yPos, fx->pos.zPos);
newEffect->Mesh = m_meshPointersToMesh[reinterpret_cast<unsigned int>(Meshes[(obj->nmeshes ? obj->meshIndex : fx->frameNumber)])];
newEffect->Mesh = getMesh(obj->nmeshes ? obj->meshIndex : fx->frameNumber);
collectLightsForEffect(fx->roomNumber, newEffect,renderView);
collectLightsForEffect(fx->roomNumber, newEffect, renderView);
renderView.effectsToDraw.push_back(newEffect);
short* mp = Meshes[(obj->nmeshes ? obj->meshIndex : fx->frameNumber)];
short hhh = 0;
m_effectsToDraw.push_back(newEffect);
}
}
void Renderer11::ResetAnimations() {
for (int i = 0; i < NUM_ITEMS; i++) {
void Renderer11::ResetAnimations()
{
for (int i = 0; i < NUM_ITEMS; i++)
{
m_items[i].DoneAnimations = false;
}
}
}
} // namespace T5M::Renderer

3
TR5Main/Renderer/Renderer11Init.cpp
View file

@ -81,7 +81,8 @@ bool Renderer11::Initialise(int w, int h, int refreshRate, bool windowed, HWND h
{"NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 32, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"BLENDINDICES", 0, DXGI_FORMAT_R32_FLOAT, 0, 48, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"BLENDINDICES", 0, DXGI_FORMAT_R32_FLOAT, 0, 48, D3D11_INPUT_PER_VERTEX_DATA, 0}/*,
{"TEXCOORD", 1, DXGI_FORMAT_R32_UINT, 0, 52, D3D11_INPUT_PER_VERTEX_DATA, 0},*/
};
m_inputLayout = NULL;

56
TR5Main/Renderer/Renderer11Lara.cpp
View file

@ -11,7 +11,7 @@
#include "GameFlowScript.h"
using namespace T5M::Renderer;
extern GameFlow* g_GameFlow;
extern GameFlow *g_GameFlow;
void Renderer11::UpdateLaraAnimations(bool force)
{
@ -22,14 +22,14 @@ void Renderer11::UpdateLaraAnimations(bool force)
Matrix identity;
Matrix world;
RendererItem* item = &m_items[Lara.itemNumber];
RendererItem *item = &m_items[Lara.itemNumber];
item->Id = Lara.itemNumber;
item->Item = LaraItem;
if (!force && item->DoneAnimations)
return;
RendererObject& laraObj = *m_moveableObjects[ID_LARA];
RendererObject &laraObj = *m_moveableObjects[ID_LARA];
// Clear extra rotations
for (int i = 0; i < laraObj.LinearizedBones.size(); i++)
@ -48,7 +48,7 @@ void Renderer11::UpdateLaraAnimations(bool force)
// First calculate matrices for legs, hips, head and torso
int mask = MESH_BITS(LM_HIPS) | MESH_BITS(LM_LTHIGH) | MESH_BITS(LM_LSHIN) | MESH_BITS(LM_LFOOT) | MESH_BITS(LM_RTHIGH) | MESH_BITS(LM_RSHIN) | MESH_BITS(LM_RFOOT) | MESH_BITS(LM_TORSO) | MESH_BITS(LM_HEAD);
short* framePtr[2];
short *framePtr[2];
int rate, frac;
frac = GetFrame_D2(LaraItem, framePtr, &rate);
@ -68,8 +68,8 @@ void Renderer11::UpdateLaraAnimations(bool force)
laraObj.LinearizedBones[LM_LINARM]->ExtraRotation += Vector3(TO_RAD(Lara.leftArm.xRot), TO_RAD(Lara.leftArm.zRot), TO_RAD(-Lara.leftArm.yRot));
laraObj.LinearizedBones[LM_RINARM]->ExtraRotation += Vector3(TO_RAD(Lara.rightArm.xRot), TO_RAD(Lara.rightArm.zRot), TO_RAD(-Lara.rightArm.yRot));
LARA_ARM * leftArm = &Lara.leftArm;
LARA_ARM * rightArm = &Lara.rightArm;
LARA_ARM *leftArm = &Lara.leftArm;
LARA_ARM *rightArm = &Lara.rightArm;
// HACK: backguns handles differently // TokyoSU: not really a hack since it's the original way to do that.
switch (Lara.gunType)
@ -79,7 +79,7 @@ void Renderer11::UpdateLaraAnimations(bool force)
case WEAPON_CROSSBOW:
case WEAPON_GRENADE_LAUNCHER:
case WEAPON_HARPOON_GUN:
short* shotgunFramePtr;
short *shotgunFramePtr;
// Left arm
mask = MESH_BITS(LM_LINARM) | MESH_BITS(LM_LOUTARM) | MESH_BITS(LM_LHAND);
@ -97,7 +97,7 @@ void Renderer11::UpdateLaraAnimations(bool force)
case WEAPON_REVOLVER:
default:
{
short* pistolFramePtr;
short *pistolFramePtr;
// Left arm
int upperArmMask = MESH_BITS(LM_LINARM);
@ -136,7 +136,9 @@ void Renderer11::UpdateLaraAnimations(bool force)
laraObj.AnimationTransforms[m] = item->AnimationTransforms[m];
// At this point, Lara's matrices are ready. Now let's do ponytails...
if (m_moveableObjects[ID_LARA_HAIR].has_value())
// TODO: disabled for now
/*
if (m_moveableObjects[ID_LARA_HAIR] != NULL)
{
RendererObject& hairsObj = *m_moveableObjects[ID_LARA_HAIR];
@ -262,7 +264,7 @@ void Renderer11::UpdateLaraAnimations(bool force)
}
}
}
}
}*/
m_items[Lara.itemNumber].DoneAnimations = true;
}
@ -284,7 +286,7 @@ bool Renderer11::drawLara(bool transparent, bool shadowMap)
m_context->IASetInputLayout(m_inputLayout);
m_context->IASetIndexBuffer(m_moveablesIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
RendererItem * item = &m_items[Lara.itemNumber];
RendererItem *item = &m_items[Lara.itemNumber];
// Set shaders
if (shadowMap)
@ -301,16 +303,16 @@ bool Renderer11::drawLara(bool transparent, bool shadowMap)
// Set texture
m_context->PSSetShaderResources(0, 1, m_moveablesTextures[0].ShaderResourceView.GetAddressOf());
m_context->PSSetShaderResources(1, 1, m_reflectionCubemap.ShaderResourceView.GetAddressOf());
ID3D11SamplerState* sampler = m_states->AnisotropicClamp();
ID3D11SamplerState *sampler = m_states->AnisotropicClamp();
m_context->PSSetSamplers(0, 1, &sampler);
m_stMisc.AlphaTest = !transparent;
updateConstantBuffer<CMiscBuffer>(m_cbMisc, m_stMisc);
m_context->PSSetConstantBuffers(3, 1, &m_cbMisc);
RendererObject& laraObj = *m_moveableObjects[ID_LARA];
RendererObject& laraSkin = *m_moveableObjects[ID_LARA_SKIN];
RendererRoom& const room = m_rooms[LaraItem->roomNumber];
RendererObject &laraObj = *m_moveableObjects[ID_LARA];
RendererObject &laraSkin = *m_moveableObjects[ID_LARA_SKIN];
RendererRoom &const room = m_rooms[LaraItem->roomNumber];
m_stItem.World = m_LaraWorldMatrix;
m_stItem.Position = Vector4(LaraItem->pos.xPos, LaraItem->pos.yPos, LaraItem->pos.zPos, 1.0f);
@ -331,38 +333,38 @@ bool Renderer11::drawLara(bool transparent, bool shadowMap)
for (int k = 0; k < laraSkin.ObjectMeshes.size(); k++)
{
RendererMesh* mesh = m_meshPointersToMesh[reinterpret_cast<unsigned int>(Lara.meshPtrs[k])];
RendererMesh *mesh = getMesh(Lara.meshPtrs[k]);
for (int j = firstBucket; j < lastBucket; j++)
{
RendererBucket* bucket = &mesh->Buckets[j];
RendererBucket *bucket = &mesh->Buckets[j];
if (bucket->Vertices.size() == 0)
continue;
// Draw vertices
m_context->DrawIndexed(bucket->NumIndices, bucket->StartIndex, 0);
m_context->DrawIndexed(bucket->Indices.size(), bucket->StartIndex, 0);
m_numDrawCalls++;
}
}
if (m_moveableObjects[ID_LARA_SKIN_JOINTS].has_value())
{
RendererObject& laraSkinJoints = *m_moveableObjects[ID_LARA_SKIN_JOINTS];
RendererObject &laraSkinJoints = *m_moveableObjects[ID_LARA_SKIN_JOINTS];
for (int k = 0; k < laraSkinJoints.ObjectMeshes.size(); k++)
{
RendererMesh* mesh = laraSkinJoints.ObjectMeshes[k];
RendererMesh *mesh = laraSkinJoints.ObjectMeshes[k];
for (int j = firstBucket; j < lastBucket; j++)
{
RendererBucket* bucket = &mesh->Buckets[j];
RendererBucket *bucket = &mesh->Buckets[j];
if (bucket->Vertices.size() == 0)
continue;
// Draw vertices
m_context->DrawIndexed(bucket->NumIndices, bucket->StartIndex, 0);
m_context->DrawIndexed(bucket->Indices.size(), bucket->StartIndex, 0);
m_numDrawCalls++;
}
}
@ -370,7 +372,7 @@ bool Renderer11::drawLara(bool transparent, bool shadowMap)
if (!transparent)
{
for (int k = 0; k < laraSkin.ObjectMeshes.size(); k++)
/*for (int k = 0; k < laraSkin->ObjectMeshes.size(); k++)
{
RendererMesh* mesh = laraSkin.ObjectMeshes[k];
@ -382,13 +384,13 @@ bool Renderer11::drawLara(bool transparent, bool shadowMap)
continue;
// Draw vertices
m_context->DrawIndexed(bucket->NumIndices, bucket->StartIndex, 0);
m_context->DrawIndexed(bucket->Indices.size(), bucket->StartIndex, 0);
m_numDrawCalls++;
}
}
}*/
// Hairs are pre-transformed
Matrix matrices[8] = { Matrix::Identity, Matrix::Identity, Matrix::Identity, Matrix::Identity,
/*Matrix matrices[8] = { Matrix::Identity, Matrix::Identity, Matrix::Identity, Matrix::Identity,
Matrix::Identity, Matrix::Identity, Matrix::Identity, Matrix::Identity };
memcpy(m_stItem.BonesMatrices, matrices, sizeof(Matrix) * 8);
m_stItem.World = Matrix::Identity;
@ -399,7 +401,7 @@ bool Renderer11::drawLara(bool transparent, bool shadowMap)
m_primitiveBatch->Begin();
m_primitiveBatch->DrawIndexed(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, (const uint16_t*)m_hairIndices.data(), m_numHairIndices, m_hairVertices.data(), m_numHairVertices);
m_primitiveBatch->End();
}
}*/
}
return true;

109
TR5Main/Specific/level.cpp
View file

@ -12,11 +12,12 @@
#include "door.h"
#include "box.h"
#include "sound.h"
#include "levelloader.h"
#include "GameFlowScript.h"
using T5M::Renderer::g_Renderer;
using std::vector;
using std::string;
ChunkId* ChunkTriggersList = ChunkId::FromString("Tr5Triggers");
ChunkId* ChunkTrigger = ChunkId::FromString("Tr5Trigger");
ChunkId* ChunkLuaIds = ChunkId::FromString("Tr5LuaIds");
@ -24,17 +25,13 @@ ChunkId* ChunkLuaId = ChunkId::FromString("Tr5LuaId");
extern GameScript* g_GameScript;
short* RawMeshData;
int MeshDataSize;
int* MeshTrees;
int* RawMeshPointers;
std::vector<int> Bones;
std::vector<MESH> Meshes;
int NumObjects;
int NumStaticObjects;
int NumMeshPointers;
int NumObjectTextures;
int NumTextureTiles;
short* MeshBase;
short** Meshes;
int NumItems;
FILE* LevelFilePtr;
@ -57,7 +54,6 @@ ANIM_STRUCT* Anims;
CHANGE_STRUCT* Changes;
RANGE_STRUCT* Ranges;
short* Commands;
int* Bones;
short* Frames;
int AnimationsCount;
short* FloorData;
@ -76,8 +72,6 @@ int g_NumSpritesSequences;
ChunkReader* g_levelChunkIO;
TrLevel g_Level;
short ReadInt8()
{
byte value = *(byte*)LevelDataPtr;
@ -187,25 +181,56 @@ void LoadObjects()
memset(Objects, 0, sizeof(ObjectInfo) * ID_NUMBER_OBJECTS);
memset(StaticObjects, 0, sizeof(StaticInfo) * MAX_STATICS);
int numMeshDataWords = ReadInt32();
int numMeshDataBytes = 2 * numMeshDataWords;
MeshBase = (short*)game_malloc(numMeshDataBytes);
ReadBytes(MeshBase, numMeshDataBytes);
MeshDataSize = numMeshDataBytes;
int numMeshPointers = ReadInt32();
Meshes = (short**)game_malloc(sizeof(short*) * numMeshPointers);
ReadBytes(Meshes, sizeof(short*) * numMeshPointers);
for (int i = 0; i < numMeshPointers; i++)
int numMeshes = ReadInt32();
Meshes.reserve(numMeshes);
for (int i = 0; i < numMeshes; i++)
{
Meshes[i] = &MeshBase[(int)Meshes[i] / 2];
}
MESH mesh;
int numMeshes = numMeshPointers;
NumMeshPointers = numMeshes;
mesh.sphere = BoundingSphere(Vector3(ReadFloat(), ReadFloat(), ReadFloat()), ReadFloat());
int numVertices = ReadInt32();
mesh.vertices.reserve(numVertices);
for (int j = 0; j < numVertices; j++)
{
MESH_VERTEX vertex;
vertex.position.x = ReadFloat();
vertex.position.y = ReadFloat();
vertex.position.z = ReadFloat();
vertex.normal.x = ReadFloat();
vertex.normal.y = ReadFloat();
vertex.normal.z = ReadFloat();
vertex.textureCoordinates.x = ReadFloat();
vertex.textureCoordinates.y = ReadFloat();
vertex.color.x = ReadFloat();
vertex.color.y = ReadFloat();
vertex.color.z = ReadFloat();
ReadFloat();
vertex.bone = ReadInt32();
vertex.index = ReadInt32();
mesh.vertices.push_back(vertex);
}
int numBuckets = ReadInt32();
mesh.buckets.reserve(numBuckets);
for (int j = 0; j < numBuckets; j++)
{
BUCKET bucket;
bucket.texture = ReadInt32();
bucket.blendMode = ReadInt8();
bucket.animated = ReadInt8();
int numIndices = ReadInt32();
bucket.indices.reserve(numIndices);
for (int k = 0; k < numIndices; k++)
bucket.indices.push_back(ReadInt32());
mesh.buckets.push_back(bucket);
}
Meshes.push_back(mesh);
}
int numAnimations = ReadInt32();
Anims = (ANIM_STRUCT*)game_malloc(sizeof(ANIM_STRUCT) * numAnimations);
@ -224,21 +249,11 @@ void LoadObjects()
ReadBytes(Commands, sizeof(short) * numCommands);
int numBones = ReadInt32();
Bones = (int*)game_malloc(sizeof(int) * numBones);
ReadBytes(Bones, sizeof(int) * numBones);
int* bone = Bones;
for (int i = 0; i < 15; i++)
Bones.reserve(numBones);
for (int i = 0; i < numBones; i++)
{
int opcode = *(bone++);
int linkX = *(bone++);
int linkY = *(bone++);
int linkZ = *(bone++);
Bones.push_back(ReadInt32());
}
MeshTrees = (int*)game_malloc(sizeof(int) * numBones);
memcpy(MeshTrees, Bones, sizeof(int) * numBones);
int numFrames = ReadInt32();
Frames = (short*)game_malloc(sizeof(short) * numFrames);
@ -260,11 +275,11 @@ void LoadObjects()
MoveablesIds.push_back(objNum);
Objects[objNum].loaded = true;
Objects[objNum].nmeshes = ReadInt16();
Objects[objNum].meshIndex = ReadInt16();
Objects[objNum].nmeshes = (short)ReadInt16();
Objects[objNum].meshIndex = (short)ReadInt16();
Objects[objNum].boneIndex = ReadInt32();
Objects[objNum].frameBase = (short*)(ReadInt32() + (int)Frames);
Objects[objNum].animIndex = ReadInt16();
Objects[objNum].animIndex = (short)ReadInt16();
ReadInt16();
@ -281,7 +296,7 @@ void LoadObjects()
int meshID = ReadInt32();
StaticObjectsIds.push_back(meshID);
StaticObjects[meshID].meshNumber = ReadInt16();
StaticObjects[meshID].meshNumber = (short)ReadInt16();
StaticObjects[meshID].yMinp = ReadInt16();
StaticObjects[meshID].xMaxp = ReadInt16();
@ -297,7 +312,7 @@ void LoadObjects()
StaticObjects[meshID].zMinc = ReadInt16();
StaticObjects[meshID].zMaxc = ReadInt16();
StaticObjects[meshID].flags = ReadInt16();
StaticObjects[meshID].flags = (short)ReadInt16();
}
// HACK: to remove after decompiling LoadSprites
@ -442,6 +457,7 @@ void ReadRooms()
vertex.color.y = ReadFloat();
vertex.color.z = ReadFloat();
vertex.effects = ReadInt32();
vertex.index = ReadInt32();
room.vertices.push_back(vertex);
}
@ -736,6 +752,9 @@ void FreeLevel()
StaticsTextures.clear();
SpritesTextures.clear();
ObjectTextures.clear();
Bones.clear();
Meshes.clear();
MoveablesIds.clear();
g_Renderer.FreeRendererData();
g_GameScript->FreeLevelScripts();
}

65
TR5Main/Specific/level.h
View file

@ -8,7 +8,7 @@
#include "room.h"
#define AddPtr(p, t, n) p = (t*)((char*)(p) + (ptrdiff_t)(n));
#define MESHES(slot, mesh) Meshes[Objects[slot].meshIndex + mesh]
#define MESHES(slot, mesh) (Objects[slot].meshIndex + mesh)
struct ChunkId;
struct LEB128;
@ -28,30 +28,15 @@ typedef struct OBJECT_TEXTURE
int destination;
};
#pragma pack(push, 1)
struct tr_object_texture_vert
struct TEXTURE
{
byte Xcoordinate; // 1 if Xpixel is the low value, 255 if Xpixel is the high value in the object texture
byte Xpixel;
byte Ycoordinate; // 1 if Ypixel is the low value, 255 if Ypixel is the high value in the object texture
byte Ypixel;
int width;
int height;
int size;
std::vector<byte> data;
};
struct tr4_object_texture
{
short Attribute;
short TileAndFlag;
short NewFlags;
tr_object_texture_vert Vertices[4]; // The four corners of the texture
int OriginalU;
int OriginalV;
int Width; // Actually width-1
int Height; // Actually height-1
short Padding;
};
#pragma pack(pop)
typedef struct AIOBJECT
struct AIOBJECT
{
short objectNumber;
short roomNumber;
@ -64,14 +49,14 @@ typedef struct AIOBJECT
short boxNumber;
};
typedef struct CHANGE_STRUCT
struct CHANGE_STRUCT
{
short goalAnimState;
short numberRanges;
short rangeIndex;
};
typedef struct RANGE_STRUCT
struct RANGE_STRUCT
{
short startFrame;
short endFrame;
@ -79,7 +64,7 @@ typedef struct RANGE_STRUCT
short linkFrameNum;
};
typedef struct SPRITE
struct SPRITE
{
int tile;
float x1;
@ -92,26 +77,37 @@ typedef struct SPRITE
float y4;
};
extern short* MeshData;
extern int MeshDataSize;
struct MESH_VERTEX
{
Vector3 position;
Vector3 normal;
Vector2 textureCoordinates;
Vector3 color;
int bone;
int index;
};
struct MESH
{
BoundingSphere sphere;
std::vector<MESH_VERTEX> vertices;
std::vector<BUCKET> buckets;
};
extern OBJECT_TEXTURE* NewObjectTextures;
extern uintptr_t hLoadLevel;
extern int NumMeshPointers;
extern int* MeshTrees;
extern std::vector<int> Bones;
extern int NumObjects;
extern int NumStaticObjects;
extern std::vector<int> MoveablesIds;
extern std::vector<int> StaticObjectsIds;
extern int* RawMeshPointers;
extern short* RawMeshData;
extern int NumObjectTextures;
extern char* LevelDataPtr;
extern int IsLevelLoading;
extern int NumTextureTiles;
extern int g_NumSprites;
extern int g_NumSpritesSequences;
extern short* MeshBase;
extern short** Meshes;
extern std::vector<MESH> Meshes;
extern int NumItems;
extern std::vector<OBJECT_TEXTURE> ObjectTextures;
extern ITEM_INFO* Items;
@ -121,7 +117,6 @@ extern ANIM_STRUCT* Anims;
extern CHANGE_STRUCT* Changes;
extern RANGE_STRUCT* Ranges;
extern short* Commands;
extern int* Bones;
extern short* Frames;
extern int AnimationsCount;
extern short* FloorData;
@ -135,8 +130,6 @@ extern std::vector<TEXTURE> StaticsTextures;
extern std::vector<TEXTURE> SpritesTextures;
extern TEXTURE MiscTextures;
extern TrLevel g_Level;
void LoadTextures();
void LoadRooms();
int LoadItems();

1001
TR5Main/Specific/levelloader.cpp
View file

File diff suppressed because it is too large Load diff

101
TR5Main/Specific/levelloader.h
View file

@ -1,101 +0,0 @@
#pragma once
#include "framework.h"
#include "sound.h"
#include "Streams.h"
#include "newtypes.h"
#include "ChunkId.h"
#include "ChunkReader.h"
class LevelLoader
{
private:
ChunkId* m_chunkTextureAtlas = ChunkId::FromString("T5MTex");
ChunkId* m_chunkTextureColor = ChunkId::FromString("T5MTexColMap");
ChunkId* m_chunkTextureNormalMap = ChunkId::FromString("T5MTexNrmMap");
ChunkId* m_chunkRoom = ChunkId::FromString("T5MRoom");
ChunkId* m_chunkRoomInfo = ChunkId::FromString("T5MRoomInfo");
ChunkId* m_chunkBucket = ChunkId::FromString("T5MBckt");
ChunkId* m_chunkRoomLight = ChunkId::FromString("T5MLight");
ChunkId* m_chunkRoomStatic = ChunkId::FromString("T5MRoomSt");
ChunkId* m_chunkRoomPortal = ChunkId::FromString("T5MPortal");
ChunkId* m_chunkRoomSector = ChunkId::FromString("T5MSector");
ChunkId* m_chunkRoomTriggerVolume = ChunkId::FromString("T5MTrigVol");
ChunkId* m_chunkRoomClimbVolume = ChunkId::FromString("T5MClimbVol");
ChunkId* m_chunkMaterial = ChunkId::FromString("T5MMat");
ChunkId* m_chunkVerticesPositions = ChunkId::FromString("T5MVrtPos");
ChunkId* m_chunkVerticesNormals = ChunkId::FromString("T5MVrtN");
ChunkId* m_chunkVerticesTextureCoords = ChunkId::FromString("T5MVrtUV");
ChunkId* m_chunkVerticesColors = ChunkId::FromString("T5MVrtCol");
ChunkId* m_chunkVerticesEffects = ChunkId::FromString("T5MVrtFX");
ChunkId* m_chunkVerticesBones = ChunkId::FromString("T5MVrtB");
ChunkId* m_chunkPolygon = ChunkId::FromString("T5MPoly");
ChunkId* m_chunkMesh = ChunkId::FromString("T5MMesh");
ChunkId* m_chunkBone = ChunkId::FromString("T5MBone");
ChunkId* m_chunkKeyFrame = ChunkId::FromString("T5MKf");
ChunkId* m_chunkAnimCommand = ChunkId::FromString("T5MAnCmd");
ChunkId* m_chunkStateChange = ChunkId::FromString("T5MStCh");
ChunkId* m_chunkAnimDispatch = ChunkId::FromString("T5MAnDisp");
ChunkId* m_chunkAnimation = ChunkId::FromString("T5MAnim");
ChunkId* m_chunkMoveable = ChunkId::FromString("T5MMoveable");
ChunkId* m_chunkStatic = ChunkId::FromString("T5MStatic");
ChunkId* m_chunkItem = ChunkId::FromString("T5MItem");
ChunkId* m_chunkAiItem = ChunkId::FromString("T5MAiItem");
ChunkId* m_chunkCamera = ChunkId::FromString("T5MCamera");
ChunkId* m_chunkSink = ChunkId::FromString("T5MSink");
ChunkId* m_chunkFlybyCamera = ChunkId::FromString("T5MFlyBy");
ChunkId* m_chunkSoundSource = ChunkId::FromString("T5MSndSrc");
ChunkId* m_chunkBox = ChunkId::FromString("T5MBox");
ChunkId* m_chunkOverlap = ChunkId::FromString("T5MOv");
ChunkId* m_chunkZone = ChunkId::FromString("T5MZone");
ChunkId* m_chunkSoundMap = ChunkId::FromString("T5MSoundMap");
ChunkId* m_chunkSoundDetail = ChunkId::FromString("T5MSndDet");
ChunkId* m_chunkSample = ChunkId::FromString("T5MSam");
ChunkId* m_chunkLeelScript = ChunkId::FromString("T5MScript");
ChunkId* m_chunkSprite = ChunkId::FromString("T5MSpr");
ChunkId* m_chunkSpriteSequence = ChunkId::FromString("T5MSprSeq");
ChunkId* m_chunkDummy = ChunkId::FromString("T5MDummy");
ChunkId* m_chunkAnimatedTextureSequence = ChunkId::FromString("T5MAnTxSeq");
ChunkId* m_chunkAnimatedTextureFrame = ChunkId::FromString("T5MAnTxFr");
ChunkId* m_chunkFloorData = ChunkId::FromString("T5MFloorData");
int m_magicNumber = 0x4D355254;
std::string m_filename;
ChunkReader* m_reader;
FileStream* m_stream;
int m_numSamples = 0;
TrLevel m_level;
bool readTexture();
bool readAnimatedTextureSequence();
bool readRoom();
bool readBucket(TrBucket* bucket);
bool readMesh();
bool readAnimation();
bool readChange();
bool readDispatch();
bool readBone();
bool readKeyFrame();
bool readCommand();
bool readOverlap();
bool readFloorData();
bool readMoveable();
bool readStatic();
bool readSpriteSequence();
bool readItem();
bool readAiItem();
bool readSink();
bool readCamera();
bool readFlybyCamera();
bool readSoundSource();
bool readBox();
bool readZones();
bool readSoundMap();
bool readSoundDetail();
bool readSample();
public:
LevelLoader(std::string filename);
~LevelLoader();
bool Load();
bool FillLegacyData();
};

380
TR5Main/Specific/newtypes.h
View file

@ -1,386 +1,10 @@
#pragma once
#include "framework.h"
struct TEXTURE
{
int width;
int height;
int size;
std::vector<byte> data;
};
struct TrTexturePage
{
int width;
int height;
int flags;
int format;
byte* colorMap;
byte* normalMap;
};
struct TrPolygon
{
std::vector<int> indices;
int animatedSequence;
int frame;
};
struct TrMaterial
struct BUCKET
{
int texture;
byte blendMode;
bool animated;
std::vector<int> indices;
};
struct TrBucket
{
TrMaterial material;
std::vector<Vector3> positions;
std::vector<Vector3> colors;
std::vector<Vector2> textureCoords;
std::vector<Vector3> normals;
std::vector<int> verticesEffects;
std::vector<int> bones;
std::vector<TrPolygon> polygons;
};
struct TrVolume
{
int type;
Vector3 position;
Quaternion rotation;
BoundingBox box;
BoundingSphere sphere;
std::string script;
};
struct TrClimbVolume : TrVolume
{
int climbType;
};
struct TrTriggerVolume : TrVolume
{
int activators;
};
struct TrSector
{
int floorDataIndex;
int floorDataCount;
int box;
int pathfindingFlags;
int stepSound;
int roomBelow;
int roomAbove;
int floor;
int ceiling;
std::vector<int> floorData;
};
struct TrLight
{
Vector3 position;
Vector3 color;
Vector3 direction;
byte type;
bool castShadows;
float intensity;
float in;
float out;
float len;
float cutoff;
int flags;
};
struct TrRoomStatic
{
std::string name;
Vector3 position;
Quaternion rotation;
Vector3 scale;
int staticNumber;
Vector3 color;
bool receiveShadows;
bool castShadows;
int flags;
std::string script;
};
struct TrPortal
{
int adjoiningRoom;
Vector3 normal;
std::vector<Vector3> vertices;
};
struct TrRoom
{
int x;
int z;
int yBottom;
int yTop;
int numXsectors;
int numZsectors;
int roomType;
int reverb;
int effect;
float effectStrength;
int alternateRoom;
int alternatGroup;
int flags;
Vector3 ambient;
std::vector<TrBucket> buckets;
std::vector<TrLight> lights;
std::vector<TrRoomStatic> statics;
std::vector<TrSector> sectors;
std::vector<TrPortal> portals;
std::vector<TrTriggerVolume> triggers;
std::vector<TrClimbVolume> climbVolumes;
int itemNumber;
int fxNumber;
};
struct TrMesh
{
BoundingSphere sphere;
std::vector<TrBucket> buckets;
};
struct TrBone
{
int opcode;
Vector3 offset;
};
struct TrKeyFrame
{
Vector3 origin;
BoundingBox boundingBox;
std::vector<Quaternion> angles;
};
struct TrAnimCommand
{
int type;
int frame;
std::vector<int> params;
};
struct TrAnimDispatch
{
int inFrame;
int outFrame;
int nextAnimation;
int nextFrame;
};
struct TrStateChange
{
int state;
int dispatchIndex;
int dispatchCount;
std::vector<TrAnimDispatch> dispatches;
};
struct TrAnimation
{
int framerate;
int state;
int nextAnimation;
int nextFrame;
int frameBase;
int frameEnd;
float speed;
float acceleration;
float lateralSpeed;
float lateralAcceleration;
int framesIndex;
int framesCount;
int changesIndex;
int changesCount;
int commandsIndex;
int commandsCount;
std::vector<TrKeyFrame> keyframes;
std::vector<TrStateChange> changes;
std::vector<TrAnimCommand> commands;
};
struct TrMoveable
{
int id;
int animationIndex;
int animationCount;
int meshIndex;
int meshCount;
int bonesIndex;
int bonesCount;
std::vector<TrMesh> meshes;
std::vector<TrBone> bones;
std::vector<TrAnimation> animations;
};
struct TrStatic
{
int id;
BoundingBox visibilityBox;
BoundingBox collisionBox;
int meshNumber;
int meshCount;
std::vector<TrMesh> meshes;
};
struct TrAnimatedTexturesFrame
{
int texture;
std::vector<Vector2> textureCoords;
};
struct TrAnimatedTexturesSequence
{
byte animationType;
float fps;
int uvRotate;
std::vector<TrAnimatedTexturesFrame> frames;
};
struct TrItem
{
std::string name;
Vector3 position;
Quaternion rotation;
float angle;
Vector3 scale;
Vector3 color;
int roomNumber;
int objectNumber;
std::string script;
};
struct TrCamera
{
std::string name;
Vector3 position;
int roomNumber;
int type;
int flags;
std::string script;
};
struct TrSoundSource
{
std::string name;
Vector3 position;
int roomNumber;
float volume;
int sound;
int playMode;
};
struct TrSink
{
std::string name;
Vector3 position;
int roomNumber;
float strength;
int box;
};
struct TrOverlap
{
int flags;
int box;
};
struct TrBox
{
Vector2 min;
Vector2 max;
int floor;
int flags;
int overlapsIndex;
int overlapsCount;
std::vector<TrOverlap> overlaps;
};
struct TrSample
{
int uncompressedSize;
int compressedSize;
byte* data;
};
struct TrSoundDetails
{
float volume;
float range;
float chance;
float pitch;
bool randomizePitch;
bool randomizeGain;
bool noPanoramic;
byte loop;
std::vector<TrSample> samples;
};
struct TrFlybyCamera
{
std::string name;
int sequence;
int number;
Vector3 position;
Vector3 direction;
float fov;
float roll;
float speed;
int timer;
int roomNumber;
int flags;
std::string script;
};
struct TrSprite
{
int texture;
std::vector<Vector2> textureCoords;
};
struct TrSpriteSequence
{
int id;
int spritesIndex;
int spritesCount;
std::vector<TrSprite> sprites;
};
struct TrLevel
{
std::vector<TrTexturePage> textures;
std::vector<TrRoom> rooms;
std::vector<int> floorData;
std::vector<TrMesh> meshes;
std::vector<TrAnimation> animations;
std::vector<TrBone> bones;
std::vector<TrStateChange> changes;
std::vector<TrAnimDispatch> dispatches;
std::vector<TrKeyFrame> frames;
std::vector<TrAnimCommand> commands;
std::vector<TrAnimatedTexturesSequence> animatedTextures;
std::vector<TrSprite> sprites;
std::vector<TrSpriteSequence> spriteSequences;
std::vector<int> soundMap;
std::vector<TrSoundDetails> soundDetails;
std::vector<TrSample> samples;
std::vector<TrItem> items;
std::vector<TrItem> aiItems;
std::vector<TrMoveable> moveables;
std::vector<TrStatic> statics;
std::vector<TrBox> boxes;
std::vector<TrOverlap> overlaps;
std::vector<int> zones[5][2];
std::vector<TrSink> sinks;
std::vector<TrCamera> cameras;
std::vector<TrSoundSource> soundSources;
std::vector<TrFlybyCamera> flybyCameras;
};

2
TR5Main/TR5Main.vcxproj
View file

@ -389,7 +389,6 @@ xcopy /Y "$(ProjectDir)Scripting\Scripts\*.lua" "$(TargetDir)\Scripts"</Command>
<ClInclude Include="Specific\input.h" />
<ClInclude Include="Specific\IO\Streams.h" />
<ClInclude Include="Specific\level.h" />
<ClInclude Include="Specific\levelloader.h" />
<ClInclude Include="Specific\newtypes.h" />
<ClInclude Include="Specific\setup.h" />
<ClInclude Include="Specific\winmain.h" />
@ -632,7 +631,6 @@ xcopy /Y "$(ProjectDir)Scripting\Scripts\*.lua" "$(TargetDir)\Scripts"</Command>
<ClCompile Include="Specific\IO\ChunkReader.cpp" />
<ClCompile Include="Specific\IO\Streams.cpp" />
<ClCompile Include="Specific\level.cpp" />
<ClCompile Include="Specific\levelloader.cpp" />
<ClCompile Include="Specific\setup.cpp" />
<ClCompile Include="Specific\winmain.cpp" />
<ClCompile Include="Objects\TR5\Object\tr5_genslot.cpp" />

6
TR5Main/TR5Main.vcxproj.filters
View file

@ -699,9 +699,6 @@
<ClInclude Include="Game\lara_struct.h">
<Filter>File di intestazione</Filter>
</ClInclude>
<ClInclude Include="Specific\levelloader.h">
<Filter>File di intestazione</Filter>
</ClInclude>
<ClInclude Include="Specific\newtypes.h">
<Filter>File di intestazione</Filter>
</ClInclude>
@ -1430,9 +1427,6 @@
<ClCompile Include="Game\trmath.cpp">
<Filter>File di origine</Filter>
</ClCompile>
<ClCompile Include="Specific\levelloader.cpp">
<Filter>File di origine</Filter>
</ClCompile>
<ClCompile Include="Objects\TR5\Light\tr5_light.cpp">
<Filter>File di origine</Filter>
</ClCompile>