Tilted Inverted Pyramid Platform - Revision history

LCDAngel99 at 22:48, 16 March 2026

2026-03-16T22:48:00Z

← Older revision		Revision as of 22:48, 16 March 2026
Line 19:		Line 19:
	\|coins=		\|coins=
	}}		}}
	Tilted Inverted Pyramid Platforms are a type of platform object appearing in [[Lethal Lava Land]] and [[Bowser in the Fire Sea]]. The platform ~~basically~~ tilts and moves Mario with it.		Tilted Inverted Pyramid Platforms are a type of platform object appearing in [[Lethal Lava Land]] and [[Bowser in the Fire Sea]]. The platform tilts and moves Mario with it.

	==Behavior==		==Behavior==
	The Tilting Inverted Pyramid creates a transformation matrix using its x,y,z coordinates and its x,y,z normal. The pyramid is initialized with x and z-normals of 0, and a y-normal of 1, so that the pyramid will always spawn in with its flat portion facing directly upwards. Once the pyramid is initialized, it behaves by calculating new normals when Mario is standing on it and then tilts and moves Mario with it. When Mario is on the platform, a matrix is formed from the difference between Mario’s x,y,z coordinates and the platforms x,y,z coordinates. This matrix is then multiplied by the transformation matrix to give a new matrix encoding Mario’s position before the platform rotates. The game calculates an approximate distance between Mario’s position and the platform’s position by the usual distance formula √(dx^2+dy^2+dz^2 ), where dx,dz represent the difference between Mario and the platform’s x and z coordinates, and dy is always assumed to be 500. The game then calculates new normal for the pyramid by scaling each factor dx,dy,dz by the approximate distance. Once the new target normals are calculated, the pyramid approaches these values by incrementing the current normal by .01 until they reach a final target normal. Every time the pyramids normals are updated, the platform’s orientation is updated to match. Finally, if Mario is on the pyramid, the game creates a new matrix encoding Mario’s expected new position on the platform and uses the difference between it and the previous position matrix to update Mario’s position.		The Tilting Inverted Pyramid creates a transformation matrix using its x,y,z coordinates and its x,y,z normal. The pyramid is initialized with x and z-normals of 0, and a y-normal of 1, so that the pyramid will always spawn in with its flat portion facing directly upwards. Once the pyramid is initialized, it behaves by calculating new normals when Mario is standing on it and then tilts and moves Mario with it. When Mario is on the platform, a matrix is formed from the difference between Mario’s x,y,z coordinates and the platforms x,y,z coordinates. This matrix is then multiplied by the transformation matrix to give a new matrix encoding Mario’s position before the platform rotates. The game calculates an approximate distance between Mario’s position and the platform’s position by the usual distance formula √(dx^2+dy^2+dz^2 ), where dx,dz represent the difference between Mario and the platform’s x and z coordinates, and dy is always assumed to be 500. The game then calculates new normal for the pyramid by scaling each factor dx,dy,dz by the approximate distance. Once the new target normals are calculated, the pyramid approaches these values by incrementing the current normal by .01 until they reach a final target normal. Every time the pyramids normals are updated, the platform’s orientation is updated to match. Finally, if Mario is on the pyramid, the game creates a new matrix encoding Mario’s expected new position on the platform and uses the difference between it and the previous position matrix to update Mario’s position.

Jongyon7192p at 06:42, 23 November 2022

2022-11-23T06:42:12Z

← Older revision		Revision as of 06:42, 23 November 2022
Line 19:		Line 19:
	\|coins=		\|coins=
	}}		}}
	Tilted Inverted Pyramid Platforms are a type of platform object appearing in [[Lethal Lava Land]] and [[Bowser in ~~The~~ Fire Sea]]. The platform basically tilts and moves Mario with it.		Tilted Inverted Pyramid Platforms are a type of platform object appearing in [[Lethal Lava Land]] and [[Bowser in the Fire Sea]]. The platform basically tilts and moves Mario with it.
	==Behavior==		==Behavior==
	The Tilting Inverted Pyramid creates a transformation matrix using its x,y,z coordinates and its x,y,z normal. The pyramid is initialized with x and z-normals of 0, and a y-normal of 1, so that the pyramid will always spawn in with its flat portion facing directly upwards. Once the pyramid is initialized, it behaves by calculating new normals when Mario is standing on it and then tilts and moves Mario with it. When Mario is on the platform, a matrix is formed from the difference between Mario’s x,y,z coordinates and the platforms x,y,z coordinates. This matrix is then multiplied by the transformation matrix to give a new matrix encoding Mario’s position before the platform rotates. The game calculates an approximate distance between Mario’s position and the platform’s position by the usual distance formula √(dx^2+dy^2+dz^2 ), where dx,dz represent the difference between Mario and the platform’s x and z coordinates, and dy is always assumed to be 500. The game then calculates new normal for the pyramid by scaling each factor dx,dy,dz by the approximate distance. Once the new target normals are calculated, the pyramid approaches these values by incrementing the current normal by .01 until they reach a final target normal. Every time the pyramids normals are updated, the platform’s orientation is updated to match. Finally, if Mario is on the pyramid, the game creates a new matrix encoding Mario’s expected new position on the platform and uses the difference between it and the previous position matrix to update Mario’s position.		The Tilting Inverted Pyramid creates a transformation matrix using its x,y,z coordinates and its x,y,z normal. The pyramid is initialized with x and z-normals of 0, and a y-normal of 1, so that the pyramid will always spawn in with its flat portion facing directly upwards. Once the pyramid is initialized, it behaves by calculating new normals when Mario is standing on it and then tilts and moves Mario with it. When Mario is on the platform, a matrix is formed from the difference between Mario’s x,y,z coordinates and the platforms x,y,z coordinates. This matrix is then multiplied by the transformation matrix to give a new matrix encoding Mario’s position before the platform rotates. The game calculates an approximate distance between Mario’s position and the platform’s position by the usual distance formula √(dx^2+dy^2+dz^2 ), where dx,dz represent the difference between Mario and the platform’s x and z coordinates, and dy is always assumed to be 500. The game then calculates new normal for the pyramid by scaling each factor dx,dy,dz by the approximate distance. Once the new target normals are calculated, the pyramid approaches these values by incrementing the current normal by .01 until they reach a final target normal. Every time the pyramids normals are updated, the platform’s orientation is updated to match. Finally, if Mario is on the pyramid, the game creates a new matrix encoding Mario’s expected new position on the platform and uses the difference between it and the previous position matrix to update Mario’s position.

Jongyon7192p: /* References */ Maybe you'll revert this change cuz you don't need this, but I do. Especially idk where the tilt inaccuracy bug occurs

2022-11-22T17:48:53Z

References: Maybe you'll revert this change cuz you don't need this, but I do. Especially idk where the tilt inaccuracy bug occurs

← Older revision		Revision as of 17:48, 22 November 2022
Line 23:		Line 23:
	The Tilting Inverted Pyramid creates a transformation matrix using its x,y,z coordinates and its x,y,z normal. The pyramid is initialized with x and z-normals of 0, and a y-normal of 1, so that the pyramid will always spawn in with its flat portion facing directly upwards. Once the pyramid is initialized, it behaves by calculating new normals when Mario is standing on it and then tilts and moves Mario with it. When Mario is on the platform, a matrix is formed from the difference between Mario’s x,y,z coordinates and the platforms x,y,z coordinates. This matrix is then multiplied by the transformation matrix to give a new matrix encoding Mario’s position before the platform rotates. The game calculates an approximate distance between Mario’s position and the platform’s position by the usual distance formula √(dx^2+dy^2+dz^2 ), where dx,dz represent the difference between Mario and the platform’s x and z coordinates, and dy is always assumed to be 500. The game then calculates new normal for the pyramid by scaling each factor dx,dy,dz by the approximate distance. Once the new target normals are calculated, the pyramid approaches these values by incrementing the current normal by .01 until they reach a final target normal. Every time the pyramids normals are updated, the platform’s orientation is updated to match. Finally, if Mario is on the pyramid, the game creates a new matrix encoding Mario’s expected new position on the platform and uses the difference between it and the previous position matrix to update Mario’s position.		The Tilting Inverted Pyramid creates a transformation matrix using its x,y,z coordinates and its x,y,z normal. The pyramid is initialized with x and z-normals of 0, and a y-normal of 1, so that the pyramid will always spawn in with its flat portion facing directly upwards. Once the pyramid is initialized, it behaves by calculating new normals when Mario is standing on it and then tilts and moves Mario with it. When Mario is on the platform, a matrix is formed from the difference between Mario’s x,y,z coordinates and the platforms x,y,z coordinates. This matrix is then multiplied by the transformation matrix to give a new matrix encoding Mario’s position before the platform rotates. The game calculates an approximate distance between Mario’s position and the platform’s position by the usual distance formula √(dx^2+dy^2+dz^2 ), where dx,dz represent the difference between Mario and the platform’s x and z coordinates, and dy is always assumed to be 500. The game then calculates new normal for the pyramid by scaling each factor dx,dy,dz by the approximate distance. Once the new target normals are calculated, the pyramid approaches these values by incrementing the current normal by .01 until they reach a final target normal. Every time the pyramids normals are updated, the platform’s orientation is updated to match. Finally, if Mario is on the pyramid, the game creates a new matrix encoding Mario’s expected new position on the platform and uses the difference between it and the previous position matrix to update Mario’s position.
	==References==		==References==
			https://github.com/n64decomp/sm64/blob/1372ae1bb7cbedc03df366393188f4f05dcfc422/src/game/behaviors/tilting_inverted_pyramid.inc.c

			[https://github.com/n64decomp/sm64/blob/f9982e0ef5891d2b3e4381c305c80f7d86166e85/src/engine/math_util.c#L374 mtxf_align_terrain_normal(transform, normal, pos, 0);]

			[https://github.com/n64decomp/sm64/blob/1372ae1bb7cbedc03df366393188f4f05dcfc422/src/game/object_helpers.c#L652 linear_mtxf_mul_vec3f(*transform, posAfterRotation, dist);]
	[[Category:Objects]]		[[Category:Objects]]
	{{objects}}		{{objects}}

Jongyon7192p: (joke)

2022-11-22T17:43:30Z

(joke)

← Older revision		Revision as of 17:43, 22 November 2022
Line 22:		Line 22:
	==Behavior==		==Behavior==
	The Tilting Inverted Pyramid creates a transformation matrix using its x,y,z coordinates and its x,y,z normal. The pyramid is initialized with x and z-normals of 0, and a y-normal of 1, so that the pyramid will always spawn in with its flat portion facing directly upwards. Once the pyramid is initialized, it behaves by calculating new normals when Mario is standing on it and then tilts and moves Mario with it. When Mario is on the platform, a matrix is formed from the difference between Mario’s x,y,z coordinates and the platforms x,y,z coordinates. This matrix is then multiplied by the transformation matrix to give a new matrix encoding Mario’s position before the platform rotates. The game calculates an approximate distance between Mario’s position and the platform’s position by the usual distance formula √(dx^2+dy^2+dz^2 ), where dx,dz represent the difference between Mario and the platform’s x and z coordinates, and dy is always assumed to be 500. The game then calculates new normal for the pyramid by scaling each factor dx,dy,dz by the approximate distance. Once the new target normals are calculated, the pyramid approaches these values by incrementing the current normal by .01 until they reach a final target normal. Every time the pyramids normals are updated, the platform’s orientation is updated to match. Finally, if Mario is on the pyramid, the game creates a new matrix encoding Mario’s expected new position on the platform and uses the difference between it and the previous position matrix to update Mario’s position.		The Tilting Inverted Pyramid creates a transformation matrix using its x,y,z coordinates and its x,y,z normal. The pyramid is initialized with x and z-normals of 0, and a y-normal of 1, so that the pyramid will always spawn in with its flat portion facing directly upwards. Once the pyramid is initialized, it behaves by calculating new normals when Mario is standing on it and then tilts and moves Mario with it. When Mario is on the platform, a matrix is formed from the difference between Mario’s x,y,z coordinates and the platforms x,y,z coordinates. This matrix is then multiplied by the transformation matrix to give a new matrix encoding Mario’s position before the platform rotates. The game calculates an approximate distance between Mario’s position and the platform’s position by the usual distance formula √(dx^2+dy^2+dz^2 ), where dx,dz represent the difference between Mario and the platform’s x and z coordinates, and dy is always assumed to be 500. The game then calculates new normal for the pyramid by scaling each factor dx,dy,dz by the approximate distance. Once the new target normals are calculated, the pyramid approaches these values by incrementing the current normal by .01 until they reach a final target normal. Every time the pyramids normals are updated, the platform’s orientation is updated to match. Finally, if Mario is on the pyramid, the game creates a new matrix encoding Mario’s expected new position on the platform and uses the difference between it and the previous position matrix to update Mario’s position.

	Except this isn't how it behaves. If it did, then Mario would always be displaced downwards, but sometimes he can be displaced upwards. The cause of this is either lost, unknown, or only known in the SM64 TAS discord.
	==References==		==References==
	[[Category:Objects]]		[[Category:Objects]]
	{{objects}}		{{objects}}

Jongyon7192p: fucking fuck (joke)

2022-11-22T17:43:11Z

fucking fuck (joke)

← Older revision		Revision as of 17:43, 22 November 2022
Line 20:		Line 20:
	}}		}}
	Tilted Inverted Pyramid Platforms are a type of platform object appearing in [[Lethal Lava Land]] and [[Bowser in The Fire Sea]]. The platform basically tilts and moves Mario with it.		Tilted Inverted Pyramid Platforms are a type of platform object appearing in [[Lethal Lava Land]] and [[Bowser in The Fire Sea]]. The platform basically tilts and moves Mario with it.

	==Behavior==		==Behavior==
	The Tilting Inverted Pyramid creates a transformation matrix using its x,y,z coordinates and its x,y,z normal. The pyramid is initialized with x and z-normals of 0, and a y-normal of 1, so that the pyramid will always spawn in with its flat portion facing directly upwards. Once the pyramid is initialized, it behaves by calculating new normals when Mario is standing on it and then tilts and moves Mario with it. When Mario is on the platform, a matrix is formed from the difference between Mario’s x,y,z coordinates and the platforms x,y,z coordinates. This matrix is then multiplied by the transformation matrix to give a new matrix encoding Mario’s position before the platform rotates. The game calculates an approximate distance between Mario’s position and the platform’s position by the usual distance formula √(dx^2+dy^2+dz^2 ), where dx,dz represent the difference between Mario and the platform’s x and z coordinates, and dy is always assumed to be 500. The game then calculates new normal for the pyramid by scaling each factor dx,dy,dz by the approximate distance. Once the new target normals are calculated, the pyramid approaches these values by incrementing the current normal by .01 until they reach a final target normal. Every time the pyramids normals are updated, the platform’s orientation is updated to match. Finally, if Mario is on the pyramid, the game creates a new matrix encoding Mario’s expected new position on the platform and uses the difference between it and the previous position matrix to update Mario’s position.		The Tilting Inverted Pyramid creates a transformation matrix using its x,y,z coordinates and its x,y,z normal. The pyramid is initialized with x and z-normals of 0, and a y-normal of 1, so that the pyramid will always spawn in with its flat portion facing directly upwards. Once the pyramid is initialized, it behaves by calculating new normals when Mario is standing on it and then tilts and moves Mario with it. When Mario is on the platform, a matrix is formed from the difference between Mario’s x,y,z coordinates and the platforms x,y,z coordinates. This matrix is then multiplied by the transformation matrix to give a new matrix encoding Mario’s position before the platform rotates. The game calculates an approximate distance between Mario’s position and the platform’s position by the usual distance formula √(dx^2+dy^2+dz^2 ), where dx,dz represent the difference between Mario and the platform’s x and z coordinates, and dy is always assumed to be 500. The game then calculates new normal for the pyramid by scaling each factor dx,dy,dz by the approximate distance. Once the new target normals are calculated, the pyramid approaches these values by incrementing the current normal by .01 until they reach a final target normal. Every time the pyramids normals are updated, the platform’s orientation is updated to match. Finally, if Mario is on the pyramid, the game creates a new matrix encoding Mario’s expected new position on the platform and uses the difference between it and the previous position matrix to update Mario’s position.

			Except this isn't how it behaves. If it did, then Mario would always be displaced downwards, but sometimes he can be displaced upwards. The cause of this is either lost, unknown, or only known in the SM64 TAS discord.
	==References==		==References==

	[[Category:Objects]]		[[Category:Objects]]
	{{objects}}		{{objects}}

Macrepeh at 05:01, 13 January 2022

2022-01-13T05:01:02Z

← Older revision		Revision as of 05:01, 13 January 2022
Line 22:		Line 22:

	==Behavior==		==Behavior==
			The Tilting Inverted Pyramid creates a transformation matrix using its x,y,z coordinates and its x,y,z normal. The pyramid is initialized with x and z-normals of 0, and a y-normal of 1, so that the pyramid will always spawn in with its flat portion facing directly upwards. Once the pyramid is initialized, it behaves by calculating new normals when Mario is standing on it and then tilts and moves Mario with it. When Mario is on the platform, a matrix is formed from the difference between Mario’s x,y,z coordinates and the platforms x,y,z coordinates. This matrix is then multiplied by the transformation matrix to give a new matrix encoding Mario’s position before the platform rotates. The game calculates an approximate distance between Mario’s position and the platform’s position by the usual distance formula √(dx^2+dy^2+dz^2 ), where dx,dz represent the difference between Mario and the platform’s x and z coordinates, and dy is always assumed to be 500. The game then calculates new normal for the pyramid by scaling each factor dx,dy,dz by the approximate distance. Once the new target normals are calculated, the pyramid approaches these values by incrementing the current normal by .01 until they reach a final target normal. Every time the pyramids normals are updated, the platform’s orientation is updated to match. Finally, if Mario is on the pyramid, the game creates a new matrix encoding Mario’s expected new position on the platform and uses the difference between it and the previous position matrix to update Mario’s position.
	==References==		==References==

	[[Category:Objects]]		[[Category:Objects]]
	{{objects}}		{{objects}}

Macrepeh: Created page with "{{object_infobox_2 |title= Tilting Inverted Pyramid Platform |image= STROOP- LLL Tilting Inverted Pyramid Platform.png |group= Surface |group2 = |tangibility= |draw= |gravity=..."

2022-01-08T21:54:40Z

Created page with "{{object_infobox_2 |title= Tilting Inverted Pyramid Platform |image= STROOP- LLL Tilting Inverted Pyramid Platform.png |group= Surface |group2 = |tangibility= |draw= |gravity=..."

New page

{{object_infobox_2
|title= Tilting Inverted Pyramid Platform
|image= STROOP- LLL Tilting Inverted Pyramid Platform.png
|group= Surface
|group2 =
|tangibility=
|draw=
|gravity=
|friction=
|buoyancy=
|interaction=
|damage=
|health=
|radius=
|height=
|hurtbox_radius=
|hurtbox_height=
|offset=
|coins=
}}
Tilted Inverted Pyramid Platforms are a type of platform object appearing in [[Lethal Lava Land]] and [[Bowser in The Fire Sea]]. The platform basically tilts and moves Mario with it.

==Behavior==

==References==

[[Category:Objects]]
{{objects}}