diff --git a/include/structs.h b/include/structs.h
index 2fc746ce..c7110a91 100644
--- a/include/structs.h
+++ b/include/structs.h
@@ -152,6 +152,13 @@ typedef struct DrawTexture {
     s16 yOffset; // Offset from the center of the screen.
 } DrawTexture;
 
+// Probably not unique to the boot menu.
+typedef struct ShadowHeapProperties {
+  TextureHeader *texture; // Pointer to texture to draw.
+  s16 triCount; // Offset from the center of the screen.
+  s16 vtxCount; // Offset from the center of the screen.
+} ShadowHeapProperties;
+
 typedef struct Sprite {
   /* 0x00 */ s16 baseTextureId;
   /* 0x02 */ s16 numberOfFrames; // 1 means static texture
@@ -791,10 +798,10 @@ typedef struct ObjectHeader {
   /* 0x40 */ s16 shadeAngleZ;
   /* 0x42 */ s16 unk42;
   /* 0x44 */ s16 unk44;
-  /* 0x48 */ s16 unk46;
-  /* 0x48 */ s16 unk48;
-  /* 0x4A */ s16 unk4A;
-  /* 0x4C */ s16 unk4C;
+  /* 0x48 */ s16 shadowBottom; // Lower bounds for shadow
+  /* 0x48 */ s16 shadowTop; // Upper bounds for shadow
+  /* 0x4A */ s16 shadowFadeMin; // Close reference distance for shadow opacity
+  /* 0x4C */ s16 shadowFadeMax; // Far reference distance for shadow opacity
   /* 0x4E */ s16 drawDistance;
   /* 0x50 */ s16 unk50;
   /* 0x52 */ s8 unk52;
diff --git a/src/menu.c b/src/menu.c
index bb5c17b9..7e33a5fd 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -5610,9 +5610,11 @@ void pakmenu_render(UNUSED s32 updateRate) {
         set_dialogue_font(6, ASSET_FONTS_FUNFONT);
         set_current_text_colour(6, 255, 255, 255, 0, 255);
         set_current_text_background_colour(6, 0, 0, 0, 0);
-        render_dialogue_text(6, POS_CENTRED, 2 - PAKMENU_JP_OFFSET, gMenuText[ASSET_MENU_TEXT_CONTPAK1 + gMenuOption], 1,
+        render_dialogue_text(6, POS_CENTRED, 2 - PAKMENU_JP_OFFSET, gMenuText[ASSET_MENU_TEXT_CONTPAK1 + gMenuOption],
+                             1,
                              HORZ_ALIGN_CENTER); // CONTROLLER PAK 1 / 2 / 3 / 4
-        render_dialogue_text(6, POS_CENTRED, 16 - PAKMENU_JP_OFFSET, gMenuText[ASSET_MENU_TEXT_FREEPAGESX], sCurrentControllerPakFreePages,
+        render_dialogue_text(6, POS_CENTRED, 16 - PAKMENU_JP_OFFSET, gMenuText[ASSET_MENU_TEXT_FREEPAGESX],
+                             sCurrentControllerPakFreePages,
                              HORZ_ALIGN_CENTER); // FREE PAGES: ~
         render_dialogue_box(&sMenuCurrDisplayList, NULL, NULL, 6);
 
diff --git a/src/textures_sprites.h b/src/textures_sprites.h
index a74c21b0..551d704b 100644
--- a/src/textures_sprites.h
+++ b/src/textures_sprites.h
@@ -95,6 +95,15 @@ typedef enum TransFlags {
     OBJ_FLAGS_DEACTIVATED =         (1 << 15)  // Object is invisible and inactive.
 } TransFlags;
 
+typedef enum HeaderFlags {
+    HEADER_FLAGS_NONE,
+    HEADER_FLAGS_UNK_0001 = (1 << 0),
+    HEADER_FLAGS_UNK_0002 = (1 << 1),
+    HEADER_FLAGS_UNK_0004 = (1 << 2),
+    HEADER_FLAGS_UNK_0008 = (1 << 3),
+    HEADER_FLAGS_WATER_EFFECT = (1 << 4),
+} HeaderFlags;
+
 #define TEX_TABLE_2D 0
 #define TEX_TABLE_3D 1
 
diff --git a/src/tracks.c b/src/tracks.c
index dc57d646..8792558a 100644
--- a/src/tracks.c
+++ b/src/tracks.c
@@ -76,8 +76,8 @@ UNUSED s32 gIsNearCurrBBox; // Set to true if the current visible segment is clo
 UNUSED s32 D_8011B0C0;      // Set to 0 then never read.
 UNUSED s32 gDisableShadows; // Never not 0.
 s32 gShadowHeapFlip;        // Flips between 0 and 1 to prevent incorrect access between frames.
-s32 D_8011B0CC;
 s32 gShadowIndex;
+s32 gWaterEffectIndex;
 s32 gSceneStartSegment;
 s32 D_8011B0D8;
 s32 gSceneRenderSkyDome;
@@ -110,16 +110,16 @@ s32 D_8011C3B8[320];
 s32 D_8011C8B8[512];
 s32 D_8011D0B8;
 Vec4f *D_8011D0BC;
-TextureHeader *D_8011D0C0;
-Object *D_8011D0C4;
+TextureHeader *gNewShadowTexture;
+Object *gNewShadowObj;
 f32 D_8011D0C8;
-s16 D_8011D0CC;
-s16 D_8011D0CE;
+s16 gNewShadowY1;
+s16 gNewShadowY2;
 s16 D_8011D0D0;
 f32 gShadowOpacity;
-f32 D_8011D0D8;
-f32 D_8011D0DC;
-f32 D_8011D0E0;
+f32 gNewShadowScale;
+f32 gNewShadowWidth;
+f32 gNewShadowLength;
 f32 D_8011D0E4;
 s32 D_8011D0E8;
 s32 D_8011D0EC;
@@ -134,21 +134,21 @@ WaterProperties *gTrackWaves[20];
 s8 D_8011D308;
 LevelModel *gTrackModelHeap;
 s32 *gLevelModelTable;
-UNUSED f32 gPrevCameraX; // Set but never read
-UNUSED f32 gPrevCameraY; // Set but never read
-UNUSED f32 gPrevCameraZ; // Set but never read
-Triangle *gShadowHeapTris[4];
-Triangle *gCurrentShadowTris;
+UNUSED f32 gPrevCameraX;          // Set but never read
+UNUSED f32 gPrevCameraY;          // Set but never read
+UNUSED f32 gPrevCameraZ;          // Set but never read
+Triangle *gShadowHeapTris[2 * 2]; // Triangle Data for shadows
+Triangle *gCurrShadowTris;
 UNUSED s32 D_8011D334;
-Vertex *gShadowHeapVerts[4];
-Vertex *gCurrentShadowVerts;
+Vertex *gShadowHeapVerts[2 * 2]; // Vertex Data for shadows
+Vertex *gCurrShadowVerts;
 UNUSED s32 D_8011D34C;
-DrawTexture *gShadowHeapTextures[4];
-DrawTexture *gCurrentShadowTexture;
-s32 D_8011D364;
-s32 D_8011D368;   // xOffset?
-s32 D_8011D36C;   // yOffset?
-u16 **D_8011D370; // Allocated 0x7D0
+ShadowHeapProperties *gShadowHeapData[2 * 2]; // General data for shadows. Texture and geometry size.
+ShadowHeapProperties *gCurrShadowHeapData;
+s32 gShadowTail;        // Position in the heap the shadow data ends at.
+s32 gNewShadowTriCount; // xOffset?
+s32 gNewShadowVtxCount; // yOffset?
+u16 **D_8011D370;       // Allocated 0x7D0
 s32 *D_8011D374;
 s32 D_8011D378;
 s32 gScenePlayerViewports;
@@ -261,18 +261,20 @@ void init_track(u32 geometry, u32 skybox, s32 numberOfPlayers, Vehicle vehicle,
 
     numberOfPlayers = gScenePlayerViewports;
     gAntiAliasing = FALSE;
-    for (i = 0; i < ARRAY_COUNT(gShadowHeapTextures); i++) {
-        gShadowHeapTextures[i] = (DrawTexture *) mempool_alloc_safe(sizeof(DrawTexture) * 400, COLOUR_TAG_YELLOW);
+    // All shadow groups are double buffered. Environment shadows never change, so they could've single buffered them.
+    for (i = 0; i < ARRAY_COUNT(gShadowHeapData); i++) {
+        gShadowHeapData[i] =
+            (ShadowHeapProperties *) mempool_alloc_safe(sizeof(ShadowHeapProperties) * 400, COLOUR_TAG_YELLOW);
         gShadowHeapTris[i] = (Triangle *) mempool_alloc_safe(sizeof(Triangle) * 800, COLOUR_TAG_YELLOW);
         gShadowHeapVerts[i] = (Vertex *) mempool_alloc_safe(sizeof(Vertex) * 2000, COLOUR_TAG_YELLOW);
     }
 
     gShadowHeapFlip = 0;
-    update_shadows(SHADOW_SCENERY, SHADOW_SCENERY, LOGIC_NULL);
-    update_shadows(SHADOW_ACTORS, SHADOW_ACTORS, LOGIC_NULL);
+    shadow_update(SHADOW_SCENERY, SHADOW_SCENERY, LOGIC_NULL);
+    shadow_update(SHADOW_ACTORS, SHADOW_ACTORS, LOGIC_NULL);
     gShadowHeapFlip = 1;
-    update_shadows(SHADOW_SCENERY, SHADOW_SCENERY, LOGIC_NULL);
-    update_shadows(SHADOW_ACTORS, SHADOW_ACTORS, LOGIC_NULL);
+    shadow_update(SHADOW_SCENERY, SHADOW_SCENERY, LOGIC_NULL);
+    shadow_update(SHADOW_ACTORS, SHADOW_ACTORS, LOGIC_NULL);
     gShadowHeapFlip = 0;
     if (gCurrentLevelHeader2->unkB7) {
         D_8011B0E1 = gCurrentLevelHeader2->unkB4;
@@ -312,7 +314,7 @@ void render_scene(Gfx **dList, MatrixS **mtx, Vertex **vtx, Triangle **tris, s32
     if (gWaveBlockCount) {
         func_800B9C18(tempUpdateRate);
     }
-    update_shadows(SHADOW_ACTORS, SHADOW_ACTORS, updateRate);
+    shadow_update(SHADOW_ACTORS, SHADOW_ACTORS, updateRate);
     for (i = 0; i < 7; i++) {
         if ((s32) gCurrentLevelHeader2->unk74[i] != -1) {
             update_colour_cycle(gCurrentLevelHeader2->unk74[i], tempUpdateRate);
@@ -1450,11 +1452,11 @@ void render_level_geometry_and_objects(void) {
                 render_object(&gSceneCurrDisplayList, &gSceneCurrMatrix, &gSceneCurrVertexList, obj);
                 continue;
             } else if (obj->shadow != NULL) {
-                render_object_shadow(obj, obj->shadow);
+                shadow_render(obj, obj->shadow);
             }
             render_object(&gSceneCurrDisplayList, &gSceneCurrMatrix, &gSceneCurrVertexList, obj);
-            if (obj->waterEffect != NULL && obj->segment.header->flags & 0x10) {
-                render_object_water_effects(obj, obj->waterEffect);
+            if (obj->waterEffect != NULL && obj->segment.header->flags & HEADER_FLAGS_WATER_EFFECT) {
+                watereffect_render(obj, obj->waterEffect);
             }
         }
     }
@@ -1473,11 +1475,11 @@ void render_level_geometry_and_objects(void) {
                 render_object(&gSceneCurrDisplayList, &gSceneCurrMatrix, &gSceneCurrVertexList, obj);
                 continue;
             } else if (obj->shadow != NULL) {
-                render_object_shadow(obj, obj->shadow);
+                shadow_render(obj, obj->shadow);
             }
             render_object(&gSceneCurrDisplayList, &gSceneCurrMatrix, &gSceneCurrVertexList, obj);
-            if ((obj->waterEffect != NULL) && (obj->segment.header->flags & 0x10)) {
-                render_object_water_effects(obj, obj->waterEffect);
+            if (obj->waterEffect != NULL && obj->segment.header->flags & HEADER_FLAGS_WATER_EFFECT) {
+                watereffect_render(obj, obj->waterEffect);
             }
         }
     }
@@ -1519,11 +1521,11 @@ void render_level_geometry_and_objects(void) {
                     render_object(&gSceneCurrDisplayList, &gSceneCurrMatrix, &gSceneCurrVertexList, obj);
                     goto skip;
                 } else if (obj->shadow != NULL) {
-                    render_object_shadow(obj, obj->shadow);
+                    shadow_render(obj, obj->shadow);
                 }
                 render_object(&gSceneCurrDisplayList, &gSceneCurrMatrix, &gSceneCurrVertexList, obj);
                 if ((obj->waterEffect != 0) && (obj->segment.header->flags & 0x10)) {
-                    render_object_water_effects(obj, obj->waterEffect);
+                    watereffect_render(obj, obj->waterEffect);
                 }
             }
         skip:
@@ -2456,8 +2458,8 @@ void free_track(void) {
     mempool_free(D_8011D370);
     mempool_free(D_8011D374);
     free_sprite((Sprite *) gCurrentLevelModel->minimapSpriteIndex);
-    for (i = 0; i < MAXCONTROLLERS; i++) {
-        mempool_free(gShadowHeapTextures[i]);
+    for (i = 0; i < ARRAY_COUNT(gShadowHeapData); i++) {
+        mempool_free(gShadowHeapData[i]);
         mempool_free(gShadowHeapTris[i]);
         mempool_free(gShadowHeapVerts[i]);
     }
@@ -2581,30 +2583,30 @@ void trackMakeAbsolute(unk8002D30C_a0 *arg0, s32 arg1) {
  * Render the shadow of an object on the ground as a decal.
  * Can subdivide itself to wrap around the terrain properly, as the N64 lacks stencil buffering.
  */
-void render_object_shadow(Object *obj, ShadowData *shadow) {
+void shadow_render(Object *obj, ShadowData *shadow) {
     s32 i;
     s32 numVerts;
     s32 numTris;
     Vertex *vtx;
     Triangle *tri;
     s32 flags;
-    UNUSED s32 offsetX_2;
-    s32 offsetY_2;
-    s32 offsetY;
-    s32 offsetX;
+    UNUSED s32 tri2;
+    s32 vtx2;
+    s32 vtxCount;
+    s32 triCount;
     s32 alpha;
 
     if (obj->segment.header->shadowGroup) {
         if (shadow->meshStart != -1 && gDisableShadows == FALSE) {
-            D_8011B0CC = gShadowHeapFlip;
+            gShadowIndex = gShadowHeapFlip;
             if (obj->segment.header->shadowGroup == SHADOW_SCENERY) {
-                D_8011B0CC += 2;
+                gShadowIndex += 2;
             }
             i = shadow->meshStart;
-            gCurrentShadowTexture = gShadowHeapTextures[D_8011B0CC];
-            gCurrentShadowTris = gShadowHeapTris[D_8011B0CC];
-            gCurrentShadowVerts = gShadowHeapVerts[D_8011B0CC];
-            alpha = gCurrentShadowVerts[gCurrentShadowTexture[i].yOffset].a;
+            gCurrShadowHeapData = gShadowHeapData[gShadowIndex];
+            gCurrShadowTris = gShadowHeapTris[gShadowIndex];
+            gCurrShadowVerts = gShadowHeapVerts[gShadowIndex];
+            alpha = gCurrShadowVerts[gCurrShadowHeapData[i].vtxCount].a;
             flags = RENDER_FOG_ACTIVE | RENDER_Z_COMPARE;
             if (alpha == 0 || obj->segment.object.opacity == 0) {
                 i = shadow->meshEnd; // It'd be easier to just return...
@@ -2614,14 +2616,14 @@ void render_object_shadow(Object *obj, ShadowData *shadow) {
                 gDPSetPrimColor(gSceneCurrDisplayList++, 0, 0, 255, 255, 255, alpha);
             }
             while (i < shadow->meshEnd) {
-                load_and_set_texture_no_offset(&gSceneCurrDisplayList, gCurrentShadowTexture[i].texture, flags);
+                load_and_set_texture_no_offset(&gSceneCurrDisplayList, gCurrShadowHeapData[i].texture, flags);
                 // I hope we can clean this part up.
-                offsetX_2 = offsetX = gCurrentShadowTexture[i].xOffset; // Fakematch
-                offsetY_2 = offsetY = gCurrentShadowTexture[i].yOffset;
-                numTris = gCurrentShadowTexture[i + 1].xOffset - offsetX;
-                numVerts = gCurrentShadowTexture[i + 1].yOffset - offsetY;
-                tri = &gCurrentShadowTris[offsetX];
-                vtx = &gCurrentShadowVerts[offsetY_2];
+                tri2 = triCount = gCurrShadowHeapData[i].triCount; // Fakematch
+                vtx2 = vtxCount = gCurrShadowHeapData[i].vtxCount;
+                numTris = gCurrShadowHeapData[i + 1].triCount - triCount;
+                numVerts = gCurrShadowHeapData[i + 1].vtxCount - vtxCount;
+                tri = &gCurrShadowTris[triCount];
+                vtx = &gCurrShadowVerts[vtx2];
                 gSPVertexDKR(gSceneCurrDisplayList++, OS_K0_TO_PHYSICAL(vtx), numVerts, 0);
                 gSPPolygon(gSceneCurrDisplayList++, OS_K0_TO_PHYSICAL(tri), numTris, 1);
                 i++;
@@ -2638,40 +2640,39 @@ void render_object_shadow(Object *obj, ShadowData *shadow) {
  * Used only by cars, render a texture on the surface of the water where the car is
  * to give the wave effect. Works almost identically to shadows, since water can be wavy.
  */
-void render_object_water_effects(Object *obj, WaterEffect *effect) {
+void watereffect_render(Object *obj, WaterEffect *effect) {
     s32 i;
     s32 numVerts;
     s32 numTris;
     Vertex *vtx;
     Triangle *tri;
     s32 flags;
-    UNUSED s32 offsetX;
-    UNUSED s32 offsetY;
+    UNUSED s32 triCount;
+    UNUSED s32 vtxCount;
 
     if (obj->segment.header->waterEffectGroup) {
         if (effect->meshStart != -1 && gDisableShadows == FALSE) {
-            gShadowIndex = gShadowHeapFlip;
+            gWaterEffectIndex = gShadowHeapFlip;
             i = effect->meshStart;
             if (obj->segment.header->waterEffectGroup == SHADOW_SCENERY) {
-                gShadowIndex = gShadowHeapFlip;
-                gShadowIndex += 2;
+                gWaterEffectIndex += 2;
                 if (get_distance_to_active_camera(obj->segment.trans.x_position, obj->segment.trans.y_position,
                                                   obj->segment.trans.z_position) > 768.0f) {
                     i = effect->meshEnd; // Just return.
                 }
             }
             flags = RENDER_FOG_ACTIVE | RENDER_Z_COMPARE;
-            gCurrentShadowTexture = gShadowHeapTextures[gShadowIndex];
-            gCurrentShadowTris = gShadowHeapTris[gShadowIndex];
-            gCurrentShadowVerts = gShadowHeapVerts[gShadowIndex];
+            gCurrShadowHeapData = gShadowHeapData[gWaterEffectIndex];
+            gCurrShadowTris = gShadowHeapTris[gWaterEffectIndex];
+            gCurrShadowVerts = gShadowHeapVerts[gWaterEffectIndex];
             while (i < effect->meshEnd) {
-                load_and_set_texture_no_offset(&gSceneCurrDisplayList, gCurrentShadowTexture[i].texture, flags);
-                offsetX = gCurrentShadowTexture[i].xOffset; // Fakematch
-                offsetY = gCurrentShadowTexture[i].yOffset; // Fakematch
-                numTris = gCurrentShadowTexture[i + 1].xOffset - gCurrentShadowTexture[i].xOffset;
-                numVerts = gCurrentShadowTexture[i + 1].yOffset - gCurrentShadowTexture[i].yOffset;
-                tri = &gCurrentShadowTris[gCurrentShadowTexture[i].xOffset];
-                vtx = &gCurrentShadowVerts[gCurrentShadowTexture[i].yOffset];
+                load_and_set_texture_no_offset(&gSceneCurrDisplayList, gCurrShadowHeapData[i].texture, flags);
+                triCount = gCurrShadowHeapData[i].triCount; // Fakematch
+                vtxCount = gCurrShadowHeapData[i].vtxCount; // Fakematch
+                numTris = gCurrShadowHeapData[i + 1].triCount - gCurrShadowHeapData[i].triCount;
+                numVerts = gCurrShadowHeapData[i + 1].vtxCount - gCurrShadowHeapData[i].vtxCount;
+                tri = &gCurrShadowTris[gCurrShadowHeapData[i].triCount];
+                vtx = &gCurrShadowVerts[gCurrShadowHeapData[i].vtxCount];
                 gSPVertexDKR(gSceneCurrDisplayList++, OS_K0_TO_PHYSICAL(vtx), numVerts, 0);
                 gSPPolygon(gSceneCurrDisplayList++, OS_K0_TO_PHYSICAL(tri), numTris, 1);
                 i++;
@@ -2683,9 +2684,9 @@ void render_object_water_effects(Object *obj, WaterEffect *effect) {
 /**
  * Updates shadow and water effect properties for each relevant object in the scene.
  * The first argument decides whether to update shadows for static objects or moving objects.
- * Checks how many players there are before deciding whether to cast a shadow for that object.
+ * In multiplayer, only important objects get shadows.
  */
-void update_shadows(s32 group, s32 waterGroup, s32 updateRate) {
+void shadow_update(s32 group, s32 waterGroup, s32 updateRate) {
     s32 objIndex;
     s32 objectCount;
     Object *obj;
@@ -2700,16 +2701,16 @@ void update_shadows(s32 group, s32 waterGroup, s32 updateRate) {
     WaterEffect *waterEffect;
     s32 playerIndex;
 
-    D_8011B0CC = gShadowHeapFlip;
+    gShadowIndex = gShadowHeapFlip;
     if (group == SHADOW_SCENERY) {
-        D_8011B0CC += 2;
+        gShadowIndex += 2;
     }
-    gCurrentShadowTris = (Triangle *) gShadowHeapTris[D_8011B0CC];
-    gCurrentShadowVerts = (Vertex *) gShadowHeapVerts[D_8011B0CC];
-    gCurrentShadowTexture = (DrawTexture *) gShadowHeapTextures[D_8011B0CC];
-    D_8011D364 = 0;
-    D_8011D368 = 0;
-    D_8011D36C = 0;
+    gCurrShadowTris = (Triangle *) gShadowHeapTris[gShadowIndex];
+    gCurrShadowVerts = (Vertex *) gShadowHeapVerts[gShadowIndex];
+    gCurrShadowHeapData = (ShadowHeapProperties *) gShadowHeapData[gShadowIndex];
+    gShadowTail = 0;
+    gNewShadowTriCount = 0;
+    gNewShadowVtxCount = 0;
     numViewports = get_viewport_count();
     objects = objGetObjList(&objIndex, &objectCount);
     while (objIndex < objectCount) {
@@ -2717,8 +2718,8 @@ void update_shadows(s32 group, s32 waterGroup, s32 updateRate) {
         objHeader = obj->segment.header;
         waterEffect = obj->waterEffect;
         shadow = obj->shadow;
-        objIndex += 1;
-        if ((obj->segment.trans.flags & OBJ_FLAGS_DEACTIVATED)) {
+        objIndex++;
+        if (obj->segment.trans.flags & OBJ_FLAGS_DEACTIVATED) {
             continue;
         }
         if (shadow != NULL && shadow->scale > 0.0f && group == objHeader->shadowGroup) {
@@ -2738,24 +2739,26 @@ void update_shadows(s32 group, s32 waterGroup, s32 updateRate) {
             gShadowOpacity = 1.0f;
             shadow->meshStart = -1;
             skipShading = FALSE;
-            if (objHeader->shadowGroup == SHADOW_ACTORS && numViewports > ONE_PLAYER && numViewports <= FOUR_PLAYERS) {
+            // Multiplayer
+            if (objHeader->shadowGroup == SHADOW_ACTORS && numViewports >= TWO_PLAYERS &&
+                numViewports <= FOUR_PLAYERS) {
                 if (obj->behaviorId == BHV_RACER) {
                     playerIndex = obj->unk64->racer.playerIndex;
                     if (playerIndex != PLAYER_COMPUTER) {
-                        func_8002E234(obj, FALSE);
+                        shadow_generate(obj, FALSE);
                         skipShading = TRUE;
                     }
                 } else if (obj->behaviorId == BHV_WEAPON) {
-                    func_8002E234(obj, FALSE);
+                    shadow_generate(obj, FALSE);
                     skipShading = TRUE;
                 }
-            } else {
-                radius = objHeader->unk4A;
+            } else { // Single Player
+                radius = objHeader->shadowFadeMin;
                 if (dist < radius) {
-                    if (objHeader->unk4C < dist) {
-                        gShadowOpacity = (radius - dist) / (radius - objHeader->unk4C);
+                    if (objHeader->shadowFadeMax < dist) {
+                        gShadowOpacity = (radius - dist) / (radius - objHeader->shadowFadeMax);
                     }
-                    func_8002E234(obj, FALSE);
+                    shadow_generate(obj, FALSE);
                     skipShading = TRUE;
                 }
             }
@@ -2774,27 +2777,30 @@ void update_shadows(s32 group, s32 waterGroup, s32 updateRate) {
                 }
             }
 
-            if (objHeader->shadowGroup == SHADOW_ACTORS && numViewports > ONE_PLAYER && numViewports <= FOUR_PLAYERS) {
+            // Multiplayer
+            if (objHeader->shadowGroup == SHADOW_ACTORS && numViewports >= TWO_PLAYERS &&
+                numViewports <= FOUR_PLAYERS) {
                 if (obj->behaviorId == BHV_RACER) {
                     playerIndex = obj->unk64->racer.playerIndex;
                     if (playerIndex != PLAYER_COMPUTER) {
-                        func_8002E234(obj, TRUE);
+                        shadow_generate(obj, TRUE);
                     }
                 } else if (obj->behaviorId == BHV_WEAPON) {
-                    func_8002E234(obj, TRUE);
+                    shadow_generate(obj, TRUE);
                 }
-            } else {
-                if (dist < objHeader->unk4A) {
-                    if (objHeader->unk4C < dist) {
-                        gShadowOpacity = (objHeader->unk4A - dist) / (objHeader->unk4A - objHeader->unk4C);
+            } else { // Single Player
+                if (dist < objHeader->shadowFadeMin) {
+                    if (objHeader->shadowFadeMax < dist) {
+                        gShadowOpacity =
+                            (objHeader->shadowFadeMin - dist) / (objHeader->shadowFadeMin - objHeader->shadowFadeMax);
                     }
-                    func_8002E234(obj, TRUE);
+                    shadow_generate(obj, TRUE);
                 }
             }
         }
     }
-    gCurrentShadowTexture[D_8011D364].xOffset = D_8011D368;
-    gCurrentShadowTexture[D_8011D364].yOffset = D_8011D36C;
+    gCurrShadowHeapData[gShadowTail].triCount = gNewShadowTriCount;
+    gCurrShadowHeapData[gShadowTail].vtxCount = gNewShadowVtxCount;
 }
 
 void func_8002DE30(Object *obj) {
@@ -2858,9 +2864,12 @@ void func_8002DE30(Object *obj) {
     }
 }
 
-// Generate shadow
-void func_8002E234(Object *obj, s32 bool) {
-    f32 var_f2;
+/**
+ * Generate shadow geometry for an object.
+ * Handles water effects too, isWater is true.
+ */
+void shadow_generate(Object *obj, s32 isWater) {
+    f32 dist;
     s32 yPos;
     f32 xPos;
     f32 zPos;
@@ -2883,45 +2892,45 @@ void func_8002E234(Object *obj, s32 bool) {
         }
     }
 
-    D_8011D0C4 = obj;
+    gNewShadowObj = obj;
     D_8011D0C8 = 2.0f;
 
-    if (bool) {
+    if (isWater) {
         D_8011D0B8 = 0;
-        obj->waterEffect->meshStart = D_8011D364;
-        D_8011D0C0 = set_animated_texture_header(obj->waterEffect->texture, obj->waterEffect->textureFrame << 8);
-        D_8011D0CE = obj->segment.header->unk48 + yPos;
-        D_8011D0CC = obj->segment.header->unk46 + yPos;
-        if ((gWaveBlockCount == 0) || ((get_viewport_count() <= 0))) {
+        obj->waterEffect->meshStart = gShadowTail;
+        gNewShadowTexture = set_animated_texture_header(obj->waterEffect->texture, obj->waterEffect->textureFrame << 8);
+        gNewShadowY2 = obj->segment.header->shadowTop + yPos;
+        gNewShadowY1 = obj->segment.header->shadowBottom + yPos;
+        if (gWaveBlockCount == 0 || get_viewport_count() < VIEWPORTS_COUNT_2_PLAYERS) {
             D_8011D0C8 = 0;
         }
-        D_8011D0D8 = (obj->waterEffect->scale * character_scale);
-        D_8011D0DC = D_8011D0D8 * 10.0f;
-        D_8011D0E0 = D_8011D0D8 * 10.0f;
+        gNewShadowScale = (obj->waterEffect->scale * character_scale);
+        gNewShadowWidth = gNewShadowScale * 10.0f;
+        gNewShadowLength = gNewShadowScale * 10.0f;
         D_8011D0F0 = -1.0f;
     } else {
-        obj->shadow->meshStart = D_8011D364;
-        D_8011D0C0 = obj->shadow->texture;
-        D_8011D0CE = obj->segment.header->unk44 + yPos;
-        D_8011D0CC = obj->segment.header->unk42 + yPos;
+        obj->shadow->meshStart = gShadowTail;
+        gNewShadowTexture = obj->shadow->texture;
+        gNewShadowY2 = obj->segment.header->unk44 + yPos;
+        gNewShadowY1 = obj->segment.header->unk42 + yPos;
         if (obj->behaviorId != BHV_RACER) {
-            var_f2 = obj->segment.object.distanceToCamera;
-            if (var_f2 < 0.0) {
-                var_f2 = -var_f2;
+            dist = obj->segment.object.distanceToCamera;
+            if (dist < 0.0) {
+                dist = -dist;
             }
-            var_f2 -= 512.0;
-            if (var_f2 < 0.0) {
-                var_f2 = 0.0;
+            dist -= 512.0;
+            if (dist < 0.0) {
+                dist = 0.0;
             }
-            if (var_f2 > 1024.0) {
-                var_f2 = 1024.0;
+            if (dist > 1024.0) {
+                dist = 1024.0;
             }
-            D_8011D0C8 += (var_f2 * 0.005f);
+            D_8011D0C8 += (dist * 0.005f);
         }
-        D_8011D0D8 = (obj->shadow->scale * character_scale);
-        D_8011D0DC = D_8011D0D8 * 10.0f;
-        D_8011D0E0 = D_8011D0D8 * 10.0f;
-        D_8011D0E4 = 4.0f * D_8011D0DC * D_8011D0E0;
+        gNewShadowScale = (obj->shadow->scale * character_scale);
+        gNewShadowWidth = gNewShadowScale * 10.0f;
+        gNewShadowLength = gNewShadowScale * 10.0f;
+        D_8011D0E4 = 4.0f * gNewShadowWidth * gNewShadowLength;
         D_8011D0F0 = (obj->segment.header->unk42 * 0.125f);
         if (D_8011D0F0 < 0.0f) {
             D_8011D0F0 = -D_8011D0F0;
@@ -2929,11 +2938,11 @@ void func_8002E234(Object *obj, s32 bool) {
         D_8011D0F4 = (7.0f * D_8011D0F0);
         D_8011D0D0 = -0x8000;
     }
-    D_8011D0D8 = 144.0f / D_8011D0D8;
-    xPos = D_8011D0C4->segment.trans.x_position;
-    zPos = D_8011D0C4->segment.trans.z_position;
-    segs = get_inside_segment_count_xyz(inSegs, (xPos - D_8011D0DC), D_8011D0CC, (zPos - D_8011D0E0),
-                                        (xPos + D_8011D0DC), D_8011D0CE, (zPos + D_8011D0E0));
+    gNewShadowScale = 144.0f / gNewShadowScale;
+    xPos = gNewShadowObj->segment.trans.x_position;
+    zPos = gNewShadowObj->segment.trans.z_position;
+    segs = get_inside_segment_count_xyz(inSegs, (xPos - gNewShadowWidth), gNewShadowY1, (zPos - gNewShadowLength),
+                                        (xPos + gNewShadowWidth), gNewShadowY2, (zPos + gNewShadowLength));
     D_8011C230 = 0;
     D_8011B118 = 0;
     for (i = 0; i < ARRAY_COUNT(D_8011B320); i++) {
@@ -2943,30 +2952,30 @@ void func_8002E234(Object *obj, s32 bool) {
     D_8011D0EC = -1;
     for (i = 0; i < segs; i++) {
         if (inSegs[i] >= 0) {
-            if (bool && (gCurrentLevelModel->segments[inSegs[i]].hasWaves != 0) && (gWaveBlockCount != 0)) {
+            if (isWater && (gCurrentLevelModel->segments[inSegs[i]].hasWaves != 0) && (gWaveBlockCount != 0)) {
                 func_8002EEEC(inSegs[i]);
             } else {
                 test = func_800314DC(&gCurrentLevelModel->segmentsBoundingBoxes[inSegs[i]],
-                                     (obj->segment.trans.x_position - D_8011D0DC), // x1
-                                     (obj->segment.trans.z_position - D_8011D0E0), // z1
-                                     (obj->segment.trans.x_position + D_8011D0DC), // x2
-                                     (obj->segment.trans.z_position + D_8011D0E0)  // z2
+                                     (obj->segment.trans.x_position - gNewShadowWidth),  // x1
+                                     (obj->segment.trans.z_position - gNewShadowLength), // z1
+                                     (obj->segment.trans.x_position + gNewShadowWidth),  // x2
+                                     (obj->segment.trans.z_position + gNewShadowLength)  // z2
                 );
-                func_8002E904(&gCurrentLevelModel->segments[inSegs[i]], test, bool);
+                func_8002E904(&gCurrentLevelModel->segments[inSegs[i]], test, isWater);
             }
         }
     }
     if (D_8011C230 > 0) {
-        if ((obj->shading != NULL) && !bool) {
+        if ((obj->shading != NULL) && isWater == FALSE) {
             obj->shading->unk0 = func_8002FA64();
         }
         func_8002F2AC();
         func_8002F440();
     }
-    if (!bool) {
-        obj->shadow->meshEnd = D_8011D364;
+    if (isWater == FALSE) {
+        obj->shadow->meshEnd = gShadowTail;
     } else {
-        obj->waterEffect->meshEnd = D_8011D364;
+        obj->waterEffect->meshEnd = gShadowTail;
     }
 }
 
@@ -3107,26 +3116,26 @@ void func_800304C8(Vec4f *arg0) {
     temp = arg0[0].z;
     arg00z = temp;
     compare = 0.0f;
-    temp = (D_8011D0C4->segment.trans.z_position - arg0[1].z);
+    temp = (gNewShadowObj->segment.trans.z_position - arg0[1].z);
 
-    if ((((D_8011D0C4->segment.trans.x_position - arg0[0].x) * (arg0[1].z - arg00z)) -
-         ((arg0[1].x - arg0[0].x) * (((0, D_8011D0C4->segment.trans.z_position)) - arg00z))) >= compare) {
+    if ((((gNewShadowObj->segment.trans.x_position - arg0[0].x) * (arg0[1].z - arg00z)) -
+         ((arg0[1].x - arg0[0].x) * (((0, gNewShadowObj->segment.trans.z_position)) - arg00z))) >= compare) {
         found1 = TRUE;
     }
-    if ((((D_8011D0C4->segment.trans.x_position - arg0[1].x) * (arg0[2].z - arg0[1].z)) -
+    if ((((gNewShadowObj->segment.trans.x_position - arg0[1].x) * (arg0[2].z - arg0[1].z)) -
          (temp * (arg0[2].x - arg0[1].x))) >= compare) {
         found2 = TRUE;
     }
     arg02x = arg0[2].x;
     if (found1 == found2) {
         f32 zPosDiff = (arg00z - arg0[2].z);
-        if ((((D_8011D0C4->segment.trans.x_position - arg02x) * zPosDiff) -
+        if ((((gNewShadowObj->segment.trans.x_position - arg02x) * zPosDiff) -
              ((arg0[0].x - arg02x) * (arg02x - arg0[2].z))) >= compare) {
             found3 = TRUE;
         }
         if (found2 == found3) {
-            f32 test = (-(((D_8011D0BC->x * D_8011D0C4->segment.trans.x_position) +
-                           (D_8011D0BC->z * D_8011D0C4->segment.trans.z_position)) +
+            f32 test = (-(((D_8011D0BC->x * gNewShadowObj->segment.trans.x_position) +
+                           (D_8011D0BC->z * gNewShadowObj->segment.trans.z_position)) +
                           D_8011D0BC->w)) /
                        D_8011D0BC->y;
             if (D_8011D0D0 < test) {
diff --git a/src/tracks.h b/src/tracks.h
index f46a9621..1989eacd 100644
--- a/src/tracks.h
+++ b/src/tracks.h
@@ -169,13 +169,13 @@ s32 check_if_inside_segment(Object *obj, s32 segmentIndex);
 s32 get_level_segment_index_from_position(f32 xPos, f32 yPos, f32 zPos);
 void traverse_segments_bsp_tree(s32 nodeIndex, s32 segmentIndex, s32 segmentIndex2, u8 *segmentsOrder, s32 *segmentsOrderIndex);
 void render_level_geometry_and_objects(void);
-void render_object_water_effects(Object *obj, WaterEffect *effect);
-void render_object_shadow(Object *obj, ShadowData *shadow);
+void watereffect_render(Object *obj, WaterEffect *effect);
+void shadow_render(Object *obj, ShadowData *shadow);
 s32 should_segment_be_visible(LevelModelSegmentBoundingBox *bb);
 s32 check_if_in_draw_range(Object *obj);
 void func_8002C954(LevelModelSegment *segment, LevelModelSegmentBoundingBox *bbox, s32 arg2);
 void draw_gradient_background(void);
-void update_shadows(s32 group, s32 waterGroup, s32 updateRate);
+void shadow_update(s32 group, s32 waterGroup, s32 updateRate);
 void obj_loop_fogchanger(Object* obj);
 void initialise_player_viewport_vars(s32 updateRate);
 s32 get_wave_properties(f32 yPos, f32 *waterHeight, Vec3f *rotation);
@@ -200,7 +200,7 @@ void update_colour_cycle(LevelHeader_70 *arg0, s32 updateRate);
 void func_800B9C18(s32);
 void func_800BA8E4(Gfx**, MatrixS**, s32);
 void func_8002DE30(Object*);
-void func_8002E234(Object*, s32);
+void shadow_generate(Object*, s32);
 void func_8002E904(LevelModelSegment *, s32, s32 bool);
 void func_8002EEEC(s32 arg0);
 void func_8002F2AC(void);
diff --git a/ver/symbols/symbol_addrs.jpn.v79.txt b/ver/symbols/symbol_addrs.jpn.v79.txt
index a7538afe..d4306602 100644
--- a/ver/symbols/symbol_addrs.jpn.v79.txt
+++ b/ver/symbols/symbol_addrs.jpn.v79.txt
@@ -450,11 +450,11 @@ free_track = 0x8002C7D4;
 func_8002C954 = 0x8002C954;
 func_8002CC30 = 0x8002CC30;
 trackMakeAbsolute = 0x8002D30C;
-render_object_shadow = 0x8002D384;
-render_object_water_effects = 0x8002D670;
-update_shadows = 0x8002D8DC;
+shadow_render = 0x8002D384;
+watereffect_render = 0x8002D670;
+shadow_update = 0x8002D8DC;
 func_8002DE30 = 0x8002DE30;
-func_8002E234 = 0x8002E234;
+shadow_generate = 0x8002E234;
 func_8002E904 = 0x8002E904;
 func_8002EEEC = 0x8002EEEC;
 func_8002F2AC = 0x8002F2AC;
@@ -3714,8 +3714,8 @@ gIsNearCurrBBox = 0x8011CB2C;
 D_8011B0C0 = 0x8011CB30;
 gDisableShadows = 0x8011CB34;
 gShadowHeapFlip = 0x8011CB38;
-D_8011B0CC = 0x8011CB3C;
-gShadowIndex = 0x8011CB40;
+gShadowIndex = 0x8011CB3C;
+gWaterEffectIndex = 0x8011CB40;
 gSceneStartSegment = 0x8011CB44;
 D_8011B0D8 = 0x8011CB48;
 gSceneRenderSkyDome = 0x8011CB4C;
@@ -3748,16 +3748,16 @@ D_8011C3B8 = 0x8011DE28;
 D_8011C8B8 = 0x8011E328;
 D_8011D0B8 = 0x8011EB28;
 D_8011D0BC = 0x8011EB2C;
-D_8011D0C0 = 0x8011EB30;
-D_8011D0C4 = 0x8011EB34;
+gNewShadowTexture = 0x8011EB30;
+gNewShadowObj = 0x8011EB34;
 D_8011D0C8 = 0x8011EB38;
-D_8011D0CC = 0x8011EB3C;
-D_8011D0CE = 0x8011EB3E;
+gNewShadowY1 = 0x8011EB3C;
+gNewShadowY2 = 0x8011EB3E;
 D_8011D0D0 = 0x8011EB40;
 gShadowOpacity = 0x8011EB44;
-D_8011D0D8 = 0x8011EB48;
-D_8011D0DC = 0x8011EB4C;
-D_8011D0E0 = 0x8011EB50;
+gNewShadowScale = 0x8011EB48;
+gNewShadowWidth = 0x8011EB4C;
+gNewShadowLength = 0x8011EB50;
 D_8011D0E4 = 0x8011EB54;
 D_8011D0E8 = 0x8011EB58;
 D_8011D0EC = 0x8011EB5C;
@@ -3776,16 +3776,16 @@ gPrevCameraX = 0x8011ED84;
 gPrevCameraY = 0x8011ED88;
 gPrevCameraZ = 0x8011ED8C;
 gShadowHeapTris = 0x8011ED90;
-gCurrentShadowTris = 0x8011EDA0;
+gCurrShadowTris = 0x8011EDA0;
 D_8011D334 = 0x8011EDA4;
 gShadowHeapVerts = 0x8011EDA8;
-gCurrentShadowVerts = 0x8011EDB8;
+gCurrShadowVerts = 0x8011EDB8;
 D_8011D34C = 0x8011EDBC;
-gShadowHeapTextures = 0x8011EDC0;
-gCurrentShadowTexture = 0x8011EDD0;
-D_8011D364 = 0x8011EDD4;
-D_8011D368 = 0x8011EDD8;
-D_8011D36C = 0x8011EDDC;
+gShadowHeapData = 0x8011EDC0;
+gCurrShadowHeapData = 0x8011EDD0;
+gShadowTail = 0x8011EDD4;
+gNewShadowTriCount = 0x8011EDD8;
+gNewShadowVtxCount = 0x8011EDDC;
 D_8011D370 = 0x8011EDE0;
 D_8011D374 = 0x8011EDE4;
 D_8011D378 = 0x8011EDE8;
diff --git a/ver/symbols/symbol_addrs.pal.v77.txt b/ver/symbols/symbol_addrs.pal.v77.txt
index 65fa914b..baa753c3 100644
--- a/ver/symbols/symbol_addrs.pal.v77.txt
+++ b/ver/symbols/symbol_addrs.pal.v77.txt
@@ -450,11 +450,11 @@ free_track = 0x8002C7D4;
 func_8002C954 = 0x8002C954;
 func_8002CC30 = 0x8002CC30;
 trackMakeAbsolute = 0x8002D30C;
-render_object_shadow = 0x8002D384;
-render_object_water_effects = 0x8002D670;
-update_shadows = 0x8002D8DC;
+shadow_render = 0x8002D384;
+watereffect_render = 0x8002D670;
+shadow_update = 0x8002D8DC;
 func_8002DE30 = 0x8002DE30;
-func_8002E234 = 0x8002E234;
+shadow_generate = 0x8002E234;
 func_8002E904 = 0x8002E904;
 func_8002EEEC = 0x8002EEEC;
 func_8002F2AC = 0x8002F2AC;
@@ -3459,8 +3459,8 @@ gIsNearCurrBBox = 0x8011B14C;
 D_8011B0C0 = 0x8011B150;
 gDisableShadows = 0x8011B154;
 gShadowHeapFlip = 0x8011B158;
-D_8011B0CC = 0x8011B15C;
-gShadowIndex = 0x8011B160;
+gShadowIndex = 0x8011B15C;
+gWaterEffectIndex = 0x8011B160;
 gSceneStartSegment = 0x8011B164;
 D_8011B0D8 = 0x8011B168;
 gSceneRenderSkyDome = 0x8011B16C;
@@ -3493,16 +3493,16 @@ D_8011C3B8 = 0x8011C448;
 D_8011C8B8 = 0x8011C948;
 D_8011D0B8 = 0x8011D148;
 D_8011D0BC = 0x8011D14C;
-D_8011D0C0 = 0x8011D150;
-D_8011D0C4 = 0x8011D154;
+gNewShadowTexture = 0x8011D150;
+gNewShadowObj = 0x8011D154;
 D_8011D0C8 = 0x8011D158;
-D_8011D0CC = 0x8011D15C;
-D_8011D0CE = 0x8011D15E;
+gNewShadowY1 = 0x8011D15C;
+gNewShadowY2 = 0x8011D15E;
 D_8011D0D0 = 0x8011D160;
 gShadowOpacity = 0x8011D164;
-D_8011D0D8 = 0x8011D168;
-D_8011D0DC = 0x8011D16C;
-D_8011D0E0 = 0x8011D170;
+gNewShadowScale = 0x8011D168;
+gNewShadowWidth = 0x8011D16C;
+gNewShadowLength = 0x8011D170;
 D_8011D0E4 = 0x8011D174;
 D_8011D0E8 = 0x8011D178;
 D_8011D0EC = 0x8011D17C;
@@ -3521,16 +3521,16 @@ gPrevCameraX = 0x8011D3A4;
 gPrevCameraY = 0x8011D3A8;
 gPrevCameraZ = 0x8011D3AC;
 gShadowHeapTris = 0x8011D3B0;
-gCurrentShadowTris = 0x8011D3C0;
+gCurrShadowTris = 0x8011D3C0;
 D_8011D334 = 0x8011D3C4;
 gShadowHeapVerts = 0x8011D3C8;
-gCurrentShadowVerts = 0x8011D3D8;
+gCurrShadowVerts = 0x8011D3D8;
 D_8011D34C = 0x8011D3DC;
-gShadowHeapTextures = 0x8011D3E0;
-gCurrentShadowTexture = 0x8011D3F0;
-D_8011D364 = 0x8011D3F4;
-D_8011D368 = 0x8011D3F8;
-D_8011D36C = 0x8011D3FC;
+gShadowHeapData = 0x8011D3E0;
+gCurrShadowHeapData = 0x8011D3F0;
+gShadowTail = 0x8011D3F4;
+gNewShadowTriCount = 0x8011D3F8;
+gNewShadowVtxCount = 0x8011D3FC;
 D_8011D370 = 0x8011D400;
 D_8011D374 = 0x8011D404;
 D_8011D378 = 0x8011D408;
diff --git a/ver/symbols/symbol_addrs.pal.v80.txt b/ver/symbols/symbol_addrs.pal.v80.txt
index 5ab35bac..8a61125b 100644
--- a/ver/symbols/symbol_addrs.pal.v80.txt
+++ b/ver/symbols/symbol_addrs.pal.v80.txt
@@ -446,11 +446,11 @@ free_track = 0x8002C814;
 func_8002C954 = 0x8002C994;
 func_8002CC30 = 0x8002CC70;
 trackMakeAbsolute = 0x8002D34C;
-render_object_shadow = 0x8002D3C4;
-render_object_water_effects = 0x8002D6B0;
-update_shadows = 0x8002D91C;
+shadow_render = 0x8002D3C4;
+watereffect_render = 0x8002D6B0;
+shadow_update = 0x8002D91C;
 func_8002DE30 = 0x8002DE70;
-func_8002E234 = 0x8002E274;
+shadow_generate = 0x8002E274;
 func_8002E904 = 0x8002E944;
 func_8002EEEC = 0x8002EF2C;
 func_8002F2AC = 0x8002F2EC;
@@ -3389,8 +3389,8 @@ gIsNearCurrBBox = 0x8011B6CC;
 D_8011B0C0 = 0x8011B6D0;
 gDisableShadows = 0x8011B6D4;
 gShadowHeapFlip = 0x8011B6D8;
-D_8011B0CC = 0x8011B6DC;
-gShadowIndex = 0x8011B6E0;
+gShadowIndex = 0x8011B6DC;
+gWaterEffectIndex = 0x8011B6E0;
 gSceneStartSegment = 0x8011B6E4;
 D_8011B0D8 = 0x8011B6E8;
 gSceneRenderSkyDome = 0x8011B6EC;
@@ -3423,16 +3423,16 @@ D_8011C3B8 = 0x8011C9C8;
 D_8011C8B8 = 0x8011CEC8;
 D_8011D0B8 = 0x8011D6C8;
 D_8011D0BC = 0x8011D6CC;
-D_8011D0C0 = 0x8011D6D0;
-D_8011D0C4 = 0x8011D6D4;
+gNewShadowTexture = 0x8011D6D0;
+gNewShadowObj = 0x8011D6D4;
 D_8011D0C8 = 0x8011D6D8;
-D_8011D0CC = 0x8011D6DC;
-D_8011D0CE = 0x8011D6DE;
+gNewShadowY1 = 0x8011D6DC;
+gNewShadowY2 = 0x8011D6DE;
 D_8011D0D0 = 0x8011D6E0;
 gShadowOpacity = 0x8011D6E4;
-D_8011D0D8 = 0x8011D6E8;
-D_8011D0DC = 0x8011D6EC;
-D_8011D0E0 = 0x8011D6F0;
+gNewShadowScale = 0x8011D6E8;
+gNewShadowWidth = 0x8011D6EC;
+gNewShadowLength = 0x8011D6F0;
 D_8011D0E4 = 0x8011D6F4;
 D_8011D0E8 = 0x8011D6F8;
 D_8011D0EC = 0x8011D6FC;
@@ -3451,16 +3451,16 @@ gPrevCameraX = 0x8011D924;
 gPrevCameraY = 0x8011D928;
 gPrevCameraZ = 0x8011D92C;
 gShadowHeapTris = 0x8011D930;
-gCurrentShadowTris = 0x8011D940;
+gCurrShadowTris = 0x8011D940;
 D_8011D334 = 0x8011D944;
 gShadowHeapVerts = 0x8011D948;
-gCurrentShadowVerts = 0x8011D958;
+gCurrShadowVerts = 0x8011D958;
 D_8011D34C = 0x8011D95C;
-gShadowHeapTextures = 0x8011D960;
-gCurrentShadowTexture = 0x8011D970;
-D_8011D364 = 0x8011D974;
-D_8011D368 = 0x8011D978;
-D_8011D36C = 0x8011D97C;
+gShadowHeapData = 0x8011D960;
+gCurrShadowHeapData = 0x8011D970;
+gShadowTail = 0x8011D974;
+gNewShadowTriCount = 0x8011D978;
+gNewShadowVtxCount = 0x8011D97C;
 D_8011D370 = 0x8011D980;
 D_8011D374 = 0x8011D984;
 D_8011D378 = 0x8011D988;
diff --git a/ver/symbols/symbol_addrs.us.v77.txt b/ver/symbols/symbol_addrs.us.v77.txt
index f2423570..a35fb706 100644
--- a/ver/symbols/symbol_addrs.us.v77.txt
+++ b/ver/symbols/symbol_addrs.us.v77.txt
@@ -450,11 +450,11 @@ free_track = 0x8002C7D4;
 func_8002C954 = 0x8002C954;
 func_8002CC30 = 0x8002CC30;
 trackMakeAbsolute = 0x8002D30C;
-render_object_shadow = 0x8002D384;
-render_object_water_effects = 0x8002D670;
-update_shadows = 0x8002D8DC;
+shadow_render = 0x8002D384;
+watereffect_render = 0x8002D670;
+shadow_update = 0x8002D8DC;
 func_8002DE30 = 0x8002DE30;
-func_8002E234 = 0x8002E234;
+shadow_generate = 0x8002E234;
 func_8002E904 = 0x8002E904;
 func_8002EEEC = 0x8002EEEC;
 func_8002F2AC = 0x8002F2AC;
@@ -3838,8 +3838,8 @@ gIsNearCurrBBox = 0x8011B0BC;
 D_8011B0C0 = 0x8011B0C0;
 gDisableShadows = 0x8011B0C4;
 gShadowHeapFlip = 0x8011B0C8;
-D_8011B0CC = 0x8011B0CC;
-gShadowIndex = 0x8011B0D0;
+gShadowIndex = 0x8011B0CC;
+gWaterEffectIndex = 0x8011B0D0;
 gSceneStartSegment = 0x8011B0D4;
 D_8011B0D8 = 0x8011B0D8;
 gSceneRenderSkyDome = 0x8011B0DC;
@@ -3872,16 +3872,16 @@ D_8011C3B8 = 0x8011C3B8;
 D_8011C8B8 = 0x8011C8B8;
 D_8011D0B8 = 0x8011D0B8;
 D_8011D0BC = 0x8011D0BC;
-D_8011D0C0 = 0x8011D0C0;
-D_8011D0C4 = 0x8011D0C4;
+gNewShadowTexture = 0x8011D0C0;
+gNewShadowObj = 0x8011D0C4;
 D_8011D0C8 = 0x8011D0C8;
-D_8011D0CC = 0x8011D0CC;
-D_8011D0CE = 0x8011D0CE;
+gNewShadowY1 = 0x8011D0CC;
+gNewShadowY2 = 0x8011D0CE;
 D_8011D0D0 = 0x8011D0D0;
 gShadowOpacity = 0x8011D0D4;
-D_8011D0D8 = 0x8011D0D8;
-D_8011D0DC = 0x8011D0DC;
-D_8011D0E0 = 0x8011D0E0;
+gNewShadowScale = 0x8011D0D8;
+gNewShadowWidth = 0x8011D0DC;
+gNewShadowLength = 0x8011D0E0;
 D_8011D0E4 = 0x8011D0E4;
 D_8011D0E8 = 0x8011D0E8;
 D_8011D0EC = 0x8011D0EC;
@@ -3900,16 +3900,16 @@ gPrevCameraX = 0x8011D314;
 gPrevCameraY = 0x8011D318;
 gPrevCameraZ = 0x8011D31C;
 gShadowHeapTris = 0x8011D320;
-gCurrentShadowTris = 0x8011D330;
+gCurrShadowTris = 0x8011D330;
 D_8011D334 = 0x8011D334;
 gShadowHeapVerts = 0x8011D338;
-gCurrentShadowVerts = 0x8011D348;
+gCurrShadowVerts = 0x8011D348;
 D_8011D34C = 0x8011D34C;
-gShadowHeapTextures = 0x8011D350;
-gCurrentShadowTexture = 0x8011D360;
-D_8011D364 = 0x8011D364;
-D_8011D368 = 0x8011D368;
-D_8011D36C = 0x8011D36C;
+gShadowHeapData = 0x8011D350;
+gCurrShadowHeapData = 0x8011D360;
+gShadowTail = 0x8011D364;
+gNewShadowTriCount = 0x8011D368;
+gNewShadowVtxCount = 0x8011D36C;
 D_8011D370 = 0x8011D370;
 D_8011D374 = 0x8011D374;
 D_8011D378 = 0x8011D378;
diff --git a/ver/symbols/symbol_addrs.us.v80.txt b/ver/symbols/symbol_addrs.us.v80.txt
index 2cc5fae3..7a21f51c 100644
--- a/ver/symbols/symbol_addrs.us.v80.txt
+++ b/ver/symbols/symbol_addrs.us.v80.txt
@@ -446,11 +446,11 @@ free_track = 0x8002C814;
 func_8002C954 = 0x8002C994;
 func_8002CC30 = 0x8002CC70;
 trackMakeAbsolute = 0x8002D34C;
-render_object_shadow = 0x8002D3C4;
-render_object_water_effects = 0x8002D6B0;
-update_shadows = 0x8002D91C;
+shadow_render = 0x8002D3C4;
+watereffect_render = 0x8002D6B0;
+shadow_update = 0x8002D91C;
 func_8002DE30 = 0x8002DE70;
-func_8002E234 = 0x8002E274;
+shadow_generate = 0x8002E274;
 func_8002E904 = 0x8002E944;
 func_8002EEEC = 0x8002EF2C;
 func_8002F2AC = 0x8002F2EC;
@@ -3385,8 +3385,8 @@ gIsNearCurrBBox = 0x8011B63C;
 D_8011B0C0 = 0x8011B640;
 gDisableShadows = 0x8011B644;
 gShadowHeapFlip = 0x8011B648;
-D_8011B0CC = 0x8011B64C;
-gShadowIndex = 0x8011B650;
+gShadowIndex = 0x8011B64C;
+gWaterEffectIndex = 0x8011B650;
 gSceneStartSegment = 0x8011B654;
 D_8011B0D8 = 0x8011B658;
 gSceneRenderSkyDome = 0x8011B65C;
@@ -3419,16 +3419,16 @@ D_8011C3B8 = 0x8011C938;
 D_8011C8B8 = 0x8011CE38;
 D_8011D0B8 = 0x8011D638;
 D_8011D0BC = 0x8011D63C;
-D_8011D0C0 = 0x8011D640;
-D_8011D0C4 = 0x8011D644;
+gNewShadowTexture = 0x8011D640;
+gNewShadowObj = 0x8011D644;
 D_8011D0C8 = 0x8011D648;
-D_8011D0CC = 0x8011D64C;
-D_8011D0CE = 0x8011D64E;
+gNewShadowY1 = 0x8011D64C;
+gNewShadowY2 = 0x8011D64E;
 D_8011D0D0 = 0x8011D650;
 gShadowOpacity = 0x8011D654;
-D_8011D0D8 = 0x8011D658;
-D_8011D0DC = 0x8011D65C;
-D_8011D0E0 = 0x8011D660;
+gNewShadowScale = 0x8011D658;
+gNewShadowWidth = 0x8011D65C;
+gNewShadowLength = 0x8011D660;
 D_8011D0E4 = 0x8011D664;
 D_8011D0E8 = 0x8011D668;
 D_8011D0EC = 0x8011D66C;
@@ -3447,16 +3447,16 @@ gPrevCameraX = 0x8011D894;
 gPrevCameraY = 0x8011D898;
 gPrevCameraZ = 0x8011D89C;
 gShadowHeapTris = 0x8011D8A0;
-gCurrentShadowTris = 0x8011D8B0;
+gCurrShadowTris = 0x8011D8B0;
 D_8011D334 = 0x8011D8B4;
 gShadowHeapVerts = 0x8011D8B8;
-gCurrentShadowVerts = 0x8011D8C8;
+gCurrShadowVerts = 0x8011D8C8;
 D_8011D34C = 0x8011D8CC;
-gShadowHeapTextures = 0x8011D8D0;
-gCurrentShadowTexture = 0x8011D8E0;
-D_8011D364 = 0x8011D8E4;
-D_8011D368 = 0x8011D8E8;
-D_8011D36C = 0x8011D8EC;
+gShadowHeapData = 0x8011D8D0;
+gCurrShadowHeapData = 0x8011D8E0;
+gShadowTail = 0x8011D8E4;
+gNewShadowTriCount = 0x8011D8E8;
+gNewShadowVtxCount = 0x8011D8EC;
 D_8011D370 = 0x8011D8F0;
 D_8011D374 = 0x8011D8F4;
 D_8011D378 = 0x8011D8F8;