This shows you the differences between two versions of the page.
Both sides previous revision Previous revision Next revision | Previous revision Next revision Both sides next revision | ||
kirby64_the_crystal_shards:level_settings_blocks [2020/02/18 19:12] jesusyoshi54 [Collision Header] |
kirby64_the_crystal_shards:level_settings_blocks [2020/03/05 18:20] jesusyoshi54 [Path Node Headers] |
||
---|---|---|---|
Line 5: | Line 5: | ||
- Main Header | - Main Header | ||
- | - Vertices (s16 triplets) | + | - Vertices |
- | - Triangles (20 bytes each) | + | - Triangles |
- Surface Normals | - Surface Normals | ||
- Triangle Groups/Cells | - Triangle Groups/Cells | ||
Line 12: | Line 12: | ||
- Dynamic Geometry Lists | - Dynamic Geometry Lists | ||
- Dynamic Geometry Groups | - Dynamic Geometry Groups | ||
- | - Optional Section? | + | - Water Data |
- | - Collision Header (referred to by Header[0]) | + | - Water Normals |
+ | - Collision Header (referred to by Main Header[0]) | ||
- Pathing Nodes | - Pathing Nodes | ||
- Kirby Node Params & Camera Nodes | - Kirby Node Params & Camera Nodes | ||
Line 19: | Line 20: | ||
- Unk Bytes | - Unk Bytes | ||
- Unk Floats | - Unk Floats | ||
- | - Camera&Pathing Header | + | - Path Node Headers |
- | - Header_1(referred to by Header[1]) | + | - Node Header (referred to by Main Header[1]) |
- | - Entity List (referred to by Header[2]) | + | - Entity List (referred to by Main Header[2]) |
==== Main Header ==== | ==== Main Header ==== | ||
Line 27: | Line 28: | ||
The main header contains references to the three main sections of the level settings block: Collision, Camera and the Entity List. | The main header contains references to the three main sections of the level settings block: Collision, Camera and the Entity List. | ||
<code c> | <code c> | ||
- | struct Main_Header{ | + | struct Main_Header |
- | /*0x00*/ ptr *Collision_Header | + | { |
- | /*0x04*/ ptr *Camera_Header | + | /*0x00*/ ptr *Collision_Header; |
- | /*0x08*/ ptr *Entity_IDs | + | /*0x04*/ ptr *Node_Header; |
- | } | + | /*0x08*/ ptr *Entity_IDs; |
+ | }; | ||
</code> | </code> | ||
Line 49: | Line 51: | ||
Every Triangle has a struct that has additional parameters telling the game how to handle collision. | Every Triangle has a struct that has additional parameters telling the game how to handle collision. | ||
<code c> | <code c> | ||
- | struct Triangle{ | + | struct Col_Triangle |
- | /*0x0*/ u16 Vertex[3] | + | { |
- | /*0x6*/ u16 Polygon_Number | + | /*0x0*/ u16 Vertex[3]; |
- | /*0x8*/ u16 Collision_Type_1 #(1 forward norm, 2 back norm, 4 no shadow, 8 non solid/warp related?) | + | /*0x6*/ u16 Polygon_Number; |
- | /*0xA*/ u16 Destructable_Group_Index | + | /*0x8*/ u16 Solidty_Type; //(1 forward norm, 2 back norm, 4 no shadow, 8 non solid) |
- | /*0xC*/ u16 Break_Particle #(seen in DEDEDE hammer break) | + | /*0xA*/ u16 Destructable_Group_Index; |
- | /*0xE*/ u16 Halt_Movement #warp related? Maybe dest (kirby cant move while on top of this if 1) | + | /*0xC*/ u16 Break_Particle; //(seen in DEDEDE hammer break) |
- | /*0x10*/ s16 Col_Param1 #Amount to move kirby while on certain col types or Break Condition | + | /*0xE*/ u16 Halt_Movement; //warp related? Maybe dest (kirby cant move while on top of this if 1) |
- | /*0x12*/ u16 Collision_Type_2 #see col type list | + | /*0x10*/ s16 Col_Param1; //Amount to move kirby while on certain col types or Break Condition |
- | } | + | /*0x12*/ u16 Collision_Type; //see col type list |
+ | }; | ||
</code> | </code> | ||
- | The following is a list of Collision_Type_2 values known. | + | The following is a list of Collision_Type values known. |
* 0x1 - wall ladder | * 0x1 - wall ladder | ||
* 0x2 - rope | * 0x2 - rope | ||
Line 79: | Line 82: | ||
Triangle normals are stored as a F32 array of 4 values. The first three values are the surface normals while the last is the origin offset. Together the normals should solve the plane equation (see:[[http://mathworld.wolfram.com/Plane.html|link]]). | Triangle normals are stored as a F32 array of 4 values. The first three values are the surface normals while the last is the origin offset. Together the normals should solve the plane equation (see:[[http://mathworld.wolfram.com/Plane.html|link]]). | ||
- | The list of normals always starts with (-1,-2,-3,-4) and this is used to refer to walls. The actual value of the first set of normal is not known to have any significance. Redundant normals are not repeated, but are just referenced multiple times (e.g. two triangles with norm Y==1 and offset==0 share their normal). | + | The list of normals always starts with (-1,-2,-3,-4) and is used to refer to walls, only floor and ceilings have their normals listed. The actual value of the first set of normal is not known to have any significance. Redundant normals are not repeated, but are just referenced multiple times (e.g. two triangles with norm Y==1 and offset==0 share their normal). |
+ | |||
+ | <code c> | ||
+ | struct Normal | ||
+ | { | ||
+ | /*0x0*/ Vec3f Surface_Normals | ||
+ | /*0xC*/ f32 Origin_Offset | ||
+ | } | ||
+ | </code> | ||
==== Triangle Groups ==== | ==== Triangle Groups ==== | ||
Line 97: | Line 108: | ||
Normal groups are sorted by polygon index. Only floors & ceilings are referenced by the normal groups, walls are given the first index of the normals list (-1,-2,-3,-4). | Normal groups are sorted by polygon index. Only floors & ceilings are referenced by the normal groups, walls are given the first index of the normals list (-1,-2,-3,-4). | ||
- | Norm List Structure | ||
<code c> | <code c> | ||
- | 0x0 u16 Normal_Index | + | struct Norm_Group |
- | 0x2 u16 Triangle_Index | + | { |
+ | /*0x0*/ u16 Normal_Index; | ||
+ | /*0x2*/ u16 Triangle_Index; | ||
+ | }; | ||
</code> | </code> | ||
==== Dynamic Geometry Lists ==== | ==== Dynamic Geometry Lists ==== | ||
Line 109: | Line 122: | ||
<code c> | <code c> | ||
- | 0x0 u16 Num_Dynamic_Geo_Group_Members #Number of connected triangles | + | struct DynGeo_List |
- | 0x2 u16 Index_To_Dynamic_Geo_Group #(0x30 in col header) | + | { |
- | 0x4 u16 Unk_Index #Gets stored to unk struct | + | /*0x0*/ u16 Num_Dynamic_Geo_Group_Members; //Number of connected triangles |
+ | /*0x2*/ u16 Index_To_Dynamic_Geo_Group; //(0x30 in col header) | ||
+ | /*0x4*/ u16 Unk_Index; //Gets stored to unk struct | ||
+ | }; | ||
</code> | </code> | ||
- | The dynamic geo list ends with 0x9999 | + | The dynamic geo list usually ends with 0x9999, but it is not necessary. |
+ | The dynamic geo list can also be null, in that case the col header will have a null ptr to match. | ||
==== Dynamic Geometry Groups ==== | ==== Dynamic Geometry Groups ==== | ||
Line 123: | Line 140: | ||
The dynamic geomtry group only has the references to triangles. The transformation (usually destruction) is applied based on col type or specific code. | The dynamic geomtry group only has the references to triangles. The transformation (usually destruction) is applied based on col type or specific code. | ||
- | The dynamic geo geoup array ends with 0x9999 | + | The dynamic geo geoup array usually ends with 0x9999, but its not necessary. |
+ | This list can also be null, and will have a null ptr in the col header to match. | ||
+ | ==== Water Data ==== | ||
+ | |||
+ | Water data is an array of water structs that will determine how kirby collides with water. | ||
+ | Normals and a bounding box are used instead of polygons to determine collision. First kirby has to be inside the bounding box inside the water data struct. | ||
+ | Then the normals are used. Normals are different than collision triangle geometry in that they define an infinite plane. The normal planes intersect to create a closed surface which is used as the collision check. | ||
+ | |||
+ | The bytes inside the water data struct act as bools. | ||
+ | |||
+ | <code c> | ||
+ | struct Water_Data | ||
+ | { | ||
+ | /*0x0*/ u16 Num_Normals; | ||
+ | /*0x2*/ u16 Norm_Array_Index; | ||
+ | /*0x4*/ u8 Water_Box_Active; | ||
+ | /*0x5*/ u8 Activate_Water_Flow; | ||
+ | /*0x6*/ u8 Water_Flow_Direction; | ||
+ | /*0x7*/ u8 Water_Flow_Speed; | ||
+ | /*0x8*/ f32 Pos1; | ||
+ | /*0xC*/ f32 Pos2; | ||
+ | /*0x10*/ f32 Pos3; | ||
+ | /*0x14*/ f32 Pos4; | ||
+ | }; | ||
+ | </code> | ||
+ | |||
+ | ==== Water Floats ==== | ||
+ | |||
+ | Works exactly like floats for other collision triangles. | ||
+ | Lead by a (1,2,3,4) the followed by (3*norms,origin offset). | ||
+ | Follows all the conventions for normals that you'd expect, including n * r = -offset. | ||
+ | |||
+ | This list is only accessed by being pointed to by the water data struct. | ||
==== Collision Header ==== | ==== Collision Header ==== | ||
The collision header is referred to by the first index inside the main header. The collision header has the following format. | The collision header is referred to by the first index inside the main header. The collision header has the following format. | ||
<code c> | <code c> | ||
- | struct Collision_Header{ | + | struct Collision_Header |
- | /*0x0*/ ptr Triangles_Offset | + | { |
- | /*0x4*/ U32 Num_Triangles | + | /*0x0*/ struct Col_Triangle *Triangles; |
- | /*0x8*/ ptr Vertices_Offset | + | /*0x4*/ u32 Len_Triangles; |
- | /*0xC*/ U32 Num_Vertices | + | /*0x8*/ s16 (*Vertices)[][3]; |
- | /*0x10*/ ptr Triangle_Normals | + | /*0xC*/ u32 Len_Vertices; |
- | /*0x14*/ U32 Num_Norms | + | /*0x10*/ struct Normal (*Triangle_Normals)[]; |
- | /*0x18*/ ptr Triangle_Cells_Offset | + | /*0x14*/ u32 Len_Tiangle_Normals; |
- | /*0x1C*/ U32 Num_Triangle_Cells | + | /*0x18*/ u16 (*Triangle_Cells)[][2]; |
- | /*0x20*/ ptr Triangle_Norm_Cells_Offset | + | /*0x1C*/ u32 Len_Triangle_Cells; |
- | /*0x24*/ U32 Num_Tri_Norm_Cells | + | /*0x20*/ u16 (*Triangle_Norm_Cells)[][2]; |
- | /*0x28*/ U32 Num_Floor_Norms #Should be tri norm cells minus 1 | + | /*0x24*/ u32 Len_Triangle_Norm_Cells; |
- | /*0x2C*/ ptr Destructable_Groups | + | /*0x28*/ u32 Num_Floor_Norms; //Should be tri norm cells minus 1 |
- | /*0x30*/ ptr Destructable Indices | + | /*0x2C*/ struct DynGeo_List (*Destructable_Groups)[]; |
- | /*0x34*/ ptr Opt_Param_1_Offset | + | /*0x30*/ u16 (*Destructable Indices)[]; |
- | /*0x38*/ U32 Opt_Param_1_Value | + | /*0x34*/ struct Water_Data (*Water_Data)[]; |
- | /*0x3C*/ ptr Opt_Param_2_Offset | + | /*0x38*/ u32 Len_Water_Data; |
- | /*0x40*/ U32 Opt_Param_2_Value | + | /*0x3C*/ struct Normal (*Water_Normals)[]; |
- | } | + | /*0x40*/ u32 Len_Water_Normals; |
+ | }; | ||
</code> | </code> | ||
- | ===== Header_1 ===== | + | ===== Node_Header ===== |
The level nodes are referred to by the second index in the main header. | The level nodes are referred to by the second index in the main header. | ||
This section tells the game how to move kirby as you progress through the level and how the camera should act. | This section tells the game how to move kirby as you progress through the level and how the camera should act. | ||
+ | |||
+ | <code c> | ||
+ | struct Node_Header | ||
+ | { | ||
+ | /*0x0*/ u32 Num_Path_Nodes; | ||
+ | /*0x4*/ struct Path_Node_Header (*Path_Node_Header)[]; | ||
+ | /*0x8*/ u8 (*Unk_Bytes)[]; | ||
+ | /*0xC*/ f32 (*Unk_Floats)[]; | ||
+ | }; | ||
+ | </code> | ||
+ | |||
+ | ==== Path Node Headers ==== | ||
+ | |||
+ | Pathing nodes are sections of the level that have a defined path and camera movement for kirby as he progresses through the level. | ||
+ | |||
+ | Each node has several parts which are pointed to by the path node header array. | ||
+ | |||
+ | <code c> | ||
+ | struct Path_Node_Header | ||
+ | { | ||
+ | /*0x0*/ struct Kirby_Node *Kirby_Node; | ||
+ | /*0x4*/ struct Path_Node_Footer *Path_Node_Footer; | ||
+ | /*0x8*/ struct Node_Connecters (*Node_Connections)[]; | ||
+ | /*0xC*/ u16 Num_Connections; | ||
+ | /*0xE*/ u16 Self_Connected; | ||
+ | }; | ||
+ | </code> | ||
+ | |||
+ | ==== Path Nodes ==== | ||
+ | |||
+ | Path nodes are made up of 3 parts. A footer, a position matrix, and a boundary matrix. | ||
+ | |||
+ | The path node footer contains pointers to the other sections, as well as important data for those sections. | ||
+ | |||
+ | The boundary matrix is a N×1 matrix that has percentage completion for the positional matrix. | ||
+ | This matrix tells the game how much each position in the position matrix contributes towards one node. | ||
+ | |||
+ | The position matrix is a 3×N matrix which tells the game the absolute positioning of kirby as you progress through the level. | ||
+ | This matrix is how kirby moves in both X and Z when you push to the right. | ||
+ | |||
+ | All together these sections create a path which kirby will walk along when you push right/left. | ||
+ | Theyre ordered in the rom as: Position matrix, boundary matrix, path node footer. | ||
+ | |||
+ | <code c> | ||
+ | struct Path_Node_Footer | ||
+ | { | ||
+ | /*0x00*/ u32 Num_Node_Sections; | ||
+ | /*0x04*/ u32 Unused; | ||
+ | /*0x08*/ Vec3f (*Position_Matrix)[]; | ||
+ | /*0x0C*/ f32 Inverse_H_Speed; | ||
+ | /*0x10*/ f32 (*Boundary_Matrix)[]; | ||
+ | /*0x14*/ f32 *Unk; | ||
+ | }; | ||
+ | </code> | ||
+ | |||
+ | The unknown section is almost always null. All that is known is that it follows the boundary matrix and is 4 sets if 5 floats. | ||
+ | |||
+ | ==== Camera&Kirby Nodes ==== | ||
+ | |||
+ | These nodes tell the game how to move the camera with respect to the path nodes. | ||
+ | There are settings for kirby's graphics (possibly lots of other things aswell) as he progresses through the level, as well as camera movement. | ||
+ | |||
+ | <code c> | ||
+ | struct Kirby_Node | ||
+ | { | ||
+ | /*0x00*/ u32 unk; | ||
+ | /*0x02*/ u16 unk2; | ||
+ | /*0x04*/ u32 unk3; | ||
+ | /*0x08*/ u8 unused; | ||
+ | /*0x09*/ u8 Shade_Left; | ||
+ | /*0x0A*/ u8 Shade_Center; | ||
+ | /*0x0B*/ u8 Shade_Right; | ||
+ | /*0x0C*/ u16 unk4; | ||
+ | /*0x0E*/ u16 Unkflag; | ||
+ | /*0x10*/ u32 opt_1; | ||
+ | /*0x14*/ u32 opt_2; | ||
+ | /*0x18*/ u32 opt_3; | ||
+ | /*0x1C*/ u32 opt_4; | ||
+ | /*0x20*/ struct Camera_Node Camera; | ||
+ | }; | ||
+ | </code> | ||
+ | |||
+ | <code c> | ||
+ | struct Camera_Node | ||
+ | { | ||
+ | /*0x00*/ u16 Camera_Type; | ||
+ | /*0x02*/ u8 Lock_X_pos; | ||
+ | /*0x03*/ u8 Lock_Y_pos; | ||
+ | /*0x04*/ u8 Lock_Z_pos; | ||
+ | /*0x05*/ u8 unused; | ||
+ | /*0x06*/ u8 unk1; | ||
+ | /*0x07*/ u8 unk2; | ||
+ | /*0x08*/ u8 Follow_X_Angle; | ||
+ | /*0x09*/ u8 unk4; | ||
+ | /*0x0A*/ u8 unk5; | ||
+ | /*0x0C*/ f32 X_Focus_Pos; | ||
+ | /*0x10*/ f32 Y_Focus_Pos; | ||
+ | /*0x14*/ f32 Flag; //always 9999? | ||
+ | /*0x18*/ f32 Near_Clip_Plane; | ||
+ | /*0x1C*/ f32 Far_Clip_Plane; | ||
+ | /*0x20*/ f32[2] Cam_Y_Pos; | ||
+ | /*0x28*/ f32[2] Cam_X_Pos; | ||
+ | /*0x30*/ f32[2] Cam_Z_Pos; | ||
+ | /*0x38*/ f32[2] FOV_Pair; | ||
+ | /*0x40*/ f32[2] Lateral_Y_Pos; | ||
+ | /*0x48*/ f32 Unk6; | ||
+ | /*0x4C*/ f32 Cam_X_Offset_Locked; | ||
+ | /*0x50*/ f32 Unk7; | ||
+ | /*0x54*/ f32 Cam_Y_Pos_Locked; | ||
+ | /*0x58*/ f32[2] Flag2; //a 9999 pair | ||
+ | /*0x60*/ f32 Focus_Y_Above; //while 0x6 is true | ||
+ | /*0x64*/ f32 Focus_Y_Below; //while 0x6 is true | ||
+ | /*0x68*/ f32 Focus_X_Left; //while 0x6 is true | ||
+ | /*0x6C*/ f32 Focus_X_Right; //while 0x6 is true | ||
+ | }; | ||
+ | </code> | ||
+ | |||
+ | ==== Node Connectors ==== | ||
+ | |||
+ | Node connectors tell the game which nodes to use as kirby hits the boundaries of a node. | ||
+ | The number of connections for each node is listed in the path node header. | ||
+ | |||
+ | <code c> | ||
+ | struct Node_Connectors | ||
+ | { | ||
+ | /*0x00*/ u16 Unused; //Not entirely sure | ||
+ | /*0x02*/ u16 Current_Node; | ||
+ | /*0x04*/ u16 Unused2; //Not sure | ||
+ | /*0x06*/ u16 Connected_Node; | ||
+ | }; | ||
+ | </code> | ||
+ | ===== Entity List ===== | ||
+ | The entity list is an array of structs ehich spawn objects as kirby gets in range. It is terminated by an 0x99999999 marker. | ||
+ | See [[kirby64_the_crystal_shards:entity_ids|]] for more info |