TUTORIAL Editing the .CAM file through hex

PART 02

In this part of the tutorial you will learn what some bytes are used for in the cam structure, and you will be introduced to Pointers, the most important part.

What are Pointers?
Pointers are variables which stores addresses of another memory region, so you can use pointers to get information that is not present in that part of the structure.
Just think about pointers as "arrows" which points to an specific address, in our case address = offset.
You will understand better by practicing later, let's move on.

In-Depth details
Now let's take a look at our new custom camera and dissect it to understand what is what.
I am assuming you read the last post to see the cam structure, if don't remember it anymore, just scroll up a bit before continuing.

01: Start of the cam file, without this data the game will not recognize the file.
02: Camera entries index, you will need to update these two values to the total amount of camera entries. In our custom cam we only have 1 entry, so update them both to 01 01.

Type 04 triggerzones will be activated when the player opens chests, drawers, cabinets and this sort of things that can be inspected.
There are other types like 23, 63 and some others which I still don't know the real use.

02: Pointer to Camera Properties 1. This pointer tells the file to obtain a value at which offset we put there, as this is the pointer to Camera Properties 1, we will need to update it correctly, so let's do it now.
The cam file is shown to us as Little Endian format, but the pointers are always in Big Endian format. So this means we need to invert the bytes to know the correct offset we need to point at, in our case here we have 00 01 which is equal to 01 00, what means that this pointer is pointing to the data in the 01 00 offset. Which is correct in the original r100_00.CAM, but is wrong in our custom camera, so to fix it we need to put the offset related to the Camera Properties 1 of the first entry, which is 00 20, but you need to update it as Little Endian, so put 20 00 and it is done.

03: Pointer to Camera Properties 2. This pointer works the same way as the previous one, you need to edit it and input the offset that starts the Camera Properties 2, which in our custom camera is 00 50, so update it inverted 50 00 and it's done.

01: LIT Group. This byte activates specified LIT Group present in .LIT file, most used to change ligthing when entering some areas, this is an amazing feature, but I will not cover it up here since Mr.Curious already wrote almost everything you need in his tutorials.

02: Trigger type. You just need to put here the same value you inserted in the first byte of the camera entry, scroll up a little if you forgot.

03 & 04: Higher Limit & Lower Limit. Don't worry about editing these values for now, we can edit them easily in Crzosk's tool.
Higher Limit is where you want the top vertexes to be placed (look at the pic below), this value represents how much taller you want the triggerzones to be.
Lower Limit is the opposite, here you define the lower part of the triggerzones, it is recommended that you put it a little underground to make sure Leon will enter it.
But this is not all. After you input the values, there will be made a sum calculation, so the total height of the triggerzones will be the sum of these two values:
05: Total of triggerzones vertexes. This value defines how much triggerzone vertexes you want to put, and you will need to add correspondent vertexes at triggerzone structure area.

The last arrow is number 06, which is a Pointer pointing to Triggerzones offset. It works the same way as the other pointers, just invert it and replace to the correct offset, which in our custom camera is 00 84, so update it with 84 00 and you're done.
If you're a bit lost about this, check it out in the HxD and look for offset 00000080 in the fourth column, then look at float value to see the first X triggerzone value.

01: Camera Index. This is updated 1 by 1 at each entry, so if you have two cameras, in the second camera you will need to update this value to 2.

02: Camera type. Now the best part, camera types. There are a total of 9 known different camera types, which I will list here with parts of Mr.Curious descriptions.
0: "Fixed camera in a specified position and direction"
1: "Camera aligns behind player and FOV pulls back as player passes "
2: "Camera position is moved away (over head) & locked, camera does not track the player"
3: "Fixed camera that rotates alongside the player"
4: "Camera position & rotation move to a specific location and pans with player"
5: "360 Camera, moves with right analog stick/camera buttons"
6: "Camera is locked to a specified position & rotation and can be animated"
7: "Camera position & rotation is locked when entering trigger zone"
8: "Over the shoulder camera"

As I have yet not tested all of them, In this tutorial I will be using type 3 for easier understanding. But you can (and should) try all of them to see what happens.
03: Data Set. In the last post I told you about this byte, the Data Set defines how much data will be read. Example, it's 00 now so no data from position, rotation and pan zoom will be read.
For type 3 cameras we need 2 data set for it to work, for type 0 cameras we need only 1 data set, but for type 8 cameras we need 18 (24 in decimal) data set for it to work. If you're not understanding what this means, just see how much position and direction data there are in Crzosk's tool.
As we're going to use type 3, just put a 02 there and you're done.

04: Pointer for position. This pointer works like every other, do same steps: invert it, find where the position offset starts (in our custom camera is 00 B4) and put a B4 00 there.

05: Pointer for direction. Same work to do here, find the correct offset that starts the direction and update it. Remeber we are using 2 Data Set, so there will be two positions and after them are two directions. You can see it starts at offset 000000D4, so put a D4 00 there.

06: Pointer for Pan Zoom 1. There are two types of Pan Zoom, one for rotation and other for FOV. And as we are using 2 Data Set, we need two float values for Pan Zoom 1. If you look at our custom camera, you can see it starts at 000000F4, so put a F4 00 there.

07: Pointer for Pan Zoom 2. Works the same way as the previous one, two float values. Starts at offset 000000FC, so put a FC 00 there.

After all of this work, your camera is now ready and can be succesfully opened at Crzosk's tool.

01: End of Cam Properties 2.
02: Beggining of the camera position.
XYZ: Triggerzones. Better explained in previous post.

01: End of Triggerzones.
02: Beggining of Pan Zoom.
Redish box: Position in X, Y, Z and a separator (better explained in previous post).
Greenish box: Direction in X, Y, Z and a separator.

01: End of Direction.
All the rest is self explained and there are more info in the first post.

With this part of the tutorial you learned what is the purpose of some bytes and how they are related to each other, the pointer system can be difficult at the beggining, but keep on practicing until you get used to it.
And remember: you can rename your custom cam to r100_00.CAM and re-import it back at the game to test it.
There is a very nice tutorial over here on how to configure the camera with Crzosk's tool, go ahead and try it out.

---

Additional Info:
I am aware of some problems while building up entries from scratch because of some optional data that some rooms needs, I am gonna detail them now.

Just before the Triggerzone structure area, there is a 16 bytes row which use is unknown:

If your camera does not work, insert these bytes to see if it fixes.
But if the game still crashes or your file doesn't open with Crzosk's tool, try adding 20 bytes of CD just like the pic above. With these fixes, all should work fine.

PART 04

Ok, for the last part we want to insert our custom camera entry into the original cam file, r100_00.CAM.
As this is not very hard, it is very tedious. Especially if you're going to add multiple entries.
But let's move.

First of all, open your original r100_00.CAM file and your custom camera on HxD.
Take a look at the header for its indexes values, it is 0F 0F, but if we are going to add a new camera, we need to update it to 10 10. (0F = 15, 10 = 16).
In our second move we need to copy our custom camera entry structure part and paste it below all the entries in the original cam:

Now we need to paste our custom Camera Properties 1 below all Camera Properties 1 in the original cam. By following all the previous posts you should know where it starts, but if you're lost, you can follow the LIT group byte, it will increase from 01 to 0F.

After pasting Camera Properties 1, we need to do the same with Camera Properties 2. But remember to update the index in this part, and remember this structure is made of 34 bytes.
Paste your custom Camera Properties 2 just before that row of unknown bytes:
01 01 00 01 00 00 00 00 00 00 00 00 00 00 00 00


Now you need to paste your custom triggerzones below all original triggerzones.
To be sure you are in the correct offset, you can always check the float value and check if it is the same at Crzosk's tool.


Now we just need to paste our custom Position, Direction and Pan Zoom at the end of the file, before any CD CD CD CD.
After all pasting is done, yeah, we need to update ALL THE POINTERS again.
Pointers from camera entry, cam prop 1 & 2.

You need to be very cautious while doing this, as this is what makes the cameras work, so everything needs to be pointing at the correct place.
I will give some tips here.

Look at your original cam entries pointers, you can see they update in a pattern:
00 01, 30 01, 60 01, 90 01, C0 01, F0 01, 20 02 ... They update after each 30 bytes (in hexadecimal values).
So you can use this same method to update these pointers and include your new entry, and as we added just 1 new camera, we need just to sum +10 at each pointer:


Now when we are updating the next pointers, there is also a way to do it "faster".
If you take a look at Int16 value at each pointer, you can see all of them increases by 52. So you can open up your calculator and use this as an advantage. Update all of them.

When you're done, the last pointer will be pointing at the offset of your custom Camera Properties 2:

Here comes the next part where we need to update all the pointers from the Camera Properties 1. Remember they point to the triggerzones, so you may want to use Crzosk's tool to see if you are in the correct offset.

I have yet not found an easy way to update them, since the math here depends on how much triggerzones vertexes are defined.
Each time it's a 4 vertexes triggerzone, it increases by 48 at Int16 value.
Each time it's a 6 vertexes triggerzone, it increases by 72 at Int16 value.

With this information, you can take a good look at the Vertexes byte and see if there is a 4 or 6 there, then you can use the calculator again and do the math.
The second alternative is to check the triggerzones values at float value and compare at Crzosk's tool.

If you did everything correctly, you can see the last pointer pointing at your custom triggerzones:


Okay, now with this last and worst part, we need to update all the pointers to position, direction and pan zoom.
The only method I found to this is look at Crzosk's tool everytime to see if we are in the correct offset, so unless you find a better way, we must do this.

You can also search for the values that are in the cam tool, just remember to remove the zero before it. Example: -0,527 -> -527 and search in HxD with pointer number option.

Update all the pointers correctly, then your .cam file will be ready to go.
Be patient and attentive.

And this concludes the tutorial, I hope you could understand every step of it and you learned something from it.
If you have any questions, please just ask here.

Stay cool.