diff --git a/common/texture/texture_slots.cpp b/common/texture/texture_slots.cpp
index 27847a85bc..b4838370dd 100644
--- a/common/texture/texture_slots.cpp
+++ b/common/texture/texture_slots.cpp
@@ -43,7 +43,144 @@ std::vector<std::string> jak2_slots = {
 };
 
 std::vector<std::string> jak3_slots = {
-    "skull-gem-dest", "jakc-arm", "jakc-eyebrow", "jakc-face", "jakc-finger", "jakc-hair",
+    "skull-gem-dest",
+    "jakc-arm",
+    "jakc-eyebrow",
+    "jakc-face",
+    "jakc-finger",
+    "jakc-hair",
+    // default-water
+    "bomb-gradient",
+    "blue-beam-dest",
+    "lightjak-wings",
+    "mushroom-dest",
+    // default-warp
+    "shield-env-rim-dest",
+    // templea-water
+    "templea-waterfall-dest",
+    // templea-warp
+    "holograph-env-rim-dest",
+    // hanga-sprite
+    "glider-ring-dest2",
+    "glider-ring-dest",
+    // foresta-water
+    "fora-water-dest",
+    "fora-waterfall-01-dest",
+    "fora-water-wave-01-dest",
+    // forestb-water
+    "forb-water-dest",
+    "forb-waterfall-01-dest",
+    "forb-water-wave-01-dest",
+    // lforplnt-pris
+    "mh-gem-dest",
+    // lmhcitya-tfrag
+    "mhcitya-base-goo-01-dest",
+    // lmhcityb-tfrag
+    "mhcityb-base-goo-01-dest",
+    // mhcitya-pris
+    // "mhcity-de-door-skin-01-dest",
+    // templec-water
+    "tplc-water-dest",
+    // sewc-water
+    "sewer-water-01-c-dest",
+    "sewer-waterfall-01-c-dest",
+    "sewer-waterfall-02-c-dest",
+    "sewer-water-wave-01-c-dest",
+    "sewer-water-highlight-01-c-dest",
+    // sewd-water
+    "sewer-water-01-d-dest",
+    "sewer-waterfall-02-d-dest",
+    "sewer-water-highlight-01-d-dest",
+    "sewer-water-wave-01-d-dest",
+    "sewer-water-wave-02-d-dest",
+    "sewer-water-still-01-d-dest",
+    // sewe-water
+    "sewer-water-01-e-dest",
+    "sewer-waterfall-01-e-dest",
+    "sewer-waterfall-02-e-dest",
+    "sewer-water-highlight-01-e-dest",
+    // sewg-water
+    "sewer-water-01-g-dest",
+    "sewer-waterfall-02-g-dest",
+    "sewer-water-wave-01-g-dest",
+    // sewh-water
+    "sewer-water-01-h-dest",
+    "sewer-waterfall-02-h-dest",
+    "sewer-water-wave-02-h-dest",
+    "sewer-watefall-froth-01-h-dest",
+    // sewi-water
+    "sewer-water-still-01-i-dest",
+    "sewer-waterfall-02-i-dest",
+    "sewer-water-wave-01-i-dest",
+    // sewj-water
+    "sewer-waterfall-02-j-dest",
+    "sewer-watefall-froth-01-j-dest",
+    // sewl-water
+    "sewer-waterfall-02-l-dest",
+    "sewer-watefall-froth-01-l-dest",
+    // sewm-water
+    "sewer-water-01-m-dest",
+    "sewer-waterfall-01-m-dest",
+    "sewer-waterfall-02-m-dest",
+    "sewer-water-highlight-01-m-dest",
+    "sewer-water-wave-01-m-dest",
+    "sewer-water-still-01-m-dest",
+    "sewer-watefall-froth-01-m-dest",
+    // sewn-water
+    "sewer-waterfall-01-n-dest",
+    "sewer-waterfall-02-n-dest",
+    // "sewer-water-highlight-01-n-dest",
+    "sewer-water-wave-01-n-dest",
+    "sewer-water-still-01-n-dest",
+    // hanga-water
+    // "des-thermal-01-dest",
+    // desresc-warp
+    "sat-shield-dest",
+    // security
+    "security-env-dest",
+    "security-dot-dest",
+    // lgunnorm-water
+    "kg-target-c-forcefield-01-dest",
+    // templex-water
+    "temple-waterfall-dest",
+    // desertd-water
+    "des-waterfall-dest",
+    // towerb-water
+    "tow-energy-bridge-dest",
+    // factoryb-water
+    "hemi-gradient-dest",
+    "hemi-gradient-flames-dest",
+    // factoryc-alpha
+    "facc-convey-dest",
+    "facc-convey-02-dest",
+    // waspal-water
+    "waspala-water-dest",
+    "waspala-waterfall-dest",
+    // rubblea-water
+    "rub-water-dest",
+    // rubblea2-water
+    "rub-water-desta2",
+    // rubbleb-water
+    "rub-water-destb",
+    // rubblec-water
+    "rub-water-destc",
+    // nstb-quicksand
+    "nstb-quicksand-dest",
+    // ctyslumb-water
+    "ctyslumb-water-dest",
+    "ctyslumb-fountain-fall-dest",
+    // ctyslumc-water
+    "ctyslumc-water-dest",
+    "ctyslumc-fountain-fall-dest",
+    // mined-tfrag
+    "mined-pillar-side-dest",
+    "mined-pillar-top2side-dest",
+    "mined-pillar-top-dest",
+    // volcanoa-alpha
+    "vola-lava-01-dest",
+    "vola-lava-fall-dest",
+    // wasstada-alpha
+    "wstd-lava-base-dest",
 };
 
 }  // namespace
diff --git a/decompiler/config/jak3/all-types.gc b/decompiler/config/jak3/all-types.gc
index ce4e7fbd97..61ac036215 100644
--- a/decompiler/config/jak3/all-types.gc
+++ b/decompiler/config/jak3/all-types.gc
@@ -44496,12 +44496,12 @@
 ;; templea-texture                ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *templea-water-texture-anim-array* texture-anim-array)
-;; (define-extern *templea-warp-texture-anim-array* texture-anim-array)
-;; (define-extern templea-warp-texture-anim-func function)
-;; (define-extern *templeb-warp-texture-anim-array* texture-anim-array)
-;; (define-extern templeb-warp-texture-anim-func function)
-;; (define-extern *templec-water-texture-anim-array* texture-anim-array)
+(define-extern *templea-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *templea-warp-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern templea-warp-texture-anim-func (function none))
+(define-extern *templeb-warp-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern templeb-warp-texture-anim-func (function none))
+(define-extern *templec-water-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; hover-training                 ;;
@@ -46284,16 +46284,16 @@
 ;; sewer-texture                  ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *sewc-water-texture-anim-array* texture-anim-array)
-;; (define-extern *sewd-water-texture-anim-array* texture-anim-array)
-;; (define-extern *sewe-water-texture-anim-array* texture-anim-array)
-;; (define-extern *sewg-water-texture-anim-array* texture-anim-array)
-;; (define-extern *sewh-water-texture-anim-array* texture-anim-array)
-;; (define-extern *sewi-water-texture-anim-array* texture-anim-array)
-;; (define-extern *sewj-water-texture-anim-array* texture-anim-array)
-;; (define-extern *sewl-water-texture-anim-array* texture-anim-array)
-;; (define-extern *sewm-water-texture-anim-array* texture-anim-array)
-;; (define-extern *sewn-water-texture-anim-array* texture-anim-array)
+(define-extern *sewc-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewd-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewe-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewg-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewh-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewi-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewj-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewl-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewm-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewn-water-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; kg-hopper                      ;;
@@ -50287,7 +50287,7 @@
 ;; desresc-texture                ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *desresc-warp-texture-anim-array* texture-anim-array)
+(define-extern *desresc-warp-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; desert-rescue                  ;;
@@ -50984,7 +50984,7 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (define-extern check-drop-level-ctyslumb-drop-userdata (function sparticle-system sparticle-cpuinfo vector none))
-(define-extern *ctyslumb-water-texture-anim-array* texture-anim-array)
+(define-extern *ctyslumb-water-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; mech-part                      ;;
@@ -51090,7 +51090,7 @@
 ;; nstb-texture                   ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *nstb-quicksand-anim-array* texture-anim-array)
+(define-extern *nstb-quicksand-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; nst-mood                       ;;
@@ -51733,7 +51733,7 @@
     )
   )
 
-(define-extern *ctyslumc-water-texture-anim-array* texture-anim-array)
+(define-extern *ctyslumc-water-texture-anim-array* (texture-anim-array texture-anim))
 (define-extern ctyslumc-flag-init-by-other (function vector entity-actor object :behavior ctyslumc-flag))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -51908,8 +51908,8 @@
 ;; factoryc-texture               ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *factoryc-alpha-texture-anim-array* texture-anim-array)
-;; (define-extern set-facc-conveyor-speed! function)
+(define-extern *factoryc-alpha-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern set-facc-conveyor-speed! (function float float))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; conveyor                       ;;
@@ -52558,7 +52558,7 @@
 
 (define-extern wang-texture-anim-init (function texture-anim none))
 (define-extern real-wang-texture-anim-func (function texture-anim texture-anim none))
-(define-extern wang-texture-anim-func (function none))
+(define-extern wang-texture-anim-func (function texture-anim texture-anim none))
 (define-extern *hfrag-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -54182,7 +54182,7 @@
 ;; glider-ring-part               ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(define-extern *hanga-sprite-texture-anim-array* texture-anim-array)
+(define-extern *hanga-sprite-texture-anim-array* (texture-anim-array texture-anim))
 (define-extern cloud-shadow-find-ground (function vector matrix vector vector float))
 (define-extern birth-func-fader (function sparticle-system sparticle-cpuinfo sparticle-launchinfo none))
 (define-extern sparticle-fader (function sparticle-system sparticle-cpuinfo sparticle-launchinfo none))
@@ -54385,7 +54385,7 @@
 (define-extern hanga-login (function level none))
 (define-extern hanga-activate (function level none))
 (define-extern hanga-deactivate (function level none))
-(define-extern *hanga-water-texture-anim-array* texture-anim-array)
+(define-extern *hanga-water-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; elec-gate                      ;;
@@ -57037,7 +57037,7 @@
 ;; desertd-texture                ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *desertd-water-texture-anim-array* texture-anim-array)
+(define-extern *desertd-water-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; ctyfarm-obs                    ;;
@@ -60281,7 +60281,7 @@
 ;; mhcityb-texture                ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *lmhcityb-tfrag-texture-anim-array* texture-anim-array)
+(define-extern *lmhcityb-tfrag-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; rublcst-scenes                 ;;
@@ -61291,7 +61291,7 @@
 (define-extern init-mood-tower (function mood-context float))
 (define-extern update-tower-lights (function mood-context none))
 (define-extern update-mood-tower (function mood-context float int none :behavior time-of-day-proc))
-(define-extern *towerb-water-texture-anim-array* texture-anim-array)
+(define-extern *towerb-water-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; tower-scenes                   ;;
@@ -63331,7 +63331,7 @@
 ;; wasstada-texture               ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *wasstada-alpha-texture-anim-array* texture-anim-array)
+(define-extern *wasstada-alpha-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; wasstada-mood                  ;;
@@ -63355,7 +63355,7 @@
 ;; factorya-texture               ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *factoryb-water-texture-anim-array* texture-anim-array)
+(define-extern *factoryb-water-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; factoryb-init                  ;;
@@ -63367,9 +63367,9 @@
 ;; mhcitya-texture                ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *lmhcitya-tfrag-texture-anim-array* texture-anim-array)
-;; (define-extern *mhcitya-pris-texture-anim-array* texture-anim-array)
-;; (define-extern set-mhcity-de-door-skin! function)
+(define-extern *lmhcitya-tfrag-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *mhcitya-pris-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern set-mhcity-de-door-skin! (function float float))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; ctyinda-part                   ;;
@@ -63677,10 +63677,10 @@
 ;; rubble-texture                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *rubblea-water-texture-anim-array* texture-anim-array)
-;; (define-extern *rubblea2-water-texture-anim-array* texture-anim-array)
-;; (define-extern *rubbleb-water-texture-anim-array* texture-anim-array)
-;; (define-extern *rubblec-water-texture-anim-array* texture-anim-array)
+(define-extern *rubblea-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *rubblea2-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *rubbleb-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *rubblec-water-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; stadiuma-part                  ;;
@@ -65151,9 +65151,9 @@
 ;; forest-texture                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *foresta-water-texture-anim-array* texture-anim-array)
-;; (define-extern *forestb-water-texture-anim-array* texture-anim-array)
-;; (define-extern *lforplnt-pris-texture-anim-array* texture-anim-array)
+(define-extern *foresta-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *forestb-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *lforplnt-pris-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; forest-ring-chase              ;;
@@ -65410,8 +65410,8 @@
 ;; ltnfxhip-texture               ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *ltnfxhip-texture-anim-array* texture-anim-array)
-;; (define-extern ltnfxhip-texture-anim-func function)
+(define-extern *ltnfxhip-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern ltnfxhip-texture-anim-func (function none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; ctygenb-part                   ;;
@@ -67812,7 +67812,7 @@
 ;; gungame-texture                ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *lgunnorm-water-texture-anim-array* texture-anim-array)
+(define-extern *lgunnorm-water-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; gungame-obs                    ;;
@@ -68092,8 +68092,8 @@
 ;; ljkdxvin-texture               ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *ljkdxvin-texture-anim-array* texture-anim-array)
-;; (define-extern ljkdxvin-texture-anim-func function)
+(define-extern *ljkdxvin-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern ljkdxvin-texture-anim-func (function none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; target-tube                    ;;
@@ -71489,7 +71489,7 @@
 ;; waspal-texture                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *waspal-water-texture-anim-array* texture-anim-array)
+(define-extern *waspal-water-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; throne-scenes                  ;;
@@ -72665,7 +72665,7 @@
 ;; mined-texture                  ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(define-extern *mined-tfrag-texture-anim-array* texture-anim-array)
+(define-extern *mined-tfrag-texture-anim-array* (texture-anim-array texture-anim))
 (define-extern set-mined-pillar-texture! (function float none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -73051,8 +73051,8 @@
 ;; volcanox-texture               ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *volcanox-warp-texture-anim-array* texture-anim-array)
-;; (define-extern volcanox-warp-texture-anim-func function)
+(define-extern *volcanox-warp-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern volcanox-warp-texture-anim-func (function none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; volcanox-mood                  ;;
@@ -73252,7 +73252,7 @@
 ;; templex-texture                ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *templex-water-texture-anim-array* texture-anim-array)
+(define-extern *templex-water-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; templex-scenes                 ;;
@@ -73635,7 +73635,7 @@
 ;; volcano-texture                ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *volcanoa-alpha-texture-anim-array* texture-anim-array)
+(define-extern *volcanoa-alpha-texture-anim-array* (texture-anim-array texture-anim))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; spiky-frog                     ;;
@@ -74348,8 +74348,8 @@
 ;; deshover-texture               ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; (define-extern *deshover-texture-anim-array* texture-anim-array)
-;; (define-extern deshover-texture-anim-func function)
+(define-extern *deshover-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern deshover-texture-anim-func (function none))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; terraformer-head               ;;
diff --git a/decompiler/config/jak3/ntsc_v1/inputs.jsonc b/decompiler/config/jak3/ntsc_v1/inputs.jsonc
index 44f630845d..8af43b2f28 100644
--- a/decompiler/config/jak3/ntsc_v1/inputs.jsonc
+++ b/decompiler/config/jak3/ntsc_v1/inputs.jsonc
@@ -365,7 +365,288 @@
     "skull-gem-dest",
     "skull-gem-alpha-00",
     "skull-gem-alpha-01",
-    "skull-gem-alpha-02"
+    "skull-gem-alpha-02",
+
+    // default-water
+    "bomb-gradient",
+    "bomb-gradient-rim",
+    "bomb-gradient-flames",
+    "lightjak-wings",
+    "lighjak-wings-u-src",
+    "lightjak-wings-v-src",
+    "mushroom-dest",
+    "mushroom-src",
+
+    // default-warp
+    "shield-env-rim-dest",
+    "common-white",
+    "shield-env-uscroll",
+    "shield-env-rim-src",
+
+    // hanga-sprite
+    "glider-ring-dest2",
+    "glider-ring-dest",
+    "splash-foam",
+    "racegate",
+
+    // templea-water
+    "templea-waterfall-dest",
+    "templea-waterfall",
+
+    // templea-warp
+    "holograph-env-rim-dest",
+    "holograph-env-noise",
+    "holograph-env-scan",
+    "holograph-env-rim",
+    "environment-phong-rim",
+
+    // foresta-water
+    "fora-water-dest",
+    "fora-water",
+    "fora-waterfall-01-dest",
+    "fora-waterfall-01",
+    "fora-water-wave-01-dest",
+    "fora-water-wave-01",
+
+    // forestb-water
+    "forb-water-dest",
+    "forb-water",
+    "forb-waterfall-01-dest",
+    "forb-waterfall-01",
+    "forb-water-wave-01-dest",
+    "forb-water-wave-01",
+
+    // lforplnt-pris
+    "mh-gem-dest",
+    "mh-gem",
+    "mh-gem-alpha-01",
+    "mh-gem-alpha-02",
+
+    // lmhcitya-tfrag
+    "mhcitya-base-goo-01-dest",
+    "mhcitya-base-goo-01",
+
+    // lmhcityb-tfrag
+    "mhcityb-base-goo-01-dest",
+    "mhcityb-base-goo-01",
+
+    // mhcitya-pris
+    // "mhcity-de-door-skin-01-dest",
+    // "mhcity-de-door-skin-01",
+    // "mhcity-de-door-skin-02"
+
+    // templec-water
+    "tplc-water-dest",
+    "tplc-water",
+
+    // sewc-water
+    "sewer-water-01-c-dest",
+    "sewer-water-01-c",
+    "sewer-waterfall-01-c-dest",
+    "sewer-waterfall-01-c",
+    "sewer-waterfall-02-c-dest",
+    "sewer-waterfall-02-c",
+    "sewer-water-wave-01-c-dest",
+    "sewer-water-wave-01-c",
+    "sewer-water-highlight-01-c-dest",
+    "sewer-water-highlight-01-c",
+
+    // sewd-water
+    "sewer-water-01-d-dest",
+    "sewer-water-01-d",
+    "sewer-waterfall-02-d-dest",
+    "sewer-waterfall-02-d",
+    "sewer-water-highlight-01-d-dest",
+    "sewer-water-highlight-01-d",
+    "sewer-water-wave-01-d-dest",
+    "sewer-water-wave-01-d",
+    "sewer-water-wave-02-d-dest",
+    "sewer-water-wave-02-d",
+    "sewer-water-still-01-d-dest",
+    "sewer-water-still-01-d",
+
+    // sewe-water
+    "sewer-water-01-e-dest",
+    "sewer-water-01-e",
+    "sewer-waterfall-01-e-dest",
+    "sewer-waterfall-01-e",
+    "sewer-waterfall-02-e-dest",
+    "sewer-waterfall-02-e",
+    "sewer-water-highlight-01-e-dest",
+    "sewer-water-highlight-01-e",
+
+    // sewg-water
+    "sewer-water-01-g-dest",
+    "sewer-water-01-g",
+    "sewer-waterfall-02-g-dest",
+    "sewer-waterfall-02-g",
+    "sewer-water-wave-01-g-dest",
+    "sewer-water-wave-01-g",
+
+    // sewh-water
+    "sewer-water-01-h-dest",
+    "sewer-water-01-h",
+    "sewer-waterfall-02-h-dest",
+    "sewer-waterfall-02-h",
+    "sewer-water-wave-02-h-dest",
+    "sewer-water-wave-02-h",
+    "sewer-watefall-froth-01-h-dest",
+    "sewer-watefall-froth-01-h",
+
+    // sewi-water
+    "sewer-water-still-01-i-dest",
+    "sewer-water-still-01-i",
+    "sewer-waterfall-02-i-dest",
+    "sewer-waterfall-02-i",
+    "sewer-water-wave-01-i-dest",
+    "sewer-water-wave-01-i",
+
+    // sewj-water
+    "sewer-waterfall-02-j-dest",
+    "sewer-waterfall-02-j",
+    "sewer-watefall-froth-01-j-dest",
+    "sewer-watefall-froth-01-j",
+
+    // sewl-water
+    "sewer-waterfall-02-l-dest",
+    "sewer-waterfall-02-l",
+    "sewer-watefall-froth-01-l-dest",
+    "sewer-watefall-froth-01-l",
+
+    // sewm-water
+    "sewer-water-01-m-dest",
+    "sewer-water-01-m",
+    "sewer-waterfall-01-m-dest",
+    "sewer-waterfall-01-m",
+    "sewer-waterfall-02-m-dest",
+    "sewer-waterfall-02-m",
+    "sewer-water-highlight-01-m-dest",
+    "sewer-water-highlight-01-m",
+    "sewer-water-wave-01-m-dest",
+    "sewer-water-wave-01-m",
+    "sewer-water-still-01-m-dest",
+    "sewer-water-still-01-m",
+    "sewer-watefall-froth-01-m-dest",
+    "sewer-watefall-froth-01-m",
+
+    // sewn-water
+    "sewer-waterfall-01-n-dest",
+    "sewer-waterfall-01-n",
+    "sewer-waterfall-02-n-dest",
+    "sewer-waterfall-02-n",
+    // "sewer-water-highlight-01-n-dest",
+    // "sewer-water-highlight-01-n",
+    "sewer-water-wave-01-n-dest",
+    "sewer-water-wave-01-n",
+    "sewer-water-still-01-n-dest",
+    "sewer-water-still-01-n",
+
+    // hanga-water
+    // "des-thermal-01-dest",
+    // "des-thermal-01"
+
+    // desresc-warp
+    "sat-shield-dest",
+    "sat-shield-env-uvscroll",
+    "sat-shield",
+
+    // security
+    "security-env-dest",
+    "security-env-uscroll",
+    "security-dot-dest",
+    "security-dot-src",
+
+    // lgunnorm-water
+    "kg-target-c-forcefield-01-dest",
+    "kg-target-c-forcefield-01",
+
+    // templex-water
+    "temple-waterfall-dest",
+    "temple-waterfall",
+
+    // desertd-water
+    "des-waterfall-dest",
+    "des-waterfall",
+
+    // towerb-water
+    "tow-energy-bridge-dest",
+    "tow-energy-bridge",
+
+    // factoryb-water
+    "hemi-gradient-dest",
+    "hemi-gradient-rim",
+    "hemi-gradient-flames-dest",
+    "hemi-gradient-flames",
+
+    // factoryc-alpha
+    "facc-convey-dest",
+    "facc-convey",
+    "facc-convey-02-dest",
+    "facc-convey-02",
+
+    // waspal-water
+    "waspala-water-dest",
+    "waspala-water",
+    "waspala-waterfall-dest",
+    "waspala-waterfall",
+
+    // rubblea-water
+    "rub-water-dest",
+    "rub-water",
+
+    // rubblea2-water
+    "rub-water-desta2",
+    "rub-watera2",
+
+    // rubbleb-water
+    "rub-water-destb",
+    "rub-waterb",
+
+    // rubblec-water
+    "rub-water-destc",
+    "rub-waterc",
+
+    // nstb-quicksand
+    "nstb-quicksand-dest",
+    "nstb-quicksand-scroll",
+
+    // ctyslumb-water
+    "ctyslumb-water-dest",
+    "ctyslumb-water",
+    "ctyslumb-fountain-fall-dest",
+    "ctyslumb-fountain-fall",
+
+    // ctyslumc-water
+    "ctyslumc-water-dest",
+    "ctyslumc-water",
+    "ctyslumc-fountain-fall-dest",
+    "ctyslumc-fountain-fall",
+
+    // mined-tfrag
+    "mined-pillar-side-dest",
+    "mined-pillar-side-cold",
+    "mined-pillar-side-cooling",
+    "mined-pillar-side-hot",
+    "mined-pillar-molten",
+    "mined-pillar-top2side-dest",
+    "mined-pillar-top2side-cold",
+    "mined-pillar-top2side-cooling",
+    "mined-pillar-top2side-hot",
+    "mined-pillar-top-dest",
+    "mined-pillar-top-cold",
+    "mined-pillar-top-cooling",
+    "mined-pillar-top-hot",
+    "mined-pillar-molten-top",
+
+    // volcanoa-alpha
+    "vola-lava-01-dest",
+    "vola-lava-01",
+    "vola-lava-fall-dest",
+    "vola-lava-fall",
+
+    // wasstada-alpha
+    "wstd-lava-base-dest",
+    "wstd-lava-base"
   ],
 
   "levels_to_extract": [
diff --git a/decompiler/data/tpage.cpp b/decompiler/data/tpage.cpp
index d720f1ecb4..d5319488cf 100644
--- a/decompiler/data/tpage.cpp
+++ b/decompiler/data/tpage.cpp
@@ -515,8 +515,44 @@ TPageResultStats process_tpage(ObjectFileData& data,
           // currently not needed.
           break;
         case int(PSM::PSMT8):
-          ASSERT(tex.clutpsm == int(CPSM::PSMCT32));
-          {
+          if (tex.clutpsm == (int)CPSM::PSMCT16) {
+            // will store output pixels, rgba (8888)
+            std::vector<u8> index_out;
+
+            // width is like the TEX0 register, in 64 texel units.
+            // not sure what the other widths are yet.
+            int read_width = 64 * tex.width[0];
+
+            // loop over pixels in output texture image
+            for (int y = 0; y < tex.h; y++) {
+              for (int x = 0; x < tex.w; x++) {
+                // read as the PSMT8 type. The dest field tells us a block offset.
+                auto addr8 = psmt8_addr(x, y, read_width) + tex.dest[0] * 256;
+                u8 value = *(u8*)(vram.data() + addr8);
+                index_out.push_back(value);
+              }
+            }
+            std::array<math::Vector4<u8>, 256> unscrambled_clut{};
+            for (int i = 0; i < 256; i++) {
+              u32 clut_chunk = i / 16;
+              u32 off_in_chunk = i % 16;
+              u8 clx = 0, cly = 0;
+              if (clut_chunk & 1) {
+                clx = 8;
+              }
+              cly = (clut_chunk >> 1) * 2;
+              if (off_in_chunk >= 8) {
+                off_in_chunk -= 8;
+                cly++;
+              }
+              clx += off_in_chunk;
+              u32 clut_addr = psmct16_addr(clx, cly, 64) + tex.clutdest * 256;
+              memcpy(&unscrambled_clut[i], vram.data() + clut_addr, 4);
+            }
+            texture_db.add_index_texture(texture_page.id, tex_id, index_out, unscrambled_clut,
+                                         tex.w, tex.h, tex.name, texture_page.name, level_names);
+            stats.successful_textures++;
+          } else if (tex.clutpsm == (int)PSM::PSMCT32) {
             // will store output pixels, index (u8)
             std::vector<u8> index_out;
 
@@ -555,10 +591,12 @@ TPageResultStats process_tpage(ObjectFileData& data,
             texture_db.add_index_texture(texture_page.id, tex_id, index_out, unscrambled_clut,
                                          tex.w, tex.h, tex.name, texture_page.name, level_names);
             stats.successful_textures++;
+          } else {
+            ASSERT_NOT_REACHED();
           }
           break;
         default:
-          lg::die("Animated texture {} format {}\n", tex.name, tex.psm);
+          lg::die("Animated texture {} format {} clut {}\n", tex.name, tex.psm, tex.clutpsm);
       }
     }
 
diff --git a/game/graphics/opengl_renderer/TextureAnimator.cpp b/game/graphics/opengl_renderer/TextureAnimator.cpp
index 4022b2cce7..c6b37916ae 100644
--- a/game/graphics/opengl_renderer/TextureAnimator.cpp
+++ b/game/graphics/opengl_renderer/TextureAnimator.cpp
@@ -60,23 +60,48 @@
  * A simple list of preallocated textures by size. If a texture needs to be resized, it's faster
  * to swap to a different OpenGL texture from this pool than glTexImage2D with a different size.
  */
-OpenGLTexturePool::OpenGLTexturePool() {
+OpenGLTexturePool::OpenGLTexturePool(GameVersion version) {
   struct Alloc {
     u64 w, h, n;
   };
   // list of sizes to preallocate: {width, height, count}.
-  for (const auto& a : std::vector<Alloc>{{4, 4, 2},
-                                          {4, 64, 2},
-                                          {16, 16, 5},
-                                          {32, 16, 1},
-                                          {32, 32, 10},
-                                          {32, 64, 1},
-                                          {64, 32, 6},
-                                          {64, 64, 30},
-                                          {64, 128, 4},
-                                          {128, 128, 10},
-                                          {256, 1, 2},
-                                          {256, 256, 7}}) {
+  PerGameVersion<std::vector<Alloc>> tex_allocs{{{4, 4, 2},
+                                                 {4, 64, 2},
+                                                 {16, 16, 5},
+                                                 {32, 16, 1},
+                                                 {32, 32, 10},
+                                                 {32, 64, 1},
+                                                 {64, 32, 6},
+                                                 {64, 64, 30},
+                                                 {64, 128, 4},
+                                                 {128, 128, 10},
+                                                 {256, 1, 2},
+                                                 {256, 256, 7}},
+                                                {{4, 4, 2},
+                                                 {4, 64, 2},
+                                                 {16, 16, 5},
+                                                 {32, 16, 1},
+                                                 {32, 32, 10},
+                                                 {32, 64, 1},
+                                                 {64, 32, 6},
+                                                 {64, 64, 30},
+                                                 {64, 128, 4},
+                                                 {128, 128, 10},
+                                                 {256, 1, 2},
+                                                 {256, 256, 7}},
+                                                {{4, 4, 3},
+                                                 {4, 64, 6},
+                                                 {16, 16, 5},
+                                                 {32, 16, 1},
+                                                 {32, 32, 20},
+                                                 {32, 64, 1},
+                                                 {64, 32, 15},
+                                                 {64, 64, 85},
+                                                 {64, 128, 4},
+                                                 {128, 128, 185},
+                                                 {256, 1, 2},
+                                                 {256, 256, 7}}};
+  for (const auto& a : tex_allocs[version]) {
     auto& l = textures[(a.w << 32) | a.h];
     l.resize(a.n);
     glGenTextures(a.n, l.data());
@@ -370,6 +395,7 @@ TextureAnimator::TextureAnimator(ShaderLibrary& shaders,
                                  const tfrag3::Level* common_level,
                                  GameVersion version)
     : m_common_level(common_level),
+      m_opengl_texture_pool(version),
       m_psm32_to_psm8_8_8(8, 8, 8, 64),
       m_psm32_to_psm8_16_16(16, 16, 16, 64),
       m_psm32_to_psm8_32_32(32, 32, 16, 64),
@@ -642,7 +668,7 @@ GLuint TextureAnimator::get_by_slot(int idx) {
 }
 
 // IDs sent from GOAL telling us what texture operation to perform.
-enum PcTextureAnimCodes {
+enum class PcTextureAnimCodesJak2 : u16 {
   FINISH_ARRAY = 13,
   ERASE_DEST_TEXTURE = 14,
   UPLOAD_CLUT_16_16 = 15,
@@ -673,6 +699,360 @@ enum PcTextureAnimCodes {
   CLOUDS_HIRES = 43,
 };
 
+struct FixedAnimInfoJak2 {
+  PcTextureAnimCodesJak2 code = (PcTextureAnimCodesJak2)0;
+  std::string name;
+  int anim_array_idx = -1;
+};
+
+FixedAnimInfoJak2 anim_code_to_info(PcTextureAnimCodesJak2 code, const TextureAnimator& animator) {
+  ASSERT(code > (PcTextureAnimCodesJak2)0);
+  FixedAnimInfoJak2 anim;
+  anim.code = code;
+  switch (code) {
+    case PcTextureAnimCodesJak2::SKULL_GEM: {
+      anim.name = "skull-gem";
+      anim.anim_array_idx = animator.m_skull_gem_fixed_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::BOMB: {
+      anim.name = "bomb";
+      anim.anim_array_idx = animator.m_bomb_fixed_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::CAS_CONVEYOR: {
+      anim.name = "cas-conveyor";
+      anim.anim_array_idx = animator.m_cas_conveyor_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::SECURITY: {
+      anim.name = "security";
+      anim.anim_array_idx = animator.m_security_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::WATERFALL: {
+      anim.name = "waterfall";
+      anim.anim_array_idx = animator.m_waterfall_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::WATERFALL_B: {
+      anim.name = "waterfall-b";
+      anim.anim_array_idx = animator.m_waterfall_b_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::LAVA: {
+      anim.name = "lava";
+      anim.anim_array_idx = animator.m_lava_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::LAVA_B: {
+      anim.name = "lava-b";
+      anim.anim_array_idx = animator.m_lava_b_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::STADIUMB: {
+      anim.name = "stadiumb";
+      anim.anim_array_idx = animator.m_stadiumb_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::FORTRESS_PRIS: {
+      anim.name = "fort-pris";
+      anim.anim_array_idx = animator.m_fortress_pris_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::FORTRESS_WARP: {
+      anim.name = "fort-warp";
+      anim.anim_array_idx = animator.m_fortress_warp_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::METKOR: {
+      anim.name = "metkor";
+      anim.anim_array_idx = animator.m_metkor_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::SHIELD: {
+      anim.name = "shield";
+      anim.anim_array_idx = animator.m_shield_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak2::KREW_HOLO: {
+      anim.name = "krew-holo";
+      anim.anim_array_idx = animator.m_krew_holo_anim_array_idx;
+    } break;
+    default:
+      anim.name = "unknown";
+      lg::error("Unknown texture anim code {}", (int)code);
+  }
+  return anim;
+}
+
+enum class PcTextureAnimCodesJak3 : u16 {
+  FINISH_ARRAY = 13,
+  ERASE_DEST_TEXTURE = 14,
+  UPLOAD_CLUT_16_16 = 15,
+  GENERIC_UPLOAD = 16,
+  SET_SHADER = 17,
+  DRAW = 18,
+  DARKJAK = 22,
+  SKULL_GEM = 27,
+  DEFAULT_WATER = 28,
+  DEFAULT_WARP = 29,
+  TEMPLEA_WATER = 30,
+  TEMPLEA_WARP = 31,
+  TEMPLEB_WARP = 32,
+  TEMPLEC_WATER = 33,
+  SEWC_WATER = 34,
+  SEWD_WATER = 35,
+  SEWE_WATER = 36,
+  SEWG_WATER = 37,
+  SEWH_WATER = 38,
+  SEWI_WATER = 39,
+  SEWJ_WATER = 40,
+  SEWL_WATER = 41,
+  SEWM_WATER = 42,
+  SEWN_WATER = 43,
+  DESRESC_WARP = 44,
+  CTYSLUMB_WATER = 45,
+  NSTB_QUICKSAND = 46,
+  CTYSLUMC_WATER = 47,
+  FACTORYC_ALPHA = 48,
+  HFRAG = 49,
+  HANGA_SPRITE = 50,
+  HANGA_WATER = 51,
+  DESERTD_WATER = 52,
+  LMHCITYB_TFRAG = 53,
+  TOWERB_WATER = 54,
+  COMB_FIELD = 55,
+  WASSTADA_ALPHA = 56,
+  FACTORYB_WATER = 57,
+  LMHCITYA_TFRAG = 58,
+  MHCITYA_PRIS = 59,
+  RUBBLEA_WATER = 60,
+  RUBBLEA2_WATER = 61,
+  RUBBLEB_WATER = 62,
+  RUBBLEC_WATER = 63,
+  FORESTA_WATER = 64,
+  FORESTB_WATER = 65,
+  LFORPLNT_PRIS = 66,
+  LTNFXHIP = 67,
+  LGUNNORM_WATER = 68,
+  LJKDXVIN = 69,
+  SECURITY = 70,
+  WASPAL_WATER = 71,
+  MINED_TFRAG = 72,
+  VOLCANOX_WARP = 73,
+  TEMPLEX_WATER = 74,
+  VOLCANOA_WATER = 75,
+  DESHOVER = 76,
+  CLOUDS_AND_FOG = 77,
+  CLOUDS_HIRES = 78,
+};
+
+struct FixedAnimInfoJak3 {
+  PcTextureAnimCodesJak3 code = (PcTextureAnimCodesJak3)0;
+  std::string name;
+  int anim_array_idx = -1;
+};
+
+FixedAnimInfoJak3 anim_code_to_info(PcTextureAnimCodesJak3 code, const TextureAnimator& animator) {
+  ASSERT(code > (PcTextureAnimCodesJak3)0);
+  FixedAnimInfoJak3 anim;
+  anim.code = code;
+  switch (code) {
+    case PcTextureAnimCodesJak3::SKULL_GEM: {
+      anim.name = "skull-gem";
+      anim.anim_array_idx = animator.m_skull_gem_fixed_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::DEFAULT_WATER: {
+      anim.name = "default-water";
+      anim.anim_array_idx = animator.m_default_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::DEFAULT_WARP: {
+      anim.name = "default-warp";
+      anim.anim_array_idx = animator.m_default_warp_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::TEMPLEA_WATER: {
+      anim.name = "templea-water";
+      anim.anim_array_idx = animator.m_templea_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::TEMPLEA_WARP: {
+      anim.name = "templea-warp";
+      anim.anim_array_idx = animator.m_templea_warp_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::TEMPLEB_WARP: {
+      anim.name = "templeb-warp";
+      anim.anim_array_idx = animator.m_templeb_warp_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::TEMPLEC_WATER: {
+      anim.name = "templec-water";
+      anim.anim_array_idx = animator.m_templec_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::SEWC_WATER: {
+      anim.name = "sewc-water";
+      anim.anim_array_idx = animator.m_sewc_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::SEWD_WATER: {
+      anim.name = "sewd-water";
+      anim.anim_array_idx = animator.m_sewd_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::SEWE_WATER: {
+      anim.name = "sewe-water";
+      anim.anim_array_idx = animator.m_sewe_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::SEWG_WATER: {
+      anim.name = "sewg-water";
+      anim.anim_array_idx = animator.m_sewg_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::SEWH_WATER: {
+      anim.name = "sewh-water";
+      anim.anim_array_idx = animator.m_sewh_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::SEWI_WATER: {
+      anim.name = "sewi-water";
+      anim.anim_array_idx = animator.m_sewi_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::SEWJ_WATER: {
+      anim.name = "sewj-water";
+      anim.anim_array_idx = animator.m_sewj_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::SEWL_WATER: {
+      anim.name = "sewl-water";
+      anim.anim_array_idx = animator.m_sewl_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::SEWM_WATER: {
+      anim.name = "sewm-water";
+      anim.anim_array_idx = animator.m_sewm_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::SEWN_WATER: {
+      anim.name = "sewn-water";
+      anim.anim_array_idx = animator.m_sewn_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::DESRESC_WARP: {
+      anim.name = "desresc-warp";
+      anim.anim_array_idx = animator.m_desresc_warp_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::CTYSLUMB_WATER: {
+      anim.name = "ctyslumb-water";
+      anim.anim_array_idx = animator.m_ctyslumb_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::NSTB_QUICKSAND: {
+      anim.name = "nstb-quicksand";
+      anim.anim_array_idx = animator.m_nstb_quicksand_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::CTYSLUMC_WATER: {
+      anim.name = "ctyslumc-water";
+      anim.anim_array_idx = animator.m_ctyslumc_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::FACTORYC_ALPHA: {
+      anim.name = "factoryc-alpha";
+      anim.anim_array_idx = animator.m_factoryc_alpha_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::HFRAG: {
+      anim.name = "hfrag";
+      anim.anim_array_idx = animator.m_hfrag_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::HANGA_SPRITE: {
+      anim.name = "hanga-sprite";
+      anim.anim_array_idx = animator.m_hanga_sprite_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::HANGA_WATER: {
+      anim.name = "hanga-water";
+      anim.anim_array_idx = animator.m_hanga_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::DESERTD_WATER: {
+      anim.name = "desertd-water";
+      anim.anim_array_idx = animator.m_desertd_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::LMHCITYB_TFRAG: {
+      anim.name = "lmhcityb-tfrag";
+      anim.anim_array_idx = animator.m_lmhcityb_tfrag_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::TOWERB_WATER: {
+      anim.name = "towerb-water";
+      anim.anim_array_idx = animator.m_towerb_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::COMB_FIELD: {
+      anim.name = "comb-field";
+      anim.anim_array_idx = animator.m_comb_field_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::WASSTADA_ALPHA: {
+      anim.name = "wasstada-alpha";
+      anim.anim_array_idx = animator.m_wasstada_alpha_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::FACTORYB_WATER: {
+      anim.name = "factoryb-water";
+      anim.anim_array_idx = animator.m_factoryb_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::LMHCITYA_TFRAG: {
+      anim.name = "lmhcitya-tfrag";
+      anim.anim_array_idx = animator.m_lmhcitya_tfrag_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::MHCITYA_PRIS: {
+      anim.name = "mhcitya-pris";
+      anim.anim_array_idx = animator.m_mhcitya_pris_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::RUBBLEA_WATER: {
+      anim.name = "rubblea-water";
+      anim.anim_array_idx = animator.m_rubblea_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::RUBBLEA2_WATER: {
+      anim.name = "rubblea2-water";
+      anim.anim_array_idx = animator.m_rubblea2_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::RUBBLEB_WATER: {
+      anim.name = "rubbleb-water";
+      anim.anim_array_idx = animator.m_rubbleb_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::RUBBLEC_WATER: {
+      anim.name = "rubblec-water";
+      anim.anim_array_idx = animator.m_rubblec_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::FORESTA_WATER: {
+      anim.name = "foresta-water";
+      anim.anim_array_idx = animator.m_foresta_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::FORESTB_WATER: {
+      anim.name = "forestb-water";
+      anim.anim_array_idx = animator.m_forestb_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::LFORPLNT_PRIS: {
+      anim.name = "lforplnt-pris";
+      anim.anim_array_idx = animator.m_lforplnt_pris_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::LTNFXHIP: {
+      anim.name = "ltnfxhip";
+      anim.anim_array_idx = animator.m_ltnfxhip_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::LGUNNORM_WATER: {
+      anim.name = "lgunnorm-water";
+      anim.anim_array_idx = animator.m_lgunnorm_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::LJKDXVIN: {
+      anim.name = "ljkdxvin";
+      anim.anim_array_idx = animator.m_ljkdxvin_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::SECURITY: {
+      anim.name = "security";
+      anim.anim_array_idx = animator.m_security_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::WASPAL_WATER: {
+      anim.name = "waspal-water";
+      anim.anim_array_idx = animator.m_waspal_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::MINED_TFRAG: {
+      anim.name = "mined-tfrag";
+      anim.anim_array_idx = animator.m_mined_tfrag_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::VOLCANOX_WARP: {
+      anim.name = "volcanox-warp";
+      anim.anim_array_idx = animator.m_volcanox_warp_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::TEMPLEX_WATER: {
+      anim.name = "templex-water";
+      anim.anim_array_idx = animator.m_templex_water_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::VOLCANOA_WATER: {
+      anim.name = "volcanoa-water";
+      anim.anim_array_idx = animator.m_volcanoa_anim_array_idx;
+    } break;
+    case PcTextureAnimCodesJak3::DESHOVER: {
+      anim.name = "deshover";
+      anim.anim_array_idx = animator.m_deshover_anim_array_idx;
+    } break;
+    default:
+      anim.name = "unknown";
+      lg::error("Unknown texture anim code {}", (int)code);
+  }
+  return anim;
+}
+
 // metadata for an upload from GOAL memory
 struct TextureAnimPcUpload {
   u32 data;  // goal pointer
@@ -726,117 +1106,187 @@ void TextureAnimator::handle_texture_anim_data(DmaFollower& dma,
     auto tf = dma.read_and_advance();
     auto vif0 = tf.vifcode0();
     if (vif0.kind == VifCode::Kind::PC_PORT) {
-      switch (vif0.immediate) {
-        case UPLOAD_CLUT_16_16: {
-          auto p = scoped_prof("clut-16-16");
-          handle_upload_clut_16_16(tf, ee_mem);
-        } break;
-        case ERASE_DEST_TEXTURE: {
-          auto p = scoped_prof("erase");
-          handle_erase_dest(dma);
-        } break;
-        case GENERIC_UPLOAD: {
-          auto p = scoped_prof("generic-upload");
-          handle_generic_upload(tf, ee_mem);
-        } break;
-        case SET_SHADER: {
-          auto p = scoped_prof("set-shader");
-          handle_set_shader(dma);
-        } break;
-        case DRAW: {
-          auto p = scoped_prof("draw");
-          handle_draw(dma, *texture_pool);
-        } break;
-        case FINISH_ARRAY:
-          done = true;
+      switch (this->m_version) {
+        case GameVersion::Jak2:
+          switch (static_cast<PcTextureAnimCodesJak2>(vif0.immediate)) {
+            case PcTextureAnimCodesJak2::UPLOAD_CLUT_16_16: {
+              auto p = scoped_prof("clut-16-16");
+              handle_upload_clut_16_16(tf, ee_mem);
+            } break;
+            case PcTextureAnimCodesJak2::ERASE_DEST_TEXTURE: {
+              auto p = scoped_prof("erase");
+              handle_erase_dest(dma);
+            } break;
+            case PcTextureAnimCodesJak2::GENERIC_UPLOAD: {
+              auto p = scoped_prof("generic-upload");
+              handle_generic_upload(tf, ee_mem);
+            } break;
+            case PcTextureAnimCodesJak2::SET_SHADER: {
+              auto p = scoped_prof("set-shader");
+              handle_set_shader(dma);
+            } break;
+            case PcTextureAnimCodesJak2::DRAW: {
+              auto p = scoped_prof("draw");
+              handle_draw(dma, *texture_pool);
+            } break;
+            case PcTextureAnimCodesJak2::FINISH_ARRAY:
+              done = true;
+              break;
+            case PcTextureAnimCodesJak2::DARKJAK: {
+              auto p = scoped_prof("darkjak");
+              run_clut_blender_group(tf, m_darkjak_clut_blender_idx, frame_idx);
+            } break;
+            case PcTextureAnimCodesJak2::PRISON_JAK: {
+              auto p = scoped_prof("prisonjak");
+              run_clut_blender_group(tf, m_jakb_prison_clut_blender_idx, frame_idx);
+            } break;
+            case PcTextureAnimCodesJak2::ORACLE_JAK: {
+              auto p = scoped_prof("oraclejak");
+              run_clut_blender_group(tf, m_jakb_oracle_clut_blender_idx, frame_idx);
+            } break;
+            case PcTextureAnimCodesJak2::NEST_JAK: {
+              auto p = scoped_prof("nestjak");
+              run_clut_blender_group(tf, m_jakb_nest_clut_blender_idx, frame_idx);
+            } break;
+            case PcTextureAnimCodesJak2::KOR_TRANSFORM: {
+              auto p = scoped_prof("kor");
+              run_clut_blender_group(tf, m_kor_transform_clut_blender_idx, frame_idx);
+            } break;
+            case PcTextureAnimCodesJak2::SKULL_GEM:
+            case PcTextureAnimCodesJak2::BOMB:
+            case PcTextureAnimCodesJak2::CAS_CONVEYOR:
+            case PcTextureAnimCodesJak2::SECURITY:
+            case PcTextureAnimCodesJak2::WATERFALL:
+            case PcTextureAnimCodesJak2::WATERFALL_B:
+            case PcTextureAnimCodesJak2::LAVA:
+            case PcTextureAnimCodesJak2::LAVA_B:
+            case PcTextureAnimCodesJak2::STADIUMB:
+            case PcTextureAnimCodesJak2::FORTRESS_PRIS:
+            case PcTextureAnimCodesJak2::FORTRESS_WARP:
+            case PcTextureAnimCodesJak2::METKOR:
+            case PcTextureAnimCodesJak2::SHIELD:
+            case PcTextureAnimCodesJak2::KREW_HOLO: {
+              auto anim =
+                  anim_code_to_info(static_cast<PcTextureAnimCodesJak2>(vif0.immediate), *this);
+              auto p = scoped_prof(anim.name.c_str());
+              run_fixed_animation_array(anim.anim_array_idx, tf, texture_pool);
+              break;
+            }
+            case PcTextureAnimCodesJak2::CLOUDS_AND_FOG:
+            case PcTextureAnimCodesJak2::CLOUDS_HIRES: {
+              auto p = scoped_prof("clouds-and-fog");
+              handle_clouds_and_fog(tf, texture_pool,
+                                    vif0.immediate == (u16)PcTextureAnimCodesJak2::CLOUDS_HIRES);
+            } break;
+            case PcTextureAnimCodesJak2::SLIME: {
+              auto p = scoped_prof("slime");
+              handle_slime(tf, texture_pool);
+              break;
+            }
+            default:
+              lg::print("bad imm: {}\n", vif0.immediate);
+              ASSERT_NOT_REACHED();
+          }
+          break;
+        case GameVersion::Jak3:
+          switch (static_cast<PcTextureAnimCodesJak3>(vif0.immediate)) {
+            case PcTextureAnimCodesJak3::UPLOAD_CLUT_16_16: {
+              auto p = scoped_prof("clut-16-16");
+              handle_upload_clut_16_16(tf, ee_mem);
+            } break;
+            case PcTextureAnimCodesJak3::ERASE_DEST_TEXTURE: {
+              auto p = scoped_prof("erase");
+              handle_erase_dest(dma);
+            } break;
+            case PcTextureAnimCodesJak3::GENERIC_UPLOAD: {
+              auto p = scoped_prof("generic-upload");
+              handle_generic_upload(tf, ee_mem);
+            } break;
+            case PcTextureAnimCodesJak3::SET_SHADER: {
+              auto p = scoped_prof("set-shader");
+              handle_set_shader(dma);
+            } break;
+            case PcTextureAnimCodesJak3::DRAW: {
+              auto p = scoped_prof("draw");
+              handle_draw(dma, *texture_pool);
+            } break;
+            case PcTextureAnimCodesJak3::FINISH_ARRAY:
+              done = true;
+              break;
+            case PcTextureAnimCodesJak3::DARKJAK: {
+              auto p = scoped_prof("darkjak");
+              run_clut_blender_group(tf, m_darkjak_clut_blender_idx, frame_idx);
+            } break;
+            case PcTextureAnimCodesJak3::SKULL_GEM:
+            case PcTextureAnimCodesJak3::DEFAULT_WATER:
+            case PcTextureAnimCodesJak3::DEFAULT_WARP:
+            case PcTextureAnimCodesJak3::TEMPLEA_WATER:
+            case PcTextureAnimCodesJak3::TEMPLEA_WARP:
+            case PcTextureAnimCodesJak3::TEMPLEB_WARP:
+            case PcTextureAnimCodesJak3::TEMPLEC_WATER:
+            case PcTextureAnimCodesJak3::SEWC_WATER:
+            case PcTextureAnimCodesJak3::SEWD_WATER:
+            case PcTextureAnimCodesJak3::SEWE_WATER:
+            case PcTextureAnimCodesJak3::SEWG_WATER:
+            case PcTextureAnimCodesJak3::SEWH_WATER:
+            case PcTextureAnimCodesJak3::SEWI_WATER:
+            case PcTextureAnimCodesJak3::SEWJ_WATER:
+            case PcTextureAnimCodesJak3::SEWL_WATER:
+            case PcTextureAnimCodesJak3::SEWM_WATER:
+            case PcTextureAnimCodesJak3::SEWN_WATER:
+            case PcTextureAnimCodesJak3::DESRESC_WARP:
+            case PcTextureAnimCodesJak3::CTYSLUMB_WATER:
+            case PcTextureAnimCodesJak3::NSTB_QUICKSAND:
+            case PcTextureAnimCodesJak3::CTYSLUMC_WATER:
+            case PcTextureAnimCodesJak3::FACTORYC_ALPHA:
+            case PcTextureAnimCodesJak3::HFRAG:
+            case PcTextureAnimCodesJak3::HANGA_SPRITE:
+            case PcTextureAnimCodesJak3::HANGA_WATER:
+            case PcTextureAnimCodesJak3::DESERTD_WATER:
+            case PcTextureAnimCodesJak3::LMHCITYB_TFRAG:
+            case PcTextureAnimCodesJak3::TOWERB_WATER:
+            case PcTextureAnimCodesJak3::COMB_FIELD:
+            case PcTextureAnimCodesJak3::WASSTADA_ALPHA:
+            case PcTextureAnimCodesJak3::FACTORYB_WATER:
+            case PcTextureAnimCodesJak3::LMHCITYA_TFRAG:
+            case PcTextureAnimCodesJak3::MHCITYA_PRIS:
+            case PcTextureAnimCodesJak3::RUBBLEA_WATER:
+            case PcTextureAnimCodesJak3::RUBBLEA2_WATER:
+            case PcTextureAnimCodesJak3::RUBBLEB_WATER:
+            case PcTextureAnimCodesJak3::RUBBLEC_WATER:
+            case PcTextureAnimCodesJak3::FORESTA_WATER:
+            case PcTextureAnimCodesJak3::FORESTB_WATER:
+            case PcTextureAnimCodesJak3::LFORPLNT_PRIS:
+            case PcTextureAnimCodesJak3::LTNFXHIP:
+            case PcTextureAnimCodesJak3::LGUNNORM_WATER:
+            case PcTextureAnimCodesJak3::LJKDXVIN:
+            case PcTextureAnimCodesJak3::SECURITY:
+            case PcTextureAnimCodesJak3::WASPAL_WATER:
+            case PcTextureAnimCodesJak3::MINED_TFRAG:
+            case PcTextureAnimCodesJak3::VOLCANOX_WARP:
+            case PcTextureAnimCodesJak3::TEMPLEX_WATER:
+            case PcTextureAnimCodesJak3::VOLCANOA_WATER:
+            case PcTextureAnimCodesJak3::DESHOVER: {
+              auto anim =
+                  anim_code_to_info(static_cast<PcTextureAnimCodesJak3>(vif0.immediate), *this);
+              auto p = scoped_prof(anim.name.c_str());
+              run_fixed_animation_array(anim.anim_array_idx, tf, texture_pool);
+              break;
+            }
+            case PcTextureAnimCodesJak3::CLOUDS_AND_FOG:
+            case PcTextureAnimCodesJak3::CLOUDS_HIRES: {
+              auto p = scoped_prof("clouds-and-fog");
+              handle_clouds_and_fog(tf, texture_pool,
+                                    vif0.immediate == (u16)PcTextureAnimCodesJak3::CLOUDS_HIRES);
+              break;
+            }
+            default:
+              lg::print("bad imm: {}\n", vif0.immediate);
+              ASSERT_NOT_REACHED();
+          }
           break;
-        case DARKJAK: {
-          auto p = scoped_prof("darkjak");
-          run_clut_blender_group(tf, m_darkjak_clut_blender_idx, frame_idx);
-        } break;
-        case PRISON_JAK: {
-          auto p = scoped_prof("prisonjak");
-          run_clut_blender_group(tf, m_jakb_prison_clut_blender_idx, frame_idx);
-        } break;
-        case ORACLE_JAK: {
-          auto p = scoped_prof("oraclejak");
-          run_clut_blender_group(tf, m_jakb_oracle_clut_blender_idx, frame_idx);
-        } break;
-        case NEST_JAK: {
-          auto p = scoped_prof("nestjak");
-          run_clut_blender_group(tf, m_jakb_nest_clut_blender_idx, frame_idx);
-        } break;
-        case KOR_TRANSFORM: {
-          auto p = scoped_prof("kor");
-          run_clut_blender_group(tf, m_kor_transform_clut_blender_idx, frame_idx);
-        } break;
-        case SKULL_GEM: {
-          auto p = scoped_prof("skull-gem");
-          run_fixed_animation_array(m_skull_gem_fixed_anim_array_idx, tf, texture_pool);
-        } break;
-        case BOMB: {
-          auto p = scoped_prof("bomb");
-          run_fixed_animation_array(m_bomb_fixed_anim_array_idx, tf, texture_pool);
-        } break;
-        case CAS_CONVEYOR: {
-          auto p = scoped_prof("cas-conveyor");
-          run_fixed_animation_array(m_cas_conveyor_anim_array_idx, tf, texture_pool);
-        } break;
-        case SECURITY: {
-          auto p = scoped_prof("security");
-          run_fixed_animation_array(m_security_anim_array_idx, tf, texture_pool);
-        } break;
-        case WATERFALL: {
-          auto p = scoped_prof("waterfall");
-          run_fixed_animation_array(m_waterfall_anim_array_idx, tf, texture_pool);
-        } break;
-        case WATERFALL_B: {
-          auto p = scoped_prof("waterfall-b");
-          run_fixed_animation_array(m_waterfall_b_anim_array_idx, tf, texture_pool);
-        } break;
-        case LAVA: {
-          auto p = scoped_prof("lava");
-          run_fixed_animation_array(m_lava_anim_array_idx, tf, texture_pool);
-        } break;
-        case LAVA_B: {
-          auto p = scoped_prof("lava-b");
-          run_fixed_animation_array(m_lava_b_anim_array_idx, tf, texture_pool);
-        } break;
-        case STADIUMB: {
-          auto p = scoped_prof("stadiumb");
-          run_fixed_animation_array(m_stadiumb_anim_array_idx, tf, texture_pool);
-        } break;
-        case FORTRESS_PRIS: {
-          auto p = scoped_prof("fort-pris");
-          run_fixed_animation_array(m_fortress_pris_anim_array_idx, tf, texture_pool);
-        } break;
-        case FORTRESS_WARP: {
-          auto p = scoped_prof("fort-warp");
-          run_fixed_animation_array(m_fortress_warp_anim_array_idx, tf, texture_pool);
-        } break;
-        case METKOR: {
-          auto p = scoped_prof("metkor");
-          run_fixed_animation_array(m_metkor_anim_array_idx, tf, texture_pool);
-        } break;
-        case SHIELD: {
-          auto p = scoped_prof("shield");
-          run_fixed_animation_array(m_shield_anim_array_idx, tf, texture_pool);
-        } break;
-        case KREW_HOLO: {
-          auto p = scoped_prof("krew-holo");
-          run_fixed_animation_array(m_krew_holo_anim_array_idx, tf, texture_pool);
-        } break;
-        case CLOUDS_AND_FOG:
-        case CLOUDS_HIRES: {
-          auto p = scoped_prof("clouds-and-fog");
-          handle_clouds_and_fog(tf, texture_pool, vif0.immediate == CLOUDS_HIRES);
-        } break;
-        case SLIME: {
-          auto p = scoped_prof("slime");
-          handle_slime(tf, texture_pool);
-        } break;
         default:
-          lg::print("bad imm: {}\n", vif0.immediate);
+          lg::print("unsupported game version {}\n", (int)this->m_version);
           ASSERT_NOT_REACHED();
       }
     } else {
@@ -1818,6 +2268,21 @@ void TextureAnimator::set_up_opengl_for_fixed(const FixedLayerDef& def,
                blend_c == GsAlpha::BlendMode::SOURCE && blend_d == GsAlpha::BlendMode::DEST) {
       glBlendEquation(GL_FUNC_ADD);
       glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+    } else if (blend_a == GsAlpha::BlendMode::SOURCE &&
+               blend_b == GsAlpha::BlendMode::ZERO_OR_FIXED &&
+               blend_c == GsAlpha::BlendMode::ZERO_OR_FIXED &&
+               blend_d == GsAlpha::BlendMode::ZERO_OR_FIXED && def.blend_fix == 128) {
+      glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
+    } else if (blend_a == GsAlpha::BlendMode::SOURCE &&
+               blend_b == GsAlpha::BlendMode::ZERO_OR_FIXED &&
+               blend_c == GsAlpha::BlendMode::ZERO_OR_FIXED &&
+               blend_d == GsAlpha::BlendMode::DEST) {
+      // 0, 2, 2, 1
+      // (Cs - 0) * FIX / 128 + Cd
+      // So source is fix / 128, and dest is 1
+      float color = (float)def.blend_fix / 128.f;
+      glBlendColor(color, color, color, color);
+      glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_ONE, GL_ONE, GL_ZERO);
     } else {
       lg::print("unhandled blend: {} {} {} {}\n", (int)blend_a, (int)blend_b, (int)blend_c,
                 (int)blend_d);
@@ -1958,14 +2423,23 @@ void TextureAnimator::set_draw_data_from_interpolated(DrawData* result,
                                                       const LayerVals& vals,
                                                       int w,
                                                       int h) {
-  ASSERT(vals.rot == 0);
   result->color = (vals.color * 128.f).cast<u32>();
   math::Vector2f pos_scale(vals.scale.x() * w, vals.scale.y() * h);
   math::Vector2f pos_offset(2048.f + (vals.offset.x() * w), 2048.f + (vals.offset.y() * h));
   math::Vector2f st_scale = vals.st_scale;
   math::Vector2f st_offset = vals.st_offset;
-  const math::Vector2f corners[4] = {math::Vector2f{-0.5, -0.5}, math::Vector2f{0.5, -0.5},
-                                     math::Vector2f{-0.5, 0.5}, math::Vector2f{0.5, 0.5}};
+  math::Vector2f corners[4] = {math::Vector2f{-0.5, -0.5}, math::Vector2f{0.5, -0.5},
+                               math::Vector2f{-0.5, 0.5}, math::Vector2f{0.5, 0.5}};
+  if (vals.rot) {
+    const float rotation_radians = 2.f * M_PI * vals.rot / 65536.f;
+    const float sine = std::sin(rotation_radians);
+    const float cosine = std::cos(rotation_radians);
+    math::Vector2f vx(sine, cosine);
+    math::Vector2f vy(cosine, -sine);
+    for (auto& corner : corners) {
+      corner = vx * corner.x() + vy * corner.y();
+    }
+  }
   math::Vector2f sts[4];
   math::Vector2<u32> poss[4];
 
@@ -2058,6 +2532,11 @@ void TextureAnimator::run_fixed_animation(FixedAnim& anim, float time) {
         glUniform1f(m_uniforms.alpha_multiply, 2.f);
         glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
         glColorMask(false, false, false, true);
+        if (anim.def.set_alpha) {
+          glUniform1i(m_uniforms.set_alpha, 1);
+          glUniform4f(m_uniforms.rgba, draw_data.color.x(), draw_data.color.x(),
+                      draw_data.color.x(), 128.f);
+        }
         glUniform1f(m_uniforms.alpha_multiply, 1.f);
         glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
       } else {
diff --git a/game/graphics/opengl_renderer/TextureAnimator.h b/game/graphics/opengl_renderer/TextureAnimator.h
index 6d91b1db96..1171d88033 100644
--- a/game/graphics/opengl_renderer/TextureAnimator.h
+++ b/game/graphics/opengl_renderer/TextureAnimator.h
@@ -59,7 +59,7 @@ struct ShaderContext {
 };
 
 struct OpenGLTexturePool {
-  OpenGLTexturePool();
+  OpenGLTexturePool(GameVersion version);
   ~OpenGLTexturePool();
   GLuint allocate(u64 w, u64 h);
   void free(GLuint texture, u64 w, u64 h);
@@ -148,6 +148,18 @@ struct FixedLayerDef {
   GsAlpha::BlendMode blend_modes[4];  // abcd
   u8 blend_fix = 0;
 
+  void set_blend(GsAlpha::BlendMode a,
+                 GsAlpha::BlendMode b,
+                 GsAlpha::BlendMode c,
+                 GsAlpha::BlendMode d,
+                 u8 fix) {
+    blend_modes[0] = a;
+    blend_modes[1] = b;
+    blend_modes[2] = c;
+    blend_modes[3] = d;
+    blend_fix = fix;
+  }
+
   void set_blend_b2_d1() {
     blend_modes[0] = GsAlpha::BlendMode::SOURCE;
     blend_modes[1] = GsAlpha::BlendMode::ZERO_OR_FIXED;
@@ -181,6 +193,15 @@ struct FixedAnimDef {
   // alpha blend off, so alpha doesn't matter i think.
   std::vector<FixedLayerDef> layers;
   bool move_to_pool = false;
+  bool set_alpha = false;
+  void set_times(std::vector<std::pair<float, float>> times) {
+    ASSERT(layers.size() >= times.size());
+    for (size_t i = 0; i < layers.size(); i++) {
+      auto& layer = layers.at(i);
+      layer.start_time = times.at(i).first;
+      layer.end_time = times.at(i).second;
+    }
+  }
 };
 
 struct DynamicLayerData {
@@ -343,6 +364,7 @@ class TextureAnimator {
     GLuint tcc;
     GLuint alpha_multiply;
     GLuint minimum, maximum;
+    GLuint set_alpha;
   } m_uniforms;
 
   struct {
@@ -396,6 +418,8 @@ class TextureAnimator {
       m_psm32_to_psm8_64_64;
   ClutReader m_clut_table;
 
+ public:
+  // jak 2
   int m_skull_gem_fixed_anim_array_idx = -1;
   int m_bomb_fixed_anim_array_idx = -1;
   int m_cas_conveyor_anim_array_idx = -1;
@@ -411,9 +435,58 @@ class TextureAnimator {
   int m_shield_anim_array_idx = -1;
   int m_krew_holo_anim_array_idx = -1;
 
+  // jak 3
+  int m_default_water_anim_array_idx = -1;
+  int m_default_warp_anim_array_idx = -1;
+  int m_templea_water_anim_array_idx = -1;
+  int m_templea_warp_anim_array_idx = -1;
+  int m_templeb_warp_anim_array_idx = -1;
+  int m_templec_water_anim_array_idx = -1;
+  int m_sewc_water_anim_array_idx = -1;
+  int m_sewd_water_anim_array_idx = -1;
+  int m_sewe_water_anim_array_idx = -1;
+  int m_sewg_water_anim_array_idx = -1;
+  int m_sewh_water_anim_array_idx = -1;
+  int m_sewi_water_anim_array_idx = -1;
+  int m_sewj_water_anim_array_idx = -1;
+  int m_sewl_water_anim_array_idx = -1;
+  int m_sewm_water_anim_array_idx = -1;
+  int m_sewn_water_anim_array_idx = -1;
+  int m_desresc_warp_anim_array_idx = -1;
+  int m_ctyslumb_water_anim_array_idx = -1;
+  int m_nstb_quicksand_anim_array_idx = -1;
+  int m_ctyslumc_water_anim_array_idx = -1;
+  int m_factoryc_alpha_anim_array_idx = -1;
+  int m_hfrag_anim_array_idx = -1;
+  int m_hanga_sprite_anim_array_idx = -1;
+  int m_hanga_water_anim_array_idx = -1;
+  int m_desertd_water_anim_array_idx = -1;
+  int m_lmhcityb_tfrag_anim_array_idx = -1;
+  int m_towerb_water_anim_array_idx = -1;
+  int m_comb_field_anim_array_idx = -1;
+  int m_wasstada_alpha_anim_array_idx = -1;
+  int m_factoryb_water_anim_array_idx = -1;
+  int m_lmhcitya_tfrag_anim_array_idx = -1;
+  int m_mhcitya_pris_anim_array_idx = -1;
+  int m_rubblea_water_anim_array_idx = -1;
+  int m_rubblea2_water_anim_array_idx = -1;
+  int m_rubbleb_water_anim_array_idx = -1;
+  int m_rubblec_water_anim_array_idx = -1;
+  int m_foresta_water_anim_array_idx = -1;
+  int m_forestb_water_anim_array_idx = -1;
+  int m_lforplnt_pris_anim_array_idx = -1;
+  int m_ltnfxhip_anim_array_idx = -1;
+  int m_lgunnorm_water_anim_array_idx = -1;
+  int m_ljkdxvin_anim_array_idx = -1;
+  int m_waspal_water_anim_array_idx = -1;
+  int m_mined_tfrag_anim_array_idx = -1;
+  int m_volcanox_warp_anim_array_idx = -1;
+  int m_templex_water_anim_array_idx = -1;
+  int m_volcanoa_anim_array_idx = -1;
+  int m_deshover_anim_array_idx = -1;
+
   std::vector<FixedAnimArray> m_fixed_anim_arrays;
 
- public:
   // note: for now these can't be easily changed because each layer has its own hand-tuned
   // parameters from the original game. If you want to change it, you'll need to make up parameters
   // for those new layers.
diff --git a/game/graphics/opengl_renderer/TextureAnimatorDefs.cpp b/game/graphics/opengl_renderer/TextureAnimatorDefs.cpp
index 4928a19e14..9117eb7aa0 100644
--- a/game/graphics/opengl_renderer/TextureAnimatorDefs.cpp
+++ b/game/graphics/opengl_renderer/TextureAnimatorDefs.cpp
@@ -3,6 +3,1677 @@
 void TextureAnimator::setup_texture_anims_jak3() {
   m_darkjak_clut_blender_idx = create_clut_blender_group(
       {"jakc-arm", "jakc-eyebrow", "jakc-face", "jakc-finger", "jakc-hair"}, "-norm", "-dark", {});
+
+  // default-water
+  {
+    FixedAnimDef bomb_gradient;
+    bomb_gradient.tex_name = "bomb-gradient";
+    bomb_gradient.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    bomb_gradient.override_size = math::Vector2<int>(64, 64);
+
+    auto& bomb_rim = bomb_gradient.layers.emplace_back();
+    bomb_rim.tex_name = "bomb-gradient-rim";
+    bomb_rim.end_time = 300.f;
+    bomb_rim.set_blend_b2_d1();
+    bomb_rim.set_no_z_write_no_z_test();
+    bomb_rim.channel_masks[3] = false;  // no alpha writes.
+
+    auto& bomb_flames = bomb_gradient.layers.emplace_back();
+    bomb_flames.tex_name = "bomb-gradient-flames";
+    bomb_flames.end_time = 300.f;
+    bomb_flames.set_blend_b2_d1();
+    bomb_flames.set_no_z_write_no_z_test();
+    bomb_flames.channel_masks[3] = false;  // no alpha writes.
+
+    FixedAnimDef blue_beam_dest;
+    blue_beam_dest.tex_name = "blue-beam-dest";
+    blue_beam_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    blue_beam_dest.override_size = math::Vector2<int>(128, 128);
+
+    auto& beam01 = blue_beam_dest.layers.emplace_back();
+    beam01.tex_name = "lightning-beam-01";
+    beam01.end_time = 300.f;
+    beam01.set_blend_b2_d1();
+    beam01.set_no_z_write_no_z_test();
+    beam01.channel_masks[3] = false;  // no alpha writes.
+
+    auto& beam02 = blue_beam_dest.layers.emplace_back();
+    beam02.tex_name = "lightning-beam-02";
+    beam02.end_time = 300.f;
+    beam02.set_blend_b2_d1();
+    beam02.set_no_z_write_no_z_test();
+    beam02.channel_masks[3] = false;  // no alpha writes.
+
+    FixedAnimDef lightjak_wings;
+    lightjak_wings.tex_name = "lightjak-wings";
+    lightjak_wings.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    lightjak_wings.override_size = math::Vector2<int>(64, 16);
+
+    auto& u_src = lightjak_wings.layers.emplace_back();
+    u_src.tex_name = "lightjak-wings-u-src";
+    u_src.end_time = 300.f;
+    u_src.set_blend_b2_d1();
+    u_src.set_no_z_write_no_z_test();
+    u_src.set_clamp();
+    u_src.channel_masks[3] = false;  // no alpha writes.
+
+    auto& v_src = lightjak_wings.layers.emplace_back();
+    v_src.tex_name = "lightjak-wings-v-src";
+    v_src.end_time = 300.f;
+    v_src.set_blend_b2_d1();
+    v_src.set_no_z_write_no_z_test();
+    v_src.set_clamp();
+    v_src.channel_masks[3] = false;  // no alpha writes.
+
+    FixedAnimDef mushroom_dest;
+    mushroom_dest.tex_name = "mushroom-dest";
+    mushroom_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    mushroom_dest.override_size = math::Vector2<int>(128, 64);
+
+    auto& mushroom_src0 = mushroom_dest.layers.emplace_back();
+    mushroom_src0.tex_name = "mushroom-src";
+    mushroom_src0.end_time = 1200.f;
+    mushroom_src0.set_blend_b1_d1();
+    mushroom_src0.set_no_z_write_no_z_test();
+    mushroom_src0.set_clamp();
+
+    auto& mushroom_src1 = mushroom_dest.layers.emplace_back();
+    mushroom_src1.tex_name = "mushroom-src";
+    mushroom_src1.end_time = 1200.f;
+    // :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x2 :fix #x80)
+    mushroom_src1.set_blend(GsAlpha::BlendMode::SOURCE, GsAlpha::BlendMode::ZERO_OR_FIXED,
+                            GsAlpha::BlendMode::ZERO_OR_FIXED, GsAlpha::BlendMode::ZERO_OR_FIXED,
+                            0x80);
+    mushroom_src1.set_no_z_write_no_z_test();
+    mushroom_src1.set_clamp();
+    mushroom_src1.channel_masks[3] = false;  // no alpha writes.
+
+    m_default_water_anim_array_idx =
+        create_fixed_anim_array({bomb_gradient, blue_beam_dest, lightjak_wings, mushroom_dest});
+  }
+
+  // default-warp
+  {
+    FixedAnimDef shield_env_rim_dest;
+    shield_env_rim_dest.tex_name = "shield-env-rim-dest";
+    shield_env_rim_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    shield_env_rim_dest.override_size = math::Vector2<int>(64, 64);
+    shield_env_rim_dest.move_to_pool = true;
+
+    auto& cwhite = shield_env_rim_dest.layers.emplace_back();
+    cwhite.tex_name = "common-white";
+    cwhite.end_time = 1200.f;
+    cwhite.set_blend_b2_d1();
+    cwhite.set_no_z_write_no_z_test();
+
+    for (int i = 0; i < 2; i++) {
+      auto& uscroll = shield_env_rim_dest.layers.emplace_back();
+      uscroll.tex_name = "shield-env-uscroll";
+      uscroll.end_time = 1200.f;
+      uscroll.set_blend_b2_d1();
+      uscroll.set_no_z_write_no_z_test();
+      uscroll.channel_masks[3] = false;  // no alpha writes.
+    }
+
+    for (int i = 0; i < 2; i++) {
+      auto& rim_src = shield_env_rim_dest.layers.emplace_back();
+      rim_src.tex_name = "shield-env-rim-src";
+      rim_src.end_time = 1200.f;
+      rim_src.set_blend_b2_d1();
+      rim_src.set_no_z_write_no_z_test();
+      rim_src.channel_masks[3] = false;  // no alpha writes.
+    }
+
+    m_default_warp_anim_array_idx = create_fixed_anim_array({shield_env_rim_dest});
+  }
+
+  // templea-water
+  {
+    FixedAnimDef templea_waterfall_dest;
+    templea_waterfall_dest.tex_name = "templea-waterfall-dest";
+    templea_waterfall_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    templea_waterfall_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = templea_waterfall_dest.layers.emplace_back();
+      water.tex_name = "templea-waterfall";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef lightjak_wings;
+    lightjak_wings.tex_name = "lightjak-wings";
+    lightjak_wings.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    lightjak_wings.override_size = math::Vector2<int>(64, 16);
+
+    auto& u_src = lightjak_wings.layers.emplace_back();
+    u_src.tex_name = "lightjak-wings-u-src";
+    u_src.end_time = 300.f;
+    u_src.set_blend_b2_d1();
+    u_src.set_no_z_write_no_z_test();
+    u_src.set_clamp();
+    u_src.channel_masks[3] = false;  // no alpha writes.
+
+    auto& v_src = lightjak_wings.layers.emplace_back();
+    v_src.tex_name = "lightjak-wings-v-src";
+    v_src.end_time = 300.f;
+    v_src.set_blend_b2_d1();
+    v_src.set_no_z_write_no_z_test();
+    v_src.set_clamp();
+    v_src.channel_masks[3] = false;  // no alpha writes.
+
+    m_templea_water_anim_array_idx =
+        create_fixed_anim_array({templea_waterfall_dest, lightjak_wings});
+  }
+
+  // hanga-sprite
+  {
+    FixedAnimDef dest2;
+    dest2.move_to_pool = true;
+    dest2.color = math::Vector4<u8>(0, 0, 0, 0x80);
+    dest2.tex_name = "glider-ring-dest2";
+    dest2.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 17; i++) {
+      auto& foam = dest2.layers.emplace_back();
+      foam.tex_name = "splash-foam";
+      //    :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+      foam.set_no_z_write_no_z_test();
+      foam.channel_masks[3] = false;  // no alpha writes.
+      //    :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+      foam.set_clamp();
+      foam.set_blend_b2_d1();
+    }
+    dest2.set_times({
+        {0.f, 25.f},
+        {25.f, 150.f},
+        {25.f, 50.f},
+        {50.f, 150.f},
+        {0.f, 25.f},
+        {50.f, 75.f},
+        {75.f, 150.f},
+        {0.f, 50.f},
+        {75.f, 100.f},
+        {100.f, 150.f},
+        {0.f, 75.f},
+        {100.f, 125.f},
+        {125.f, 150.f},
+        {0.f, 100.f},
+        {125.f, 150.f},
+        {0.f, 125.f},
+        {0.f, 150.f},
+    });
+
+    FixedAnimDef dest;
+    dest.color = math::Vector4<u8>(0, 0, 0, 0x80);
+    dest.tex_name = "glider-ring-dest";
+    dest.override_size = math::Vector2<int>(128, 128);
+    dest.move_to_pool = true;
+
+    auto& ring_dest2 = dest.layers.emplace_back();
+    ring_dest2.set_blend_b2_d1();
+    ring_dest2.set_no_z_write_no_z_test();
+    ring_dest2.tex_name = "glider-ring-dest2";
+    ring_dest2.end_time = 9000.f;
+
+    for (int i = 0; i < 2; i++) {
+      auto& dsrc = dest.layers.emplace_back();
+      dsrc.set_blend_b2_d1();
+      dsrc.set_no_z_write_no_z_test();
+      dsrc.end_time = 9000.f;
+      dsrc.tex_name = "racegate";
+    }
+
+    m_hanga_sprite_anim_array_idx = create_fixed_anim_array({dest2, dest});
+  }
+
+  // foresta-water
+  {
+    FixedAnimDef fora_water_dest;
+    fora_water_dest.tex_name = "fora-water-dest";
+    fora_water_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    fora_water_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = fora_water_dest.layers.emplace_back();
+      water.tex_name = "fora-water";
+      water.end_time = 2100.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef fora_waterfall_dest;
+    fora_waterfall_dest.tex_name = "fora-waterfall-01-dest";
+    fora_waterfall_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    fora_waterfall_dest.override_size = math::Vector2<int>(64, 64);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = fora_waterfall_dest.layers.emplace_back();
+      water.tex_name = "fora-waterfall-01";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef fora_water_wave_dest;
+    fora_water_wave_dest.tex_name = "fora-water-wave-01-dest";
+    fora_water_wave_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    fora_water_wave_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = fora_water_wave_dest.layers.emplace_back();
+      water.tex_name = "fora-water-wave-01";
+      water.end_time = 1800.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_foresta_water_anim_array_idx =
+        create_fixed_anim_array({fora_water_dest, fora_waterfall_dest, fora_water_wave_dest});
+  }
+
+  // forestb-water
+  {
+    FixedAnimDef forb_water_dest;
+    forb_water_dest.tex_name = "forb-water-dest";
+    forb_water_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    forb_water_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = forb_water_dest.layers.emplace_back();
+      water.tex_name = "forb-water";
+      water.end_time = 2100.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef forb_waterfall_dest;
+    forb_waterfall_dest.tex_name = "forb-waterfall-01-dest";
+    forb_waterfall_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    forb_waterfall_dest.override_size = math::Vector2<int>(64, 64);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = forb_waterfall_dest.layers.emplace_back();
+      water.tex_name = "forb-waterfall-01";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef forb_water_wave_dest;
+    forb_water_wave_dest.tex_name = "forb-water-wave-01-dest";
+    forb_water_wave_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    forb_water_wave_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = forb_water_wave_dest.layers.emplace_back();
+      water.tex_name = "forb-water-wave-01";
+      water.end_time = 1800.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_forestb_water_anim_array_idx =
+        create_fixed_anim_array({forb_water_dest, forb_waterfall_dest, forb_water_wave_dest});
+  }
+
+  // lforplnt-pris
+  {
+    FixedAnimDef gem_dest;
+    gem_dest.tex_name = "mh-gem-dest";
+    gem_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    gem_dest.override_size = math::Vector2<int>(32, 32);
+
+    auto& gem0 = gem_dest.layers.emplace_back();
+    gem0.tex_name = "mh-gem";
+    gem0.end_time = 300.f;
+    gem0.set_blend_b2_d1();
+    gem0.set_no_z_write_no_z_test();
+
+    auto& gem1 = gem_dest.layers.emplace_back();
+    gem1.tex_name = "mh-gem-alpha-01";
+    gem1.end_time = 300.f;
+    gem1.set_blend_b2_d1();
+    gem1.set_no_z_write_no_z_test();
+
+    auto& gem2 = gem_dest.layers.emplace_back();
+    gem2.tex_name = "mh-gem-alpha-02";
+    gem2.end_time = 300.f;
+    gem2.set_blend_b2_d1();
+    gem2.set_no_z_write_no_z_test();
+
+    m_lforplnt_pris_anim_array_idx = create_fixed_anim_array({gem_dest});
+  }
+
+  // lmhcitya-tfrag
+  {
+    FixedAnimDef base_goo_dest;
+    base_goo_dest.tex_name = "mhcitya-base-goo-01-dest";
+    base_goo_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    base_goo_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (size_t i = 0; i < 3; i++) {
+      auto& goo = base_goo_dest.layers.emplace_back();
+      goo.tex_name = "mhcitya-base-goo-01";
+      goo.end_time = 6000.f;
+      goo.set_no_z_write_no_z_test();
+      // :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+      goo.blend_modes[0] = GsAlpha::BlendMode::SOURCE;
+      goo.blend_modes[1] = GsAlpha::BlendMode::ZERO_OR_FIXED;
+      goo.blend_modes[2] = GsAlpha::BlendMode::ZERO_OR_FIXED;
+      goo.blend_modes[3] = GsAlpha::BlendMode::DEST;
+      goo.blend_fix = 0x2b;
+    }
+
+    m_lmhcitya_tfrag_anim_array_idx = create_fixed_anim_array({base_goo_dest});
+  }
+
+  // lmhcityb-tfrag
+  {
+    FixedAnimDef base_goo_dest;
+    base_goo_dest.tex_name = "mhcityb-base-goo-01-dest";
+    base_goo_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    base_goo_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (size_t i = 0; i < 3; i++) {
+      auto& goo = base_goo_dest.layers.emplace_back();
+      goo.tex_name = "mhcityb-base-goo-01";
+      goo.end_time = 6000.f;
+      goo.set_no_z_write_no_z_test();
+      // :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+      goo.set_blend(GsAlpha::BlendMode::SOURCE, GsAlpha::BlendMode::ZERO_OR_FIXED,
+                    GsAlpha::BlendMode::ZERO_OR_FIXED, GsAlpha::BlendMode::DEST, 0x2b);
+    }
+    m_lmhcityb_tfrag_anim_array_idx = create_fixed_anim_array({base_goo_dest});
+  }
+
+  // mhcitya-pris
+  // destination texture is missing
+  // {
+  //   FixedAnimDef door_skin_dest;
+  //   door_skin_dest.tex_name = "mhcity-de-door-skin-01-dest";
+  //   door_skin_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+  //   door_skin_dest.override_size = math::Vector2<int>(128, 128);
+  //
+  //   auto& door0 = door_skin_dest.layers.emplace_back();
+  //   door0.tex_name = "mhcity-de-door-skin-01";
+  //   door0.end_time = 1.f;
+  //   door0.set_no_z_write_no_z_test();
+  //   // :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x80)
+  //   door0.set_blend(GsAlpha::BlendMode::SOURCE, GsAlpha::BlendMode::ZERO_OR_FIXED,
+  //                   GsAlpha::BlendMode::ZERO_OR_FIXED, GsAlpha::BlendMode::DEST, 0x80);
+  //
+  //   auto& door1 = door_skin_dest.layers.emplace_back();
+  //   door1.tex_name = "mhcity-de-door-skin-02";
+  //   door1.end_time = 1.f;
+  //   door1.set_no_z_write_no_z_test();
+  //   // :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x80)
+  //   door0.set_blend(GsAlpha::BlendMode::SOURCE, GsAlpha::BlendMode::ZERO_OR_FIXED,
+  //                   GsAlpha::BlendMode::ZERO_OR_FIXED, GsAlpha::BlendMode::DEST, 0x80);
+  //
+  //   auto& door2 = door_skin_dest.layers.emplace_back();
+  //   door2.tex_name = "mhcity-de-door-skin-01";
+  //   door2.end_time = 1.f;
+  //   door2.set_no_z_write_no_z_test();
+  //   door1.set_blend_b1_d1();
+  //
+  //   m_mhcitya_pris_anim_array_idx = create_fixed_anim_array({door_skin_dest});
+  // }
+
+  // templec-water
+  {
+    FixedAnimDef tplc_water;
+    tplc_water.tex_name = "tplc-water-dest";
+    tplc_water.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    tplc_water.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = tplc_water.layers.emplace_back();
+      water.tex_name = "tplc-water";
+      water.end_time = 2100.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_templec_water_anim_array_idx = create_fixed_anim_array({tplc_water});
+  }
+
+  // sewc-water
+  {
+    FixedAnimDef sewer_water_01_dest;
+    sewer_water_01_dest.tex_name = "sewer-water-01-c-dest";
+    sewer_water_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-01-c";
+      water.end_time = 900.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_waterfall_01_dest;
+    sewer_waterfall_01_dest.tex_name = "sewer-waterfall-01-c-dest";
+    sewer_waterfall_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-01-c";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_waterfall_02_dest;
+    sewer_waterfall_02_dest.tex_name = "sewer-waterfall-02-c-dest";
+    sewer_waterfall_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_02_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-02-c";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_wave_01_dest;
+    sewer_water_wave_01_dest.tex_name = "sewer-water-wave-01-c-dest";
+    sewer_water_wave_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_wave_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_wave_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-wave-01-c";
+      water.end_time = 1800.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_highlight_01_dest;
+    sewer_water_highlight_01_dest.tex_name = "sewer-water-highlight-01-c-dest";
+    sewer_water_highlight_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_highlight_01_dest.override_size = math::Vector2<int>(64, 32);
+
+    for (int i = 0; i < 2; i++) {
+      auto& water = sewer_water_highlight_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-highlight-01-c";
+      water.end_time = 600.f;
+      water.set_blend_b1_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_sewc_water_anim_array_idx = create_fixed_anim_array(
+        {sewer_water_01_dest, sewer_waterfall_01_dest, sewer_waterfall_02_dest,
+         sewer_water_wave_01_dest, sewer_water_highlight_01_dest});
+  }
+
+  // sewd-water
+  {
+    FixedAnimDef sewer_water_01_dest;
+    sewer_water_01_dest.tex_name = "sewer-water-01-d-dest";
+    sewer_water_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-01-d";
+      water.end_time = 900.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_waterfall_02_dest;
+    sewer_waterfall_02_dest.tex_name = "sewer-waterfall-02-d-dest";
+    sewer_waterfall_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_02_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-02-d";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_highlight_01_dest;
+    sewer_water_highlight_01_dest.tex_name = "sewer-water-highlight-01-d-dest";
+    sewer_water_highlight_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_highlight_01_dest.override_size = math::Vector2<int>(64, 32);
+
+    for (int i = 0; i < 2; i++) {
+      auto& water = sewer_water_highlight_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-highlight-01-d";
+      water.end_time = 600.f;
+      water.set_blend_b1_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_wave_01_dest;
+    sewer_water_wave_01_dest.tex_name = "sewer-water-wave-01-d-dest";
+    sewer_water_wave_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_wave_01_dest.override_size = math::Vector2<int>(64, 64);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_wave_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-wave-01-d";
+      water.end_time = 1800.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_wave_02_dest;
+    sewer_water_wave_02_dest.tex_name = "sewer-water-wave-02-d-dest";
+    sewer_water_wave_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_wave_02_dest.override_size = math::Vector2<int>(64, 64);
+
+    for (int i = 0; i < 2; i++) {
+      auto& water = sewer_water_wave_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-wave-02-d";
+      water.end_time = 300.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_still_01_dest;
+    sewer_water_still_01_dest.tex_name = "sewer-water-still-01-d-dest";
+    sewer_water_still_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_still_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_still_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-still-01-d";
+      water.end_time = 4500.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_sewd_water_anim_array_idx = create_fixed_anim_array(
+        {sewer_water_01_dest, sewer_waterfall_02_dest, sewer_water_highlight_01_dest,
+         sewer_water_wave_01_dest, sewer_water_wave_02_dest, sewer_water_still_01_dest});
+  }
+
+  // sewe-water
+  {
+    FixedAnimDef sewer_water_01_dest;
+    sewer_water_01_dest.tex_name = "sewer-water-01-e-dest";
+    sewer_water_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-01-e";
+      water.end_time = 900.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_waterfall_01_dest;
+    sewer_waterfall_01_dest.tex_name = "sewer-waterfall-01-e-dest";
+    sewer_waterfall_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-01-e";
+      water.end_time = 450.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_waterfall_02_dest;
+    sewer_waterfall_02_dest.tex_name = "sewer-waterfall-02-e-dest";
+    sewer_waterfall_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_02_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-02-e";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_highlight_01_dest;
+    sewer_water_highlight_01_dest.tex_name = "sewer-water-highlight-01-e-dest";
+    sewer_water_highlight_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_highlight_01_dest.override_size = math::Vector2<int>(64, 32);
+
+    for (int i = 0; i < 2; i++) {
+      auto& water = sewer_water_highlight_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-highlight-01-e";
+      water.end_time = 600.f;
+      water.set_blend_b1_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_sewe_water_anim_array_idx =
+        create_fixed_anim_array({sewer_water_01_dest, sewer_waterfall_01_dest,
+                                 sewer_waterfall_02_dest, sewer_water_highlight_01_dest});
+  }
+
+  // sewg-water
+  {
+    FixedAnimDef sewer_water_01_dest;
+    sewer_water_01_dest.tex_name = "sewer-water-01-g-dest";
+    sewer_water_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-01-g";
+      water.end_time = 900.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_waterfall_02_dest;
+    sewer_waterfall_02_dest.tex_name = "sewer-waterfall-02-g-dest";
+    sewer_waterfall_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_02_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-02-g";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_wave_01_dest;
+    sewer_water_wave_01_dest.tex_name = "sewer-water-wave-01-g-dest";
+    sewer_water_wave_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_wave_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_wave_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-wave-01-g";
+      water.end_time = 1800.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_sewg_water_anim_array_idx = create_fixed_anim_array(
+        {sewer_water_01_dest, sewer_waterfall_02_dest, sewer_water_wave_01_dest});
+  }
+
+  // sewh-water
+  {
+    FixedAnimDef sewer_water_01_dest;
+    sewer_water_01_dest.tex_name = "sewer-water-01-h-dest";
+    sewer_water_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-01-h";
+      water.end_time = 900.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_waterfall_02_dest;
+    sewer_waterfall_02_dest.tex_name = "sewer-waterfall-02-h-dest";
+    sewer_waterfall_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_02_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-02-h";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_wave_02_dest;
+    sewer_water_wave_02_dest.tex_name = "sewer-water-wave-02-h-dest";
+    sewer_water_wave_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_wave_02_dest.override_size = math::Vector2<int>(64, 64);
+
+    for (int i = 0; i < 2; i++) {
+      auto& water = sewer_water_wave_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-wave-02-h";
+      water.end_time = 1800.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_watefall_froth_01_dest;
+    sewer_watefall_froth_01_dest.tex_name = "sewer-watefall-froth-01-h-dest";
+    sewer_watefall_froth_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_watefall_froth_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_watefall_froth_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-watefall-froth-01-h";
+      water.end_time = 525.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_sewh_water_anim_array_idx =
+        create_fixed_anim_array({sewer_water_01_dest, sewer_waterfall_02_dest,
+                                 sewer_water_wave_02_dest, sewer_watefall_froth_01_dest});
+  }
+
+  // sewi-water
+  {
+    FixedAnimDef sewer_water_still_01_dest;
+    sewer_water_still_01_dest.tex_name = "sewer-water-still-01-i-dest";
+    sewer_water_still_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_still_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_still_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-still-01-i";
+      water.end_time = 4500.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_waterfall_02_dest;
+    sewer_waterfall_02_dest.tex_name = "sewer-waterfall-02-i-dest";
+    sewer_waterfall_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_02_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-02-i";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_wave_01_dest;
+    sewer_water_wave_01_dest.tex_name = "sewer-water-wave-01-i-dest";
+    sewer_water_wave_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_wave_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_wave_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-wave-01-i";
+      water.end_time = 1800.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_sewi_water_anim_array_idx = create_fixed_anim_array(
+        {sewer_water_still_01_dest, sewer_waterfall_02_dest, sewer_water_wave_01_dest});
+  }
+
+  // sewj-water
+  {
+    FixedAnimDef sewer_waterfall_02_dest;
+    sewer_waterfall_02_dest.tex_name = "sewer-waterfall-02-j-dest";
+    sewer_waterfall_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_02_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-02-j";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_watefall_froth_01_dest;
+    sewer_watefall_froth_01_dest.tex_name = "sewer-watefall-froth-01-j-dest";
+    sewer_watefall_froth_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_watefall_froth_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_watefall_froth_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-watefall-froth-01-j";
+      water.end_time = 525.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_sewj_water_anim_array_idx =
+        create_fixed_anim_array({sewer_waterfall_02_dest, sewer_watefall_froth_01_dest});
+  }
+
+  // sewl-water
+  {
+    FixedAnimDef sewer_waterfall_02_dest;
+    sewer_waterfall_02_dest.tex_name = "sewer-waterfall-02-l-dest";
+    sewer_waterfall_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_02_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-02-l";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_watefall_froth_01_dest;
+    sewer_watefall_froth_01_dest.tex_name = "sewer-watefall-froth-01-l-dest";
+    sewer_watefall_froth_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_watefall_froth_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_watefall_froth_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-watefall-froth-01-l";
+      water.end_time = 525.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_sewl_water_anim_array_idx =
+        create_fixed_anim_array({sewer_waterfall_02_dest, sewer_watefall_froth_01_dest});
+  }
+
+  // sewm-water
+  {
+    FixedAnimDef sewer_water_01_dest;
+    sewer_water_01_dest.tex_name = "sewer-water-01-m-dest";
+    sewer_water_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-01-m";
+      water.end_time = 900.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_waterfall_01_dest;
+    sewer_waterfall_01_dest.tex_name = "sewer-waterfall-01-m-dest";
+    sewer_waterfall_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-01-m";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_waterfall_02_dest;
+    sewer_waterfall_02_dest.tex_name = "sewer-waterfall-02-m-dest";
+    sewer_waterfall_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_02_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-02-m";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_highlight_01_dest;
+    sewer_water_highlight_01_dest.tex_name = "sewer-water-highlight-01-m-dest";
+    sewer_water_highlight_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_highlight_01_dest.override_size = math::Vector2<int>(64, 32);
+
+    for (int i = 0; i < 2; i++) {
+      auto& water = sewer_water_highlight_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-highlight-01-m";
+      water.end_time = 600.f;
+      water.set_blend_b1_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_wave_01_dest;
+    sewer_water_wave_01_dest.tex_name = "sewer-water-wave-01-m-dest";
+    sewer_water_wave_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_wave_01_dest.override_size = math::Vector2<int>(64, 64);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_wave_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-wave-01-m";
+      water.end_time = 1800.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_still_01_dest;
+    sewer_water_still_01_dest.tex_name = "sewer-water-still-01-m-dest";
+    sewer_water_still_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_still_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_still_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-still-01-m";
+      water.end_time = 4500.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_watefall_froth_01_dest;
+    sewer_watefall_froth_01_dest.tex_name = "sewer-watefall-froth-01-m-dest";
+    sewer_watefall_froth_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_watefall_froth_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_watefall_froth_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-watefall-froth-01-m";
+      water.end_time = 525.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_sewm_water_anim_array_idx = create_fixed_anim_array(
+        {sewer_water_01_dest, sewer_waterfall_01_dest, sewer_waterfall_02_dest,
+         sewer_water_highlight_01_dest, sewer_water_wave_01_dest, sewer_water_still_01_dest,
+         sewer_watefall_froth_01_dest});
+  }
+
+  // sewn-water
+  {
+    FixedAnimDef sewer_waterfall_01_dest;
+    sewer_waterfall_01_dest.tex_name = "sewer-waterfall-01-n-dest";
+    sewer_waterfall_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-01-n";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_waterfall_02_dest;
+    sewer_waterfall_02_dest.tex_name = "sewer-waterfall-02-n-dest";
+    sewer_waterfall_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_waterfall_02_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_waterfall_02_dest.layers.emplace_back();
+      water.tex_name = "sewer-waterfall-02-n";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    // destination texture is missing
+    // FixedAnimDef sewer_water_highlight_01_dest;
+    // sewer_water_highlight_01_dest.tex_name = "sewer-water-highlight-01-m-dest";
+    // sewer_water_highlight_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    // sewer_water_highlight_01_dest.override_size = math::Vector2<int>(64, 32);
+    //
+    // for (int i = 0; i < 2; i++) {
+    //   auto& water = sewer_water_highlight_01_dest.layers.emplace_back();
+    //   water.tex_name = "sewer-water-highlight-01-n";
+    //   water.end_time = 600.f;
+    //   water.set_blend_b1_d1();
+    //   water.set_no_z_write_no_z_test();
+    // }
+
+    FixedAnimDef sewer_water_wave_01_dest;
+    sewer_water_wave_01_dest.tex_name = "sewer-water-wave-01-n-dest";
+    sewer_water_wave_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_wave_01_dest.override_size = math::Vector2<int>(64, 64);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_wave_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-wave-01-n";
+      water.end_time = 1800.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef sewer_water_still_01_dest;
+    sewer_water_still_01_dest.tex_name = "sewer-water-still-01-n-dest";
+    sewer_water_still_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sewer_water_still_01_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = sewer_water_still_01_dest.layers.emplace_back();
+      water.tex_name = "sewer-water-still-01-n";
+      water.end_time = 4500.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_sewn_water_anim_array_idx = create_fixed_anim_array(
+        {sewer_waterfall_01_dest, sewer_waterfall_02_dest,  // sewer_water_highlight_01_dest,
+         sewer_water_wave_01_dest, sewer_water_still_01_dest});
+  }
+
+  // hanga-water
+  // destination texture is missing
+  // {
+  //   FixedAnimDef des_thermal_01_dest;
+  //   des_thermal_01_dest.tex_name = "des-thermal-01-dest";
+  //   des_thermal_01_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+  //   des_thermal_01_dest.override_size = math::Vector2<int>(128, 64);
+  //
+  //   for (int i = 0; i < 3; i++) {
+  //     auto& water = des_thermal_01_dest.layers.emplace_back();
+  //     water.tex_name = "des-thermal-01";
+  //     water.end_time = 1200.f;
+  //     water.set_blend_b2_d1();
+  //     water.set_no_z_write_no_z_test();
+  //   }
+  //
+  //   m_hanga_water_anim_array_idx = create_fixed_anim_array({des_thermal_01_dest});
+  // }
+
+  // desresc-warp
+  {
+    FixedAnimDef sat_shield_dest;
+    sat_shield_dest.tex_name = "sat-shield-dest";
+    sat_shield_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    sat_shield_dest.override_size = math::Vector2<int>(64, 64);
+    sat_shield_dest.move_to_pool = true;
+
+    for (int i = 0; i < 2; i++) {
+      auto& env_uvscroll = sat_shield_dest.layers.emplace_back();
+      env_uvscroll.tex_name = "sat-shield-env-uvscroll";
+      env_uvscroll.end_time = 300.f;
+      env_uvscroll.set_blend_b2_d1();
+      env_uvscroll.set_no_z_write_no_z_test();
+      env_uvscroll.channel_masks[3] = false;
+    }
+
+    auto& shield = sat_shield_dest.layers.emplace_back();
+    shield.tex_name = "sat-shield";
+    shield.end_time = 300.f;
+    shield.set_blend_b2_d1();
+    shield.set_no_z_write_no_z_test();
+    shield.channel_masks[3] = false;
+
+    m_desresc_warp_anim_array_idx = create_fixed_anim_array({sat_shield_dest});
+  }
+
+  // templea-warp
+  // templeb-warp
+  // volcanox-warp
+  // deshover
+  // ljkdxvin
+  // ltnfxhip
+  {
+    FixedAnimDef holograph_env_rim_dest;
+    holograph_env_rim_dest.tex_name = "holograph-env-rim-dest";
+    holograph_env_rim_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    holograph_env_rim_dest.move_to_pool = true;
+
+    auto& env_noise = holograph_env_rim_dest.layers.emplace_back();
+    env_noise.tex_name = "holograph-env-noise";
+    env_noise.end_time = 1200.f;
+    env_noise.set_blend_b2_d1();
+    env_noise.set_no_z_write_no_z_test();
+    env_noise.channel_masks[3] = false;  // no alpha writes.
+
+    auto& env_scan = holograph_env_rim_dest.layers.emplace_back();
+    env_scan.tex_name = "holograph-env-scan";
+    env_scan.end_time = 1200.f;
+    env_scan.set_blend_b2_d1();
+    env_scan.set_no_z_write_no_z_test();
+    env_scan.channel_masks[3] = false;  // no alpha writes.
+
+    for (int i = 0; i < 2; i++) {
+      auto& rim = holograph_env_rim_dest.layers.emplace_back();
+      rim.tex_name = "holograph-env-rim";
+      rim.end_time = 1200.f;
+      rim.set_blend_b2_d1();
+      rim.set_no_z_write_no_z_test();
+      rim.channel_masks[3] = false;  // no alpha writes.
+    }
+
+    auto& phong_rim = holograph_env_rim_dest.layers.emplace_back();
+    phong_rim.tex_name = "environment-phong-rim";
+    phong_rim.end_time = 1200.f;
+    phong_rim.set_blend_b2_d1();
+    phong_rim.set_no_z_write_no_z_test();
+    phong_rim.channel_masks[3] = false;  // no alpha writes.
+
+    m_templea_warp_anim_array_idx = create_fixed_anim_array({holograph_env_rim_dest});
+    m_templeb_warp_anim_array_idx = create_fixed_anim_array({holograph_env_rim_dest});
+    m_volcanox_warp_anim_array_idx = create_fixed_anim_array({holograph_env_rim_dest});
+    m_deshover_anim_array_idx = create_fixed_anim_array({holograph_env_rim_dest});
+    m_ljkdxvin_anim_array_idx = create_fixed_anim_array({holograph_env_rim_dest});
+    m_ltnfxhip_anim_array_idx = create_fixed_anim_array({holograph_env_rim_dest});
+  }
+
+  // lgunnorm-water
+  {
+    FixedAnimDef kg_target_forcefield_dest;
+    kg_target_forcefield_dest.tex_name = "kg-target-c-forcefield-01-dest";
+    kg_target_forcefield_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    kg_target_forcefield_dest.override_size = math::Vector2<int>(64, 64);
+
+    for (int i = 0; i < 6; i++) {
+      auto& forcefield = kg_target_forcefield_dest.layers.emplace_back();
+      forcefield.tex_name = "kg-target-c-forcefield-01";
+      forcefield.set_blend_b2_d1();
+      forcefield.set_no_z_write_no_z_test();
+      forcefield.channel_masks[3] = false;
+    }
+
+    kg_target_forcefield_dest.set_times({
+        {0.f, 75.f},
+        {0.f, 75.f},
+        {0.f, 75.f},
+        {75.f, 150.f},
+        {75.f, 150.f},
+        {75.f, 150.f},
+    });
+
+    m_lgunnorm_water_anim_array_idx = create_fixed_anim_array({kg_target_forcefield_dest});
+  }
+
+  // templex-water
+  {
+    FixedAnimDef temple_waterfall_dest;
+    temple_waterfall_dest.tex_name = "temple-waterfall-dest";
+    temple_waterfall_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    temple_waterfall_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& waterfall = temple_waterfall_dest.layers.emplace_back();
+      waterfall.tex_name = "temple-waterfall";
+      waterfall.end_time = 600.f;
+      waterfall.set_blend_b2_d1();
+      waterfall.set_no_z_write_no_z_test();
+    }
+
+    m_templex_water_anim_array_idx = create_fixed_anim_array({temple_waterfall_dest});
+  }
+
+  // desertd-water
+  {
+    FixedAnimDef des_waterfall_dest;
+    des_waterfall_dest.tex_name = "des-waterfall-dest";
+    des_waterfall_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    des_waterfall_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& waterfall = des_waterfall_dest.layers.emplace_back();
+      waterfall.tex_name = "des-waterfall";
+      waterfall.end_time = 600.f;
+      waterfall.set_blend_b2_d1();
+      waterfall.set_no_z_write_no_z_test();
+    }
+
+    m_desertd_water_anim_array_idx = create_fixed_anim_array({des_waterfall_dest});
+  }
+
+  // towerb-water
+  {
+    FixedAnimDef tow_energy_bridge_dest;
+    tow_energy_bridge_dest.tex_name = "tow-energy-bridge-dest";
+    tow_energy_bridge_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    tow_energy_bridge_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& bridge = tow_energy_bridge_dest.layers.emplace_back();
+      bridge.tex_name = "tow-energy-bridge";
+      bridge.end_time = 2100.f;
+      bridge.set_blend_b2_d1();
+      bridge.set_no_z_write_no_z_test();
+    }
+
+    m_towerb_water_anim_array_idx = create_fixed_anim_array({tow_energy_bridge_dest});
+  }
+
+  // factoryb-water
+  {
+    FixedAnimDef hemi_gradient_dest;
+    hemi_gradient_dest.tex_name = "hemi-gradient-dest";
+    hemi_gradient_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    hemi_gradient_dest.override_size = math::Vector2<int>(64, 64);
+
+    auto& rim = hemi_gradient_dest.layers.emplace_back();
+    rim.tex_name = "hemi-gradient-rim";
+    rim.end_time = 600.f;
+    rim.set_blend_b2_d1();
+    rim.set_no_z_write_no_z_test();
+    rim.channel_masks[3] = false;
+
+    auto& flames = hemi_gradient_dest.layers.emplace_back();
+    flames.tex_name = "hemi-gradient-flames";
+    flames.end_time = 600.f;
+    flames.set_blend_b2_d1();
+    flames.set_no_z_write_no_z_test();
+    flames.channel_masks[3] = false;
+
+    FixedAnimDef hemi_gradient_flames_dest;
+    hemi_gradient_flames_dest.tex_name = "hemi-gradient-dest";
+    hemi_gradient_flames_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    hemi_gradient_flames_dest.override_size = math::Vector2<int>(64, 64);
+
+    auto& flames0 = hemi_gradient_dest.layers.emplace_back();
+    flames0.tex_name = "hemi-gradient-flames";
+    flames0.end_time = 600.f;
+    flames0.set_blend_b2_d1();
+    flames0.set_no_z_write_no_z_test();
+    flames0.channel_masks[3] = false;
+
+    m_factoryb_water_anim_array_idx =
+        create_fixed_anim_array({hemi_gradient_dest, hemi_gradient_flames_dest});
+  }
+
+  // factoryc-alpha
+  {
+    FixedAnimDef facc_convey_dest;
+    facc_convey_dest.tex_name = "facc-convey-dest";
+    facc_convey_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    facc_convey_dest.override_size = math::Vector2<int>(128, 128);
+
+    auto& convey = facc_convey_dest.layers.emplace_back();
+    convey.tex_name = "facc-convey";
+    convey.end_time = 300.f;
+    convey.set_blend_b2_d1();
+    convey.set_no_z_write_no_z_test();
+    convey.channel_masks[3] = false;
+
+    FixedAnimDef facc_convey_02_dest;
+    facc_convey_02_dest.tex_name = "facc-convey-02-dest";
+    facc_convey_02_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    facc_convey_02_dest.override_size = math::Vector2<int>(128, 128);
+
+    auto& convey_02 = facc_convey_02_dest.layers.emplace_back();
+    convey_02.tex_name = "facc-convey-02";
+    convey_02.end_time = 300.f;
+    convey_02.set_blend_b2_d1();
+    convey_02.set_no_z_write_no_z_test();
+    convey_02.channel_masks[3] = false;
+
+    m_factoryc_alpha_anim_array_idx =
+        create_fixed_anim_array({facc_convey_dest, facc_convey_02_dest});
+  }
+
+  // waspala-water
+  {
+    FixedAnimDef waspala_water_dest;
+    waspala_water_dest.tex_name = "waspala-water-dest";
+    waspala_water_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    waspala_water_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = waspala_water_dest.layers.emplace_back();
+      water.tex_name = "waspala-water";
+      water.end_time = 2100.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef waspala_waterfall_dest;
+    waspala_waterfall_dest.tex_name = "waspala-waterfall-dest";
+    waspala_waterfall_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    waspala_waterfall_dest.override_size = math::Vector2<int>(64, 64);
+
+    for (int i = 0; i < 3; i++) {
+      auto& waterfall = waspala_waterfall_dest.layers.emplace_back();
+      waterfall.tex_name = "waspala-waterfall";
+      waterfall.end_time = 600.f;
+      waterfall.set_blend_b2_d1();
+      waterfall.set_no_z_write_no_z_test();
+    }
+
+    m_waspal_water_anim_array_idx =
+        create_fixed_anim_array({waspala_water_dest, waspala_waterfall_dest});
+  }
+
+  // rubblea-water
+  {
+    FixedAnimDef rub_water_dest;
+    rub_water_dest.tex_name = "rub-water-dest";
+    rub_water_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    rub_water_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = rub_water_dest.layers.emplace_back();
+      water.tex_name = "rub-water";
+      water.end_time = 2100.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_rubblea_water_anim_array_idx = create_fixed_anim_array({rub_water_dest});
+  }
+
+  // rubblea2-water
+  {
+    FixedAnimDef ruba2_water_dest;
+    ruba2_water_dest.tex_name = "rub-water-desta2";
+    ruba2_water_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    ruba2_water_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = ruba2_water_dest.layers.emplace_back();
+      water.tex_name = "rub-watera2";
+      water.end_time = 2100.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_rubblea2_water_anim_array_idx = create_fixed_anim_array({ruba2_water_dest});
+  }
+
+  // rubbleb-water
+  {
+    FixedAnimDef rubb_water_dest;
+    rubb_water_dest.tex_name = "rub-water-destb";
+    rubb_water_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    rubb_water_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = rubb_water_dest.layers.emplace_back();
+      water.tex_name = "rub-waterb";
+      water.end_time = 2100.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_rubbleb_water_anim_array_idx = create_fixed_anim_array({rubb_water_dest});
+  }
+
+  // rubblec-water
+  {
+    FixedAnimDef rubc_water_dest;
+    rubc_water_dest.tex_name = "rub-water-destc";
+    rubc_water_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    rubc_water_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = rubc_water_dest.layers.emplace_back();
+      water.tex_name = "rub-waterc";
+      water.end_time = 2100.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_rubblec_water_anim_array_idx = create_fixed_anim_array({rubc_water_dest});
+  }
+
+  // nstb-quicksand
+  {
+    FixedAnimDef quicksand_dest;
+    quicksand_dest.tex_name = "nstb-quicksand-dest";
+    quicksand_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+
+    auto& scroll = quicksand_dest.layers.emplace_back();
+    scroll.tex_name = "nstb-quicksand-scroll";
+    scroll.end_time = 1200.f;
+    scroll.set_blend_b2_d1();
+    scroll.set_no_z_write_no_z_test();
+    scroll.channel_masks[3] = false;
+
+    m_nstb_quicksand_anim_array_idx = create_fixed_anim_array({quicksand_dest});
+  }
+
+  // ctyslumb-water
+  {
+    FixedAnimDef ctyslumb_water_dest;
+    ctyslumb_water_dest.tex_name = "ctyslumb-water-dest";
+    ctyslumb_water_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    ctyslumb_water_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = ctyslumb_water_dest.layers.emplace_back();
+      water.tex_name = "ctyslumb-water";
+      water.end_time = 2100.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef ctyslumb_fountain_fall_dest;
+    ctyslumb_fountain_fall_dest.tex_name = "ctyslumb-fountain-fall-dest";
+    ctyslumb_fountain_fall_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    ctyslumb_fountain_fall_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = ctyslumb_fountain_fall_dest.layers.emplace_back();
+      water.tex_name = "ctyslumb-fountain-fall";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_ctyslumb_water_anim_array_idx =
+        create_fixed_anim_array({ctyslumb_water_dest, ctyslumb_fountain_fall_dest});
+  }
+
+  // ctyslumc-water
+  {
+    FixedAnimDef ctyslumc_water_dest;
+    ctyslumc_water_dest.tex_name = "ctyslumc-water-dest";
+    ctyslumc_water_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    ctyslumc_water_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = ctyslumc_water_dest.layers.emplace_back();
+      water.tex_name = "ctyslumc-water";
+      water.end_time = 2100.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    FixedAnimDef ctyslumc_fountain_fall_dest;
+    ctyslumc_fountain_fall_dest.tex_name = "ctyslumc-fountain-fall-dest";
+    ctyslumc_fountain_fall_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    ctyslumc_fountain_fall_dest.override_size = math::Vector2<int>(128, 128);
+
+    for (int i = 0; i < 3; i++) {
+      auto& water = ctyslumc_fountain_fall_dest.layers.emplace_back();
+      water.tex_name = "ctyslumc-fountain-fall";
+      water.end_time = 600.f;
+      water.set_blend_b2_d1();
+      water.set_no_z_write_no_z_test();
+    }
+
+    m_ctyslumc_water_anim_array_idx =
+        create_fixed_anim_array({ctyslumc_water_dest, ctyslumc_fountain_fall_dest});
+  }
+
+  // mined-tfrag
+  {
+    FixedAnimDef mined_pillar_side_dest;
+    mined_pillar_side_dest.tex_name = "mined-pillar-side-dest";
+    mined_pillar_side_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    mined_pillar_side_dest.override_size = math::Vector2<int>(128, 128);
+
+    auto& side_cold = mined_pillar_side_dest.layers.emplace_back();
+    side_cold.tex_name = "mined-pillar-side-cold";
+    side_cold.end_time = 300.f;
+    // no alpha
+    side_cold.blend_enable = false;
+    side_cold.set_no_z_write_no_z_test();
+    side_cold.channel_masks[3] = false;
+
+    auto& side_cooling = mined_pillar_side_dest.layers.emplace_back();
+    side_cooling.tex_name = "mined-pillar-side-cooling";
+    side_cooling.end_time = 300.f;
+    side_cooling.set_blend_b1_d1();
+    side_cooling.set_no_z_write_no_z_test();
+    side_cooling.channel_masks[3] = false;
+
+    auto& side_hot = mined_pillar_side_dest.layers.emplace_back();
+    side_hot.tex_name = "mined-pillar-side-hot";
+    side_hot.end_time = 300.f;
+    side_hot.set_blend_b1_d1();
+    side_hot.set_no_z_write_no_z_test();
+    side_hot.channel_masks[3] = false;
+
+    auto& molten = mined_pillar_side_dest.layers.emplace_back();
+    molten.tex_name = "mined-pillar-molten";
+    molten.end_time = 300.f;
+    molten.set_blend_b2_d1();
+    molten.set_no_z_write_no_z_test();
+    molten.channel_masks[3] = false;
+
+    auto& side_cold1 = mined_pillar_side_dest.layers.emplace_back();
+    side_cold1.tex_name = "mined-pillar-side-cold";
+    side_cold1.end_time = 300.f;
+    side_cold1.set_blend_b1_d1();
+    side_cold1.set_no_z_write_no_z_test();
+
+    FixedAnimDef mined_pillar_top2side_dest;
+    mined_pillar_top2side_dest.tex_name = "mined-pillar-top2side-dest";
+    mined_pillar_top2side_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    mined_pillar_top2side_dest.override_size = math::Vector2<int>(128, 64);
+
+    auto& top2side_cold = mined_pillar_top2side_dest.layers.emplace_back();
+    top2side_cold.tex_name = "mined-pillar-top2side-cold";
+    top2side_cold.end_time = 300.f;
+    // no alpha
+    top2side_cold.blend_enable = false;
+    top2side_cold.set_no_z_write_no_z_test();
+    top2side_cold.channel_masks[3] = false;
+
+    auto& top2side_cooling = mined_pillar_top2side_dest.layers.emplace_back();
+    top2side_cooling.tex_name = "mined-pillar-top2side-cooling";
+    top2side_cooling.end_time = 300.f;
+    top2side_cooling.set_blend_b1_d1();
+    top2side_cooling.set_no_z_write_no_z_test();
+    top2side_cooling.channel_masks[3] = false;
+
+    auto& top2side_hot = mined_pillar_top2side_dest.layers.emplace_back();
+    top2side_hot.tex_name = "mined-pillar-top2side-hot";
+    top2side_hot.end_time = 300.f;
+    top2side_hot.set_blend_b1_d1();
+    top2side_hot.set_no_z_write_no_z_test();
+    top2side_hot.channel_masks[3] = false;
+
+    auto& top2side_molten = mined_pillar_top2side_dest.layers.emplace_back();
+    top2side_molten.tex_name = "mined-pillar-molten";
+    top2side_molten.end_time = 300.f;
+    top2side_molten.set_blend_b2_d1();
+    top2side_molten.set_no_z_write_no_z_test();
+    top2side_molten.channel_masks[3] = false;
+
+    auto& top2side_cold1 = mined_pillar_top2side_dest.layers.emplace_back();
+    top2side_cold1.tex_name = "mined-pillar-side-cold";
+    top2side_cold1.end_time = 300.f;
+    top2side_cold1.set_blend_b1_d1();
+    top2side_cold1.set_no_z_write_no_z_test();
+
+    FixedAnimDef mined_pillar_top_dest;
+    mined_pillar_top_dest.tex_name = "mined-pillar-top-dest";
+    mined_pillar_top_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    mined_pillar_top_dest.override_size = math::Vector2<int>(128, 128);
+
+    auto& top_cold = mined_pillar_top_dest.layers.emplace_back();
+    top_cold.tex_name = "mined-pillar-top-cold";
+    // no alpha
+    top_cold.blend_enable = false;
+    top_cold.set_no_z_write_no_z_test();
+    top_cold.channel_masks[3] = false;
+
+    auto& top_cooling = mined_pillar_top_dest.layers.emplace_back();
+    top_cooling.tex_name = "mined-pillar-top-cooling";
+    top_cooling.set_blend_b1_d1();
+    top_cooling.set_no_z_write_no_z_test();
+    top_cooling.channel_masks[3] = false;
+
+    for (size_t i = 0; i < 4; i++) {
+      auto& top_hot = mined_pillar_top_dest.layers.emplace_back();
+      top_hot.tex_name = "mined-pillar-top-hot";
+      top_hot.set_blend_b1_d1();
+      top_hot.set_no_z_write_no_z_test();
+      top_hot.channel_masks[3] = false;
+    }
+
+    auto& top_molten = mined_pillar_top_dest.layers.emplace_back();
+    top_molten.tex_name = "mined-pillar-molten-top";
+    top_molten.set_blend_b2_d1();
+    top_molten.set_no_z_write_no_z_test();
+    top_molten.channel_masks[3] = false;
+
+    auto& top_cold1 = mined_pillar_top_dest.layers.emplace_back();
+    top_cold1.tex_name = "mined-pillar-top-cold";
+    top_cold1.set_blend_b1_d1();
+    top_cold1.set_no_z_write_no_z_test();
+
+    mined_pillar_top_dest.set_times({
+        {0.f, 300.f},
+        {0.f, 300.f},
+        {0.f, 300.f},
+        {0.f, 150.f},
+        {150.f, 300.f},
+        {0.f, 150.f},
+        {150.f, 300.f},
+        {0.f, 300.f},
+    });
+
+    m_mined_tfrag_anim_array_idx = create_fixed_anim_array(
+        {mined_pillar_side_dest, mined_pillar_top2side_dest, mined_pillar_top_dest});
+  }
+
+  // volcanoa-alpha
+  {
+    FixedAnimDef vola_lava_dest;
+    vola_lava_dest.tex_name = "vola-lava-01-dest";
+    vola_lava_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    vola_lava_dest.override_size = math::Vector2<int>(128, 128);
+    vola_lava_dest.set_alpha = true;
+
+    for (int i = 0; i < 3; i++) {
+      auto& lava_fall = vola_lava_dest.layers.emplace_back();
+      lava_fall.tex_name = "vola-lava-fall";
+      lava_fall.end_time = 6000.f;
+      lava_fall.set_blend_b2_d1();
+      lava_fall.set_no_z_write_no_z_test();
+    }
+
+    // auto& alpha = vola_lava_dest.layers.emplace_back();
+    // alpha.tex_name = "";
+    // alpha.end_time = 2100.f;
+    // alpha.set_blend_b1_d1();
+    // alpha.set_no_z_write_no_z_test();
+    // alpha.channel_masks[3] = false;
+
+    FixedAnimDef vola_lava_fall_dest;
+    vola_lava_fall_dest.tex_name = "vola-lava-fall-dest";
+    vola_lava_fall_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    vola_lava_fall_dest.override_size = math::Vector2<int>(128, 128);
+    vola_lava_fall_dest.set_alpha = true;
+
+    for (int i = 0; i < 3; i++) {
+      auto& lava_fall = vola_lava_fall_dest.layers.emplace_back();
+      lava_fall.tex_name = "vola-lava-fall";
+      lava_fall.end_time = 6000.f;
+      lava_fall.set_blend_b2_d1();
+      lava_fall.set_no_z_write_no_z_test();
+    }
+
+    // auto& alpha1 = vola_lava_fall_dest.layers.emplace_back();
+    // alpha1.tex_name = "";
+    // alpha1.end_time = 2100.f;
+    // alpha1.set_blend_b1_d1();
+    // alpha1.set_no_z_write_no_z_test();
+    // alpha1.channel_masks[3] = false;
+
+    m_volcanoa_anim_array_idx = create_fixed_anim_array({vola_lava_dest, vola_lava_fall_dest});
+  }
+
+  // wasstada-alpha
+  {
+    FixedAnimDef wstd_lava_base_dest;
+    wstd_lava_base_dest.tex_name = "wstd-lava-base-dest";
+    wstd_lava_base_dest.color = math::Vector4<u8>{0, 0, 0, 0x80};
+    wstd_lava_base_dest.override_size = math::Vector2<int>(128, 128);
+    wstd_lava_base_dest.set_alpha = true;
+
+    for (int i = 0; i < 3; i++) {
+      auto& lava_base = wstd_lava_base_dest.layers.emplace_back();
+      lava_base.tex_name = "wstd-lava-base";
+      lava_base.end_time = 6000.f;
+      lava_base.set_blend_b2_d1();
+      lava_base.set_no_z_write_no_z_test();
+    }
+
+    // auto& alpha = wstd_lava_base_dest.layers.emplace_back();
+    // alpha.tex_name = "";
+    // alpha.end_time = 2100.f;
+    // alpha.set_blend_b1_d1();
+    // alpha.set_no_z_write_no_z_test();
+    // alpha.channel_masks[3] = false;
+
+    m_wasstada_alpha_anim_array_idx = create_fixed_anim_array({wstd_lava_base_dest});
+  }
 }
 
 void TextureAnimator::setup_texture_anims_common() {
@@ -35,6 +1706,46 @@ void TextureAnimator::setup_texture_anims_common() {
 
     m_skull_gem_fixed_anim_array_idx = create_fixed_anim_array({skull_gem});
   }
+
+  // SECURITY
+  {
+    FixedAnimDef env;
+    env.color = math::Vector4<u8>(0, 0, 0, 0x80);
+    env.tex_name = "security-env-dest";
+    for (int i = 0; i < 2; i++) {
+      auto& env1 = env.layers.emplace_back();
+      env1.tex_name = "security-env-uscroll";
+      //    :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+      env1.set_no_z_write_no_z_test();
+      env1.channel_masks[3] = false;  // no alpha writes.
+      //    :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+      env1.set_blend_b2_d1();
+      env1.end_time = 4800.f;
+    }
+
+    FixedAnimDef dot;
+    dot.color = math::Vector4<u8>(0, 0, 0, 0x80);
+    dot.tex_name = "security-dot-dest";
+
+    auto& cwhite = dot.layers.emplace_back();
+    cwhite.set_blend_b2_d1();
+    cwhite.set_no_z_write_no_z_test();
+    cwhite.tex_name = "common-white";
+    cwhite.end_time = 4800.f;
+
+    for (int i = 0; i < 2; i++) {
+      auto& dsrc = dot.layers.emplace_back();
+      dsrc.set_blend_b2_d1();
+      dsrc.set_no_z_write_no_z_test();
+      dsrc.end_time = 600.f;
+      dsrc.tex_name = "security-dot-src";
+    }
+
+    m_security_anim_array_idx = create_fixed_anim_array({env, dot});
+    if (this->m_version == GameVersion::Jak3) {
+      m_comb_field_anim_array_idx = create_fixed_anim_array({env, dot});
+    }
+  }
 }
 
 void TextureAnimator::setup_texture_anims_jak2() {
@@ -155,43 +1866,6 @@ void TextureAnimator::setup_texture_anims_jak2() {
         create_fixed_anim_array({conveyor_0, conveyor_1, conveyor_2, conveyor_3});
   }
 
-  // SECURITY
-  {
-    FixedAnimDef env;
-    env.color = math::Vector4<u8>(0, 0, 0, 0x80);
-    env.tex_name = "security-env-dest";
-    for (int i = 0; i < 2; i++) {
-      auto& env1 = env.layers.emplace_back();
-      env1.tex_name = "security-env-uscroll";
-      //    :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
-      env1.set_no_z_write_no_z_test();
-      env1.channel_masks[3] = false;  // no alpha writes.
-      //    :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-      env1.set_blend_b2_d1();
-      env1.end_time = 4800.f;
-    }
-
-    FixedAnimDef dot;
-    dot.color = math::Vector4<u8>(0, 0, 0, 0x80);
-    dot.tex_name = "security-dot-dest";
-
-    auto& cwhite = dot.layers.emplace_back();
-    cwhite.set_blend_b2_d1();
-    cwhite.set_no_z_write_no_z_test();
-    cwhite.tex_name = "common-white";
-    cwhite.end_time = 4800.f;
-
-    for (int i = 0; i < 2; i++) {
-      auto& dsrc = dot.layers.emplace_back();
-      dsrc.set_blend_b2_d1();
-      dsrc.set_no_z_write_no_z_test();
-      dsrc.end_time = 600.f;
-      dsrc.tex_name = "security-dot-src";
-    }
-
-    m_security_anim_array_idx = create_fixed_anim_array({env, dot});
-  }
-
   // WATERFALL
   {
     FixedAnimDef waterfall;
diff --git a/game/graphics/opengl_renderer/shaders/tex_anim.frag b/game/graphics/opengl_renderer/shaders/tex_anim.frag
index 8a30b96596..4ed17a5307 100644
--- a/game/graphics/opengl_renderer/shaders/tex_anim.frag
+++ b/game/graphics/opengl_renderer/shaders/tex_anim.frag
@@ -4,6 +4,7 @@ out vec4 color;
 
 uniform vec4 rgba;
 uniform int enable_tex;
+uniform int set_alpha;
 uniform int tcc;
 uniform ivec4 channel_scramble;
 uniform float alpha_multiply;
@@ -57,5 +58,9 @@ void main() {
   } else {
     color = (rgba / 128.);
   }
-  color.a *= alpha_multiply;
+  if (set_alpha == 1) {
+    color.a = rgba.a;
+  } else {
+    color.a *= alpha_multiply;
+  }
 }
\ No newline at end of file
diff --git a/goal_src/jak3/engine/gfx/background/hfrag/hfrag-texture-anim.gc b/goal_src/jak3/engine/gfx/background/hfrag/hfrag-texture-anim.gc
index 5596a60b59..dfa1356e8a 100644
--- a/goal_src/jak3/engine/gfx/background/hfrag/hfrag-texture-anim.gc
+++ b/goal_src/jak3/engine/gfx/background/hfrag/hfrag-texture-anim.gc
@@ -7,3 +7,204 @@
 
 ;; DECOMP BEGINS
 
+(defun wang-texture-anim-init ((arg0 texture-anim))
+  (let ((v1-1 (new 'loading-level 'texture)))
+    (let ((a0-2 122))
+      (set! (-> arg0 tex) v1-1)
+      (set! (-> v1-1 w) 16)
+      (set! (-> v1-1 h) 16)
+      (set! (-> v1-1 num-mips) (the-as uint 1))
+      (set! (-> v1-1 psm) (gs-psm mt8))
+      (set! (-> v1-1 clutpsm) (the-as uint 0))
+      (set! (-> v1-1 dest 0) (the-as uint (* a0-2 32)))
+      (set! (-> v1-1 clutdest) (the-as uint (* a0-2 32)))
+      )
+    (set! (-> v1-1 width 0) (the-as uint 1))
+    (set! (-> v1-1 masks data 0 mask quad) (the-as uint128 0))
+    (set! (-> v1-1 masks data 1 mask quad) (the-as uint128 0))
+    (set! (-> v1-1 masks data 2 mask quad) (the-as uint128 0))
+    )
+  0
+  0
+  (none)
+  )
+
+;; WARN: Return type mismatch float vs none.
+(defun real-wang-texture-anim-func ((arg0 texture-anim) (arg1 texture-anim))
+  (let ((v1-1 (-> *level* level-default mood-context))
+        (f0-0 0.0)
+        )
+    (let* ((f1-2 (* 0.75 (fmax (-> v1-1 times 0 x) (fmax (-> v1-1 times 0 y) (-> v1-1 times 0 z))) (-> v1-1 times 0 w)))
+           (f1-3 (- 1.0 f1-2))
+           (a0-4 1)
+           (a2-0 4)
+           )
+      (while (>= a2-0 a0-4)
+        (let* ((f2-6 (* (-> v1-1 times a0-4 w)
+                        (fmax (-> v1-1 times a0-4 x) (fmax (-> v1-1 times a0-4 y) (-> v1-1 times a0-4 z)))
+                        f1-3
+                        )
+                     )
+               (f2-7 (fmax 0.0 f2-6))
+               (f2-8 (fmin 1.0 f2-7))
+               )
+          (set! (-> arg1 data a0-4 start-color w) f2-8)
+          (set! (-> arg1 data a0-4 end-color w) f2-8)
+          (+! f0-0 f2-8)
+          )
+        (+! a0-4 1)
+        )
+      )
+    (let ((f0-1 (if (= f0-0 0.0)
+                    0.0
+                    (/ 0.75 f0-0)
+                    )
+                )
+          (v1-7 1)
+          (a0-5 4)
+          )
+      (while (>= a0-5 v1-7)
+        (set! (-> arg1 data v1-7 start-color w) (* (-> arg1 data v1-7 start-color w) f0-1))
+        (set! (-> arg1 data v1-7 end-color w) (* (-> arg1 data v1-7 end-color w) f0-1))
+        (+! v1-7 1)
+        )
+      )
+    )
+  (set! (-> arg1 data 0 start-color w) 0.7)
+  (set! (-> arg1 data 0 end-color w) 0.7)
+  (set! (-> arg1 data 2 start-color w) (* 0.65 (-> arg1 data 2 start-color w)))
+  (set! (-> arg1 data 2 end-color w) (* 0.65 (-> arg1 data 2 end-color w)))
+  (set! (-> arg1 data 3 start-color w) (* 0.65 (-> arg1 data 3 start-color w)))
+  (set! (-> arg1 data 3 end-color w) (* 0.65 (-> arg1 data 3 end-color w)))
+  (none)
+  )
+
+(defun wang-texture-anim-func ((arg0 texture-anim) (arg1 texture-anim))
+  (real-wang-texture-anim-func arg0 arg1)
+  (none)
+  )
+
+(define *hfrag-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'wang-texture-anim-func
+        :init-func-id 'wang-texture-anim-init
+        :tex #f
+        :tex-name #f
+        :color (new 'static 'rgba :a #x80)
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'blend-clut-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "wang_0"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'add-clut-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "wang_1"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'add-clut-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "wang_2"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'add-clut-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "wang_3"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'add-clut-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "wang_4"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/engine/gfx/texture/texture-anim.gc b/goal_src/jak3/engine/gfx/texture/texture-anim.gc
index 8abd5be83c..ef687ec358 100644
--- a/goal_src/jak3/engine/gfx/texture/texture-anim.gc
+++ b/goal_src/jak3/engine/gfx/texture/texture-anim.gc
@@ -76,33 +76,65 @@
   (erase-and-init 14)
   (upload-clut-16-16 15) ;; needed for fog clut upload
   (upload-generic-vram 16) ;; needed for fog texture upload
-  ; (set-shader 17)
-  ; (draw 18)
-  ; (move-rg-to-ba 19)
-  ; (set-clut-alpha 20)
-  ; (copy-clut-alpha 21)
+  (set-shader 17)
+  (draw 18)
+  (move-rg-to-ba 19)
+  (set-clut-alpha 20)
+  (copy-clut-alpha 21)
   (darkjak 22)
-  ; (prison-jak 23)
-  ; (oracle-jak 24)
-  ; (nest-jak 25)
-  ; (kor-transform 26)
   (skull-gem 27) ;; same as jak 2
-  ; (bomb 28)
-  ; (cas-conveyor 29)
-  ; (security 30)
-  ; (waterfall 31)
-  ; (waterfall-b 32)
-  ; (lava 33)
-  ; (lava-b 34)
-  ; (stadiumb 35)
-  ; (fortress-pris 36)
-  ; (fortress-warp 37)
-  ; (metkor 38)
-  ; (shield 39)
-  ; (krew-holo 40)
-  (clouds-and-fog 41) ;; same as jak 2
-  ; (slime 42)
-  ; (clouds-hires 43)
+  (default-water 28)
+  (default-warp 29)
+  (templea-water 30)
+  (templea-warp 31)
+  (templeb-warp 32)
+  (templec-water 33)
+  (sewc-water 34)
+  (sewd-water 35)
+  (sewe-water 36)
+  (sewg-water 37)
+  (sewh-water 38)
+  (sewi-water 39)
+  (sewj-water 40)
+  (sewl-water 41)
+  (sewm-water 42)
+  (sewn-water 43)
+  (desresc-warp 44)
+  (ctyslumb-water 45)
+  (nstb-quicksand 46)
+  (ctyslumc-water 47)
+  (factoryc-alpha 48)
+  (hfrag 49)
+  (hanga-sprite 50)
+  (hanga-water 51)
+  (desertd-water 52)
+  (lmhcityb-tfrag 53)
+  (towerb-water 54)
+  (comb-field 55)
+  (wasstada-alpha 56)
+  (factoryb-water 57)
+  (lmhcitya-tfrag 58)
+  (mhcitya-pris 59)
+  (rubblea-water 60)
+  (rubblea2-water 61)
+  (rubbleb-water 62)
+  (rubblec-water 63)
+  (foresta-water 64)
+  (forestb-water 65)
+  (lforplnt-pris 66)
+  (ltnfxhip 67)
+  (lgunnorm-water 68)
+  (ljkdxvin 69)
+  (security 70)
+  (waspal-water 71)
+  (mined-tfrag 72)
+  (volcanox-warp 73)
+  (templex-water 74)
+  (volcanoa-water 75)
+  (deshover 76)
+  (clouds-and-fog 77) ;; same as jak 2
+  (clouds-hires 78)
+  (set-alpha 79)
   )
 
 (deftype texture-anim-pc-upload (structure)
@@ -333,53 +365,53 @@
 (define-extern *skull-gem-texture-anim-array* (texture-anim-array texture-anim))
 (define-extern *default-water-texture-anim-array* (texture-anim-array texture-anim))
 (define-extern *default-warp-texture-anim-array* (texture-anim-array texture-anim))
-(define-extern *templea-water-texture-anim-array* texture-anim-array)
-(define-extern *templea-warp-texture-anim-array* texture-anim-array)
-(define-extern *templeb-warp-texture-anim-array* texture-anim-array)
-(define-extern *templec-water-texture-anim-array* texture-anim-array)
-(define-extern *sewc-water-texture-anim-array* texture-anim-array)
-(define-extern *sewd-water-texture-anim-array* texture-anim-array)
-(define-extern *sewe-water-texture-anim-array* texture-anim-array)
-(define-extern *sewg-water-texture-anim-array* texture-anim-array)
-(define-extern *sewh-water-texture-anim-array* texture-anim-array)
-(define-extern *sewi-water-texture-anim-array* texture-anim-array)
-(define-extern *sewj-water-texture-anim-array* texture-anim-array)
-(define-extern *sewl-water-texture-anim-array* texture-anim-array)
-(define-extern *sewm-water-texture-anim-array* texture-anim-array)
-(define-extern *sewn-water-texture-anim-array* texture-anim-array)
-(define-extern *desresc-warp-texture-anim-array* texture-anim-array)
-(define-extern *ctyslumb-water-texture-anim-array* texture-anim-array)
-(define-extern *nstb-quicksand-anim-array* texture-anim-array)
-(define-extern *ctyslumc-water-texture-anim-array* texture-anim-array)
-(define-extern *factoryc-alpha-texture-anim-array* texture-anim-array)
+(define-extern *templea-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *templea-warp-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *templeb-warp-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *templec-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewc-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewd-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewe-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewg-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewh-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewi-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewj-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewl-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewm-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *sewn-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *desresc-warp-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *ctyslumb-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *nstb-quicksand-anim-array* (texture-anim-array texture-anim))
+(define-extern *ctyslumc-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *factoryc-alpha-texture-anim-array* (texture-anim-array texture-anim))
 (define-extern *hfrag-texture-anim-array* (texture-anim-array texture-anim))
-(define-extern *hanga-sprite-texture-anim-array* texture-anim-array)
-(define-extern *hanga-water-texture-anim-array* texture-anim-array)
-(define-extern *desertd-water-texture-anim-array* texture-anim-array)
-(define-extern *lmhcityb-tfrag-texture-anim-array* texture-anim-array)
-(define-extern *towerb-water-texture-anim-array* texture-anim-array)
+(define-extern *hanga-sprite-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *hanga-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *desertd-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *lmhcityb-tfrag-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *towerb-water-texture-anim-array* (texture-anim-array texture-anim))
 (define-extern *comb-field-texture-anim-array* (texture-anim-array texture-anim))
-(define-extern *wasstada-alpha-texture-anim-array* texture-anim-array)
-(define-extern *factoryb-water-texture-anim-array* texture-anim-array)
-(define-extern *lmhcitya-tfrag-texture-anim-array* texture-anim-array)
-(define-extern *mhcitya-pris-texture-anim-array* texture-anim-array)
-(define-extern *rubblea-water-texture-anim-array* texture-anim-array)
-(define-extern *rubblea2-water-texture-anim-array* texture-anim-array)
-(define-extern *rubbleb-water-texture-anim-array* texture-anim-array)
-(define-extern *rubblec-water-texture-anim-array* texture-anim-array)
-(define-extern *foresta-water-texture-anim-array* texture-anim-array)
-(define-extern *forestb-water-texture-anim-array* texture-anim-array)
-(define-extern *lforplnt-pris-texture-anim-array* texture-anim-array)
-(define-extern *ltnfxhip-texture-anim-array* texture-anim-array)
-(define-extern *lgunnorm-water-texture-anim-array* texture-anim-array)
-(define-extern *ljkdxvin-texture-anim-array* texture-anim-array)
+(define-extern *wasstada-alpha-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *factoryb-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *lmhcitya-tfrag-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *mhcitya-pris-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *rubblea-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *rubblea2-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *rubbleb-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *rubblec-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *foresta-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *forestb-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *lforplnt-pris-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *ltnfxhip-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *lgunnorm-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *ljkdxvin-texture-anim-array* (texture-anim-array texture-anim))
 (define-extern *security-texture-anim-array* (texture-anim-array texture-anim))
-(define-extern *waspal-water-texture-anim-array* texture-anim-array)
-(define-extern *mined-tfrag-texture-anim-array* texture-anim-array)
-(define-extern *volcanox-warp-texture-anim-array* texture-anim-array)
-(define-extern *templex-water-texture-anim-array* texture-anim-array)
-(define-extern *volcanoa-alpha-texture-anim-array* texture-anim-array)
-(define-extern *deshover-texture-anim-array* texture-anim-array)
+(define-extern *waspal-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *mined-tfrag-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *volcanox-warp-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *templex-water-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *volcanoa-alpha-texture-anim-array* (texture-anim-array texture-anim))
+(define-extern *deshover-texture-anim-array* (texture-anim-array texture-anim))
 
 (defun make-sky-input ((si sky-input))
   (set! (-> si fog-height) (-> (the-as (array texture-anim) *sky-texture-anim-array*) 8 extra z))
@@ -462,199 +494,201 @@
            (return #f)
            )
           ((*default-water-texture-anim-array*)
-           (print-anim "*default-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc default-water) anim-array)
            (return #f)
            )
           ((*default-warp-texture-anim-array*)
-           (print-anim "*default-warp-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc default-warp) anim-array)
            (return #f)
            )
           ((*templea-water-texture-anim-array*)
-           (print-anim "*templea-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc templea-water) anim-array)
            (return #f)
            )
           ((*templea-warp-texture-anim-array*)
-           (print-anim "*templea-warp-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc templea-warp) anim-array)
            (return #f)
            )
           ((*templeb-warp-texture-anim-array*)
-           (print-anim "*templeb-warp-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc templeb-warp) anim-array)
            (return #f)
            )
           ((*templec-water-texture-anim-array*)
-           (print-anim "*templec-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc templec-water) anim-array)
            (return #f)
            )
           ((*sewc-water-texture-anim-array*)
-           (print-anim "*sewc-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc sewc-water) anim-array)
            (return #f)
            )
           ((*sewd-water-texture-anim-array*)
-           (print-anim "*sewd-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc sewd-water) anim-array)
            (return #f)
            )
           ((*sewe-water-texture-anim-array*)
-           (print-anim "*sewe-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc sewe-water) anim-array)
            (return #f)
            )
           ((*sewg-water-texture-anim-array*)
-           (print-anim "*sewg-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc sewg-water) anim-array)
            (return #f)
            )
           ((*sewh-water-texture-anim-array*)
-           (print-anim "*sewh-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc sewh-water) anim-array)
            (return #f)
            )
           ((*sewi-water-texture-anim-array*)
-           (print-anim "*sewi-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc sewi-water) anim-array)
            (return #f)
            )
           ((*sewj-water-texture-anim-array*)
-           (print-anim "*sewj-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc sewj-water) anim-array)
            (return #f)
            )
           ((*sewl-water-texture-anim-array*)
-           (print-anim "*sewl-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc sewl-water) anim-array)
            (return #f)
            )
           ((*sewm-water-texture-anim-array*)
-           (print-anim "*sewm-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc sewm-water) anim-array)
            (return #f)
            )
           ((*sewn-water-texture-anim-array*)
-           (print-anim "*sewn-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc sewn-water) anim-array)
            (return #f)
            )
           ((*desresc-warp-texture-anim-array*)
-           (print-anim "*desresc-warp-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc desresc-warp) anim-array)
            (return #f)
            )
           ((*ctyslumb-water-texture-anim-array*)
-           (print-anim "*ctyslumb-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc ctyslumb-water) anim-array)
            (return #f)
            )
           ((*nstb-quicksand-anim-array*)
-           (print-anim "*nstb-quicksand-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc nstb-quicksand) anim-array)
            (return #f)
            )
           ((*ctyslumc-water-texture-anim-array*)
-           (print-anim "*ctyslumc-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc ctyslumc-water) anim-array)
            (return #f)
            )
           ((*factoryc-alpha-texture-anim-array*)
-           (print-anim "*factoryc-alpha-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc factoryc-alpha) anim-array)
            (return #f)
            )
           ((*hfrag-texture-anim-array*)
-           (print-anim "*hfrag-texture-anim-array*~%")
+           ; (pc-update-fixed-anim bucket (texture-anim-pc hfrag) anim-array)
            (return #f)
            )
           ((*hanga-sprite-texture-anim-array*)
-           (print-anim "*hanga-sprite-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc hanga-sprite) anim-array)
            (return #f)
            )
           ((*hanga-water-texture-anim-array*)
-           (print-anim "*hanga-water-texture-anim-array*~%")
+           ;; missing destination texture
+           ; (pc-update-fixed-anim bucket (texture-anim-pc hanga-water) anim-array)
            (return #f)
            )
           ((*desertd-water-texture-anim-array*)
-           (print-anim "*desertd-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc desertd-water) anim-array)
            (return #f)
            )
           ((*lmhcityb-tfrag-texture-anim-array*)
-           (print-anim "*lmhcityb-tfrag-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc lmhcityb-tfrag) anim-array)
            (return #f)
            )
           ((*towerb-water-texture-anim-array*)
-           (print-anim "*towerb-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc towerb-water) anim-array)
            (return #f)
            )
           ((*comb-field-texture-anim-array*)
-           (print-anim "*comb-field-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc comb-field) anim-array)
            (return #f)
            )
           ((*wasstada-alpha-texture-anim-array*)
-           (print-anim "*wasstada-alpha-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc wasstada-alpha) anim-array)
            (return #f)
            )
           ((*factoryb-water-texture-anim-array*)
-           (print-anim "*factoryb-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc factoryb-water) anim-array)
            (return #f)
            )
           ((*lmhcitya-tfrag-texture-anim-array*)
-           (print-anim "*lmhcitya-tfrag-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc lmhcitya-tfrag) anim-array)
            (return #f)
            )
           ((*mhcitya-pris-texture-anim-array*)
-           (print-anim "*mhcitya-pris-texture-anim-array*~%")
+           ;; missing destination texture
+           ; (pc-update-fixed-anim bucket (texture-anim-pc mhcitya-pris) anim-array)
            (return #f)
            )
           ((*rubblea-water-texture-anim-array*)
-           (print-anim "*rubblea-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc rubblea-water) anim-array)
            (return #f)
            )
           ((*rubblea2-water-texture-anim-array*)
-           (print-anim "*rubblea2-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc rubblea2-water) anim-array)
            (return #f)
            )
           ((*rubbleb-water-texture-anim-array*)
-           (print-anim "*rubbleb-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc rubbleb-water) anim-array)
            (return #f)
            )
           ((*rubblec-water-texture-anim-array*)
-           (print-anim "*rubblec-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc rubblec-water) anim-array)
            (return #f)
            )
           ((*foresta-water-texture-anim-array*)
-           (print-anim "*foresta-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc foresta-water) anim-array)
            (return #f)
            )
           ((*forestb-water-texture-anim-array*)
-           (print-anim "*forestb-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc forestb-water) anim-array)
            (return #f)
            )
           ((*lforplnt-pris-texture-anim-array*)
-           (print-anim "*lforplnt-pris-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc lforplnt-pris) anim-array)
            (return #f)
            )
           ((*ltnfxhip-texture-anim-array*)
-           (print-anim "*ltnfxhip-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc ltnfxhip) anim-array)
            (return #f)
            )
           ((*lgunnorm-water-texture-anim-array*)
-           (print-anim "*lgunnorm-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc lgunnorm-water) anim-array)
            (return #f)
            )
           ((*ljkdxvin-texture-anim-array*)
-           (print-anim "*ljkdxvin-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc ljkdxvin) anim-array)
            (return #f)
            )
           ((*security-texture-anim-array*)
-           (print-anim "*security-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc security) anim-array)
            (return #f)
            )
           ((*waspal-water-texture-anim-array*)
-           (print-anim "*waspal-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc waspal-water) anim-array)
            (return #f)
            )
           ((*mined-tfrag-texture-anim-array*)
-           (print-anim "*mined-tfrag-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc mined-tfrag) anim-array)
            (return #f)
            )
           ((*volcanox-warp-texture-anim-array*)
-           (print-anim "*volcanox-warp-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc volcanox-warp) anim-array)
            (return #f)
            )
           ((*templex-water-texture-anim-array*)
-           (print-anim "*templex-water-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc templex-water) anim-array)
            (return #f)
            )
           ((*volcanoa-alpha-texture-anim-array*)
-           (print-anim "*volcanoa-alpha-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc volcanoa-water) anim-array)
            (return #f)
            )
           ((*deshover-texture-anim-array*)
-           (print-anim "*deshover-texture-anim-array*~%")
+           (pc-update-fixed-anim bucket (texture-anim-pc deshover) anim-array)
            (return #f)
            )
           (else
@@ -812,35 +846,272 @@
   (none)
   )
 
-(defun no-alpha-texture-anim-layer-func ((arg0 dma-buffer) (arg1 uint) (arg2 int) (arg3 int) (arg4 texture-anim-layer) (arg5 float))
-  (format 0 "unsupported no-alpha-texture-anim-layer-func~%")
-  (break!)
+(defun no-alpha-texture-anim-layer-func ((dma-buf dma-buffer) (fbp-to-draw uint) (width int) (height int) (layer texture-anim-layer) (time float))
+  "Like others, but the tcc value is 0"
+  (when (and (>= time (-> layer start-time)) (>= (-> layer end-time) time))
+    (texture-anim-layer-interp layer time)
+    (when (!= (-> layer interpolated-color w) 0.0)
+      (texture-anim-layer-add-shader dma-buf layer 0)
+      (texture-anim-layer-draw dma-buf width height layer)
+      )
+    )
   0
   )
 
+(defun copy-alpha-texture-anim-layer-func ((dma-buf dma-buffer) (fbp-to-draw uint) (width int) (height int) (layer texture-anim-layer) (time float))
+  "Copy only alpha from the layer source texture. Does a draw, possibly blending if that's how the layer is configured.
+   Draw is always axis aligned, full size."
+  (when (and (>= time (-> layer start-time)) (>= (-> layer end-time) time))
 
-(defun copy-alpha-texture-anim-layer-func ((arg0 dma-buffer) (arg1 uint) (arg2 int) (arg3 int) (arg4 texture-anim-layer) (arg5 float))
-  (format 0 "unsupported copy-alpha-texture-anim-layer-func~%")
-  (break!)
+    ;; compute layer values for this frame
+    (texture-anim-layer-interp layer time)
+
+    (let ((s4-0 (/ (+ width 63) 64)))
+      ;; set up fbmask for alpha only
+      (dma-buffer-add-gs-set dma-buf (frame-1 (new 'static 'gs-frame :fbmsk #xffffff :fbw s4-0 :fbp fbp-to-draw)))
+      ;; set up shader to sample from the layer's texture
+      (texture-anim-layer-add-shader dma-buf layer 1)
+
+      (let ((v1-7 (-> dma-buf base))
+            (a2-6 #x8000)
+            (a3-1 #x8000)
+            (a0-10 (* (+ width 2048) 16))
+            (a1-14 (* (+ height 2048) 16))
+            )
+        ;; generate drawing.
+        (set! (-> (the-as (pointer uint128) v1-7)) (-> *texture-anim-work* draw-tmpl dma-vif quad))
+        (set! (-> (the-as (pointer uint128) v1-7) 1) (-> *texture-anim-work* draw-tmpl quad 1))
+        (set-vector! (the-as vector4w (&+ v1-7 32)) 128 128 128 (the int (* 128.0 (-> layer interpolated-color w))))
+        (set-vector! (the-as vector (&+ v1-7 48)) 0.0 0.0 1.0 0.0)
+        (set-vector! (the-as vector4w (&+ v1-7 64)) a2-6 a3-1 #xffffff 0)
+        (set-vector! (the-as vector (&+ v1-7 80)) 1.0 0.0 1.0 0.0)
+        (set-vector! (the-as vector4w (&+ v1-7 96)) a0-10 a3-1 #xffffff 0)
+        (set-vector! (the-as vector (&+ v1-7 112)) 0.0 1.0 1.0 0.0)
+        (set-vector! (the-as vector4w (&+ v1-7 128)) a2-6 a1-14 #xffffff 0)
+        (set-vector! (the-as vector (&+ v1-7 144)) 1.0 1.0 1.0 0.0)
+        (set-vector! (the-as vector4w (&+ v1-7 160)) a0-10 a1-14 #xffffff 0)
+        )
+      (&+! (-> dma-buf base) 176)
+
+      ;; reset frame.
+      (dma-buffer-add-gs-set dma-buf
+                             (frame-1 (new 'static 'gs-frame :fbw s4-0 :fbp fbp-to-draw))
+                             )
+      ; (let* ((v1-11 dma-buf)
+      ;        (a0-12 (the-as dma-packet (-> v1-11 base)))
+      ;        )
+      ;   (set! (-> a0-12 dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+      ;   (set! (-> a0-12 vif0) (new 'static 'vif-tag))
+      ;   (set! (-> a0-12 vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+      ;   (set! (-> v1-11 base) (the-as pointer (&+ a0-12 16)))
+      ;   )
+      ; (let* ((v1-12 dma-buf)
+      ;        (a0-14 (the-as object (-> v1-12 base)))
+      ;        )
+      ;   (set! (-> (the-as gs-gif-tag a0-14) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+      ;   (set! (-> (the-as gs-gif-tag a0-14) regs) GIF_REGS_ALL_AD)
+      ;   (set! (-> v1-12 base) (&+ (the-as pointer a0-14) 16))
+      ;   )
+      ; (let ((v1-13 (-> dma-buf base)))
+      ;   (set! (-> (the-as (pointer gs-frame) v1-13) 0) (new 'static 'gs-frame :fbw s4-0 :fbp fbp-to-draw))
+      ;   (set! (-> (the-as (pointer gs-reg64) v1-13) 1) (gs-reg64 frame-1))
+      ;   (set! (-> dma-buf base) (&+ v1-13 16))
+      ;   )
+      )
+    )
   0
   )
 
-(defun copy-clut-alpha-texture-anim-layer-func ((arg0 dma-buffer) (arg1 uint) (arg2 int) (arg3 int) (arg4 texture-anim-layer) (arg5 float))
-  (format 0 "unsupported copy-clut-alpha-texture-anim-layer-func~%")
-  (break!)
+(defun copy-clut-alpha-texture-anim-layer-func ((dma-buf dma-buffer) (fbp-to-draw uint) (width int) (height int) (layer texture-anim-layer) (time float))
+  "Copy only alpha from the layer source clut."
+
+  (pc-texture-anim-flag copy-clut-alpha dma-buf :qwc 1)
+  (let ((transform (the texture-anim-pc-texture-transform (-> dma-buf base))))
+    (set! (-> transform src-tbp) (-> layer tex dest 0))
+    (set! (-> transform dest-tbp) (* 32 fbp-to-draw))
+    (set! (-> transform pad0) 0)
+    (set! (-> transform pad1) 0)
+    )
+  (&+! (-> dma-buf base) 16)
+  (return 0)
+
+  (when (and (>= time (-> layer start-time)) (>= (-> layer end-time) time))
+    (texture-anim-layer-interp layer time)
+    (let ((s4-0 1))
+      (dma-buffer-add-gs-set dma-buf (frame-1 (new 'static 'gs-frame :fbmsk #xffffff :fbw s4-0 :fbp fbp-to-draw)))
+      (texture-anim-layer-add-clut-shader dma-buf layer 1)
+      (let ((a1-13 (-> dma-buf base))
+            (a2-6 #x8000)
+            (a3-1 #x8000)
+            (v1-6 #x8100)
+            (a0-9 #x8100)
+            )
+        (set! (-> (the-as (pointer uint128) a1-13)) (-> *texture-anim-work* draw-tmpl dma-vif quad))
+        (set! (-> (the-as (pointer uint128) a1-13) 1) (-> *texture-anim-work* draw-tmpl quad 1))
+        (set-vector! (the-as vector4w (&+ a1-13 32)) 128 128 128 (the int (* 128.0 (-> layer interpolated-color w))))
+        (set-vector! (the-as vector (&+ a1-13 48)) 0.0 0.0 1.0 0.0)
+        (set-vector! (the-as vector4w (&+ a1-13 64)) a2-6 a3-1 #xffffff 0)
+        (set-vector! (the-as vector (&+ a1-13 80)) 1.0 0.0 1.0 0.0)
+        (set-vector! (the-as vector4w (&+ a1-13 96)) v1-6 a3-1 #xffffff 0)
+        (set-vector! (the-as vector (&+ a1-13 112)) 0.0 1.0 1.0 0.0)
+        (set-vector! (the-as vector4w (&+ a1-13 128)) a2-6 a0-9 #xffffff 0)
+        (set-vector! (the-as vector (&+ a1-13 144)) 1.0 1.0 1.0 0.0)
+        (set-vector! (the-as vector4w (&+ a1-13 160)) v1-6 a0-9 #xffffff 0)
+        )
+      (&+! (-> dma-buf base) 176)
+      (dma-buffer-add-gs-set dma-buf
+                             (frame-1 (new 'static 'gs-frame :fbw s4-0 :fbp fbp-to-draw))
+                             )
+      ; (let* ((v1-10 dma-buf)
+      ;        (a0-10 (the-as dma-packet (-> v1-10 base)))
+      ;        )
+      ;   (set! (-> a0-10 dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+      ;   (set! (-> a0-10 vif0) (new 'static 'vif-tag))
+      ;   (set! (-> a0-10 vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+      ;   (set! (-> v1-10 base) (the-as pointer (the-as dma-packet (&+ a0-10 16))))
+      ;   )
+      ; (let* ((v1-11 dma-buf)
+      ;        (a0-12 (the-as object (-> v1-11 base)))
+      ;        )
+      ;   (set! (-> (the-as gs-gif-tag a0-12) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+      ;   (set! (-> (the-as gs-gif-tag a0-12) regs) GIF_REGS_ALL_AD)
+      ;   (set! (-> v1-11 base) (&+ (the-as pointer a0-12) 16))
+      ;   )
+      ; (let ((v1-12 (-> dma-buf base)))
+      ;   (set! (-> (the-as (pointer gs-frame) v1-12) 0) (new 'static 'gs-frame :fbw s4-0 :fbp fbp-to-draw))
+      ;   (set! (-> (the-as (pointer gs-reg64) v1-12) 1) (gs-reg64 frame-1))
+      ;   (set! (-> dma-buf base) (&+ v1-12 16))
+      ;   )
+      )
+    )
   0
   )
 
-(defun set-alpha-texture-anim-layer-func ((arg0 dma-buffer) (arg1 uint) (arg2 int) (arg3 int) (arg4 texture-anim-layer) (arg5 float))
-  (format 0 "unsupported set-alpha-texture-anim-layer-func~%")
-  (break!)
-  0
+(defun set-alpha-texture-anim-layer-func ((dma-buf dma-buffer) (fbp-to-draw uint) (width int) (height int) (layer texture-anim-layer) (time float))
+  "Set alpha to 128 for the texture."
+
+  ;; PC version
+  (pc-texture-anim-flag set-alpha dma-buf :qwc 1)
+  (let ((transform (the texture-anim-pc-texture-transform (-> dma-buf base))))
+    (set! (-> transform src-tbp) (* 32 fbp-to-draw))
+    (set! (-> transform dest-tbp) (* 32 fbp-to-draw))
+    (set! (-> transform pad0) 0)
+    (set! (-> transform pad1) 0)
+    )
+  (&+! (-> dma-buf base) 16)
+  (return 0)
+
+  (let ((v1-1 (/ (+ width 63) 64)))
+    ;; make sure alpha test is off, and set frame to allow only alpha writes
+    (dma-buffer-add-gs-set dma-buf
+                           (test-1 (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always)))
+                           (frame-1 (new 'static 'gs-frame :fbmsk #xffffff :fbw v1-1 :fbp fbp-to-draw))
+                           )
+    ;; draw the sprite.
+    (let ((t0-4 (-> dma-buf base))
+          (t2-12 2048)
+          (t1-7 2048)
+          (a2-1 (+ width 2048))
+          (a3-1 (+ height 2048))
+          )
+      (set! (-> (the-as (pointer uint128) t0-4)) (-> *texture-anim-work* erase-tmpl dma-vif quad))
+      (set! (-> (the-as (pointer uint128) t0-4) 1) (-> *texture-anim-work* erase-tmpl quad 1))
+      (set-vector! (the-as vector4w (&+ t0-4 32)) 0 0 0 128) ;; rgba
+      (set-vector! (the-as vector4w (&+ t0-4 48)) (* t2-12 16) (* t1-7 16) #xffffff 0)
+      (set-vector! (the-as vector4w (&+ t0-4 64)) (* a2-1 16) (* a3-1 16) #xffffff 0)
+      )
+    (&+! (-> dma-buf base) 80)
+    (dma-buffer-add-gs-set dma-buf
+                           (frame-1 (new 'static 'gs-frame :fbw v1-1 :fbp fbp-to-draw))
+                           )
+    0
+    ; (let* ((a2-7 dma-buf)
+    ;        (a3-2 (the-as object (-> a2-7 base)))
+    ;        )
+    ;   (set! (-> (the-as dma-packet a3-2) dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+    ;   (set! (-> (the-as dma-packet a3-2) vif0) (new 'static 'vif-tag))
+    ;   (set! (-> (the-as dma-packet a3-2) vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+    ;   (set! (-> a2-7 base) (&+ (the-as pointer a3-2) 16))
+    ;   )
+    ; (let* ((a2-8 dma-buf)
+    ;        (a3-4 (the-as object (-> a2-8 base)))
+    ;        )
+    ;   (set! (-> (the-as gs-gif-tag a3-4) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+    ;   (set! (-> (the-as gs-gif-tag a3-4) regs) GIF_REGS_ALL_AD)
+    ;   (set! (-> a2-8 base) (&+ (the-as pointer a3-4) 16))
+    ;   )
+    ; (let ((a2-9 (-> dma-buf base)))
+    ;   (set! (-> (the-as (pointer gs-frame) a2-9) 0) (new 'static 'gs-frame :fbw v1-1 :fbp fbp-to-draw))
+    ;   (set! (-> (the-as (pointer gs-reg64) a2-9) 1) (gs-reg64 frame-1))
+    ;   (let ((v0-0 (&+ a2-9 16)))
+    ;     (set! (-> dma-buf base) v0-0)
+    ;     (the-as int v0-0)
+    ;     )
+    ;   )
+    )
   )
 
-(defun set-clut-alpha-texture-anim-layer-func ((arg0 dma-buffer) (arg1 uint) (arg2 int) (arg3 int) (arg4 texture-anim-layer) (arg5 float))
-  (format 0 "unsupported set-clut-alpha-texture-anim-layer-func~%")
-  (break!)
-  0
+(defun set-clut-alpha-texture-anim-layer-func ((dma-buf dma-buffer) (fbp-to-draw uint) (width int) (height int) (layer texture-anim-layer) (time float))
+  "Set clut alpha to 128."
+
+  ;; PC version
+  (pc-texture-anim-flag set-clut-alpha dma-buf :qwc 1)
+    (let ((transform (the texture-anim-pc-texture-transform (-> dma-buf base))))
+    (set! (-> transform src-tbp) (* 32 fbp-to-draw))
+    (set! (-> transform dest-tbp) (* 32 fbp-to-draw))
+    (set! (-> transform pad0) 0)
+    (set! (-> transform pad1) 0)
+    )
+  (&+! (-> dma-buf base) 16)
+  (return 0)
+
+
+  (let ((v1-0 1))
+    (dma-buffer-add-gs-set dma-buf
+                           (test-1 (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always)))
+                           (frame-1 (new 'static 'gs-frame :fbmsk #xffffff :fbw v1-0 :fbp fbp-to-draw))
+                           )
+    (let ((t0-13 (-> dma-buf base))
+          (t2-0 2048)
+          (t1-5 2048)
+          (a3-7 2064)
+          (a2-4 2064)
+          )
+      (set! (-> (the-as (pointer uint128) t0-13)) (-> *texture-anim-work* erase-tmpl dma-vif quad))
+      (set! (-> (the-as (pointer uint128) t0-13) 1) (-> *texture-anim-work* erase-tmpl quad 1))
+      (set-vector! (the-as vector4w (&+ t0-13 32)) 0 0 0 128)
+      (set-vector! (the-as vector4w (&+ t0-13 48)) (* t2-0 16) (* t1-5 16) #xffffff 0)
+      (set-vector! (the-as vector4w (&+ t0-13 64)) (* a3-7 16) (* a2-4 16) #xffffff 0)
+      )
+    (&+! (-> dma-buf base) 80)
+    (dma-buffer-add-gs-set dma-buf
+                           (frame-1 (new 'static 'gs-frame :fbw v1-0 :fbp fbp-to-draw))
+                           )
+    0
+    ; (let* ((a2-9 dma-buf)
+    ;        (a3-9 (the-as object (-> a2-9 base)))
+    ;        )
+    ;   (set! (-> (the-as dma-packet a3-9) dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)))
+    ;   (set! (-> (the-as dma-packet a3-9) vif0) (new 'static 'vif-tag))
+    ;   (set! (-> (the-as dma-packet a3-9) vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1))
+    ;   (set! (-> a2-9 base) (&+ (the-as pointer a3-9) 16))
+    ;   )
+    ; (let* ((a2-10 dma-buf)
+    ;        (a3-11 (the-as object (-> a2-10 base)))
+    ;        )
+    ;   (set! (-> (the-as gs-gif-tag a3-11) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1))
+    ;   (set! (-> (the-as gs-gif-tag a3-11) regs) GIF_REGS_ALL_AD)
+    ;   (set! (-> a2-10 base) (&+ (the-as pointer a3-11) 16))
+    ;   )
+    ; (let ((a2-11 (-> dma-buf base)))
+    ;   (set! (-> (the-as (pointer gs-frame) a2-11) 0) (new 'static 'gs-frame :fbw v1-0 :fbp fbp-to-draw))
+    ;   (set! (-> (the-as (pointer gs-reg64) a2-11) 1) (gs-reg64 frame-1))
+    ;   (let ((v0-0 (&+ a2-11 16)))
+    ;     (set! (-> dma-buf base) v0-0)
+    ;     (the-as int v0-0)
+    ;     )
+    ;   )
+    )
   )
 
 (defun dest-texture-init ((arg0 texture-anim))
diff --git a/goal_src/jak3/engine/gfx/texture/texture-finish.gc b/goal_src/jak3/engine/gfx/texture/texture-finish.gc
index bd7c3c2fa9..474a6d12f8 100644
--- a/goal_src/jak3/engine/gfx/texture/texture-finish.gc
+++ b/goal_src/jak3/engine/gfx/texture/texture-finish.gc
@@ -17,7 +17,6 @@
     )
   )
 
-(format #t "skipping init in texture-finish.~%")
 (init! *sky-texture-anim-array*)
 (init! *darkjak-texture-anim-array*)
 (init! *skull-gem-texture-anim-array*)
diff --git a/goal_src/jak3/game.gp b/goal_src/jak3/game.gp
index 1de720b117..7ab31948d1 100644
--- a/goal_src/jak3/game.gp
+++ b/goal_src/jak3/game.gp
@@ -272,7 +272,7 @@
 (cgo-file "preca.gd" common-dep)
 (cgo-file "precb.gd" common-dep)
 (cgo-file "precc.gd" common-dep)
-(cgo-file "precd.gd" common-dep)
+; (cgo-file "precd.gd" common-dep)
 ; ;; title/intro
 (cgo-file "win.gd" common-dep) ;; wasintro
 (cgo-file "title.gd" common-dep)
diff --git a/goal_src/jak3/levels/city/ctywide-texture.gc b/goal_src/jak3/levels/city/ctywide-texture.gc
index 4b056d4f22..726859448b 100644
--- a/goal_src/jak3/levels/city/ctywide-texture.gc
+++ b/goal_src/jak3/levels/city/ctywide-texture.gc
@@ -7,196 +7,192 @@
 
 ;; DECOMP BEGINS
 
-;; og:preserve-this not-yet-implemented texture anim stuff
-; (define *security-texture-anim-array*
-;   (the-as (texture-anim-array texture-anim)
-;     (new 'static 'texture-anim-array :type texture-anim
-;       (new 'static 'texture-anim
-;         :num-layers #x2
-;         :func #f
-;         :init-func #f
-;         :tex #f
-;         :tex-name "security-env-dest"
-;         :color (new 'static 'rgba :a #x80)
-;         :frame-delta 300.0
-;         :frame-mod 4800.0
-;         :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;         :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;         :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;         :data (new 'static 'array texture-anim-layer 2
-;           (new 'static 'texture-anim-layer
-;             :func-id 'default-texture-anim-layer-func
-;             :init-func #f
-;             :tex #f
-;             :end-time 4800.0
-;             :tex-name "security-env-uscroll"
-;             :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
-;             :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;             :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
-;             :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 4.0 0.5))
-;             :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             )
-;           (new 'static 'texture-anim-layer
-;             :func-id 'default-texture-anim-layer-func
-;             :init-func #f
-;             :tex #f
-;             :end-time 4800.0
-;             :tex-name "security-env-uscroll"
-;             :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
-;             :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;             :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0 3.0))
-;             :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             )
-;           )
-;         )
-;       (new 'static 'texture-anim
-;         :num-layers #x3
-;         :func #f
-;         :init-func #f
-;         :tex #f
-;         :tex-name "security-dot-dest"
-;         :color (new 'static 'rgba :a #x80)
-;         :frame-delta 300.0
-;         :frame-mod 600.0
-;         :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;         :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;         :data (new 'static 'array texture-anim-layer 6
-;           (new 'static 'texture-anim-layer
-;             :func-id 'default-texture-anim-layer-func
-;             :init-func #f
-;             :tex #f
-;             :end-time 4800.0
-;             :tex-name "common-white"
-;             :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;             :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;             :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
-;             :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
-;             :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             )
-;           (new 'static 'texture-anim-layer
-;             :func-id 'default-texture-anim-layer-func
-;             :init-func #f
-;             :tex #f
-;             :end-time 600.0
-;             :tex-name "security-dot-src"
-;             :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;             :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;             :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0078125 0.015625))
-;             :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0078125 0.015625))
-;             :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             )
-;           (new 'static 'texture-anim-layer
-;             :func-id 'default-texture-anim-layer-func
-;             :init-func #f
-;             :tex #f
-;             :end-time 600.0
-;             :tex-name "security-dot-src"
-;             :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;             :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;             :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0078125 0.140625))
-;             :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0078125 0.140625))
-;             :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             )
-;           )
-;         )
-;       )
-;     )
-;   )
+(define *security-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func #f
+        :tex #f
+        :tex-name "security-env-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 4800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4800.0
+            :tex-name "security-env-uscroll"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 4.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4800.0
+            :tex-name "security-env-uscroll"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func #f
+        :tex #f
+        :tex-name "security-dot-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4800.0
+            :tex-name "common-white"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "security-dot-src"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0078125 0.015625))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0078125 0.015625))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "security-dot-src"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0078125 0.140625))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0078125 0.140625))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
 
 (defun set-security-color! ((arg0 vector))
-  ; (let ((v1-1 (-> *security-texture-anim-array* array-data 0)))
-  ;   (set! (-> v1-1 data 0 start-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-1 data 0 end-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-1 data 1 start-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-1 data 1 end-color quad) (-> arg0 quad))
-  ;   )
-  ; (let ((v1-5 (-> *security-texture-anim-array* array-data 1)))
-  ;   (set! (-> v1-5 data 1 start-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-5 data 1 end-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-5 data 2 start-color quad) (-> arg0 quad))
-  ;   (let ((v0-0 (-> v1-5 data 2 end-color)))
-  ;     (set! (-> v0-0 quad) (-> arg0 quad))
-  ;     v0-0
-  ;     )
-  ;   )
-  (the vector #f)
+  (let ((v1-1 (-> *security-texture-anim-array* array-data 0)))
+    (set! (-> v1-1 data 0 start-color quad) (-> arg0 quad))
+    (set! (-> v1-1 data 0 end-color quad) (-> arg0 quad))
+    (set! (-> v1-1 data 1 start-color quad) (-> arg0 quad))
+    (set! (-> v1-1 data 1 end-color quad) (-> arg0 quad))
+    )
+  (let ((v1-5 (-> *security-texture-anim-array* array-data 1)))
+    (set! (-> v1-5 data 1 start-color quad) (-> arg0 quad))
+    (set! (-> v1-5 data 1 end-color quad) (-> arg0 quad))
+    (set! (-> v1-5 data 2 start-color quad) (-> arg0 quad))
+    (let ((v0-0 (-> v1-5 data 2 end-color)))
+      (set! (-> v0-0 quad) (-> arg0 quad))
+      v0-0
+      )
+    )
   )
 
 (defun set-security-flash! ((arg0 vector))
-  ; (let ((v1-1 (-> *security-texture-anim-array* array-data 1)))
-  ;   (set! (-> v1-1 data 0 start-color quad) (-> arg0 quad))
-  ;   (let ((v0-0 (-> v1-1 data 0 end-color)))
-  ;     (set! (-> v0-0 quad) (-> arg0 quad))
-  ;     v0-0
-  ;     )
-  ;   )
-  (the vector #f)
+  (let ((v1-1 (-> *security-texture-anim-array* array-data 1)))
+    (set! (-> v1-1 data 0 start-color quad) (-> arg0 quad))
+    (let ((v0-0 (-> v1-1 data 0 end-color)))
+      (set! (-> v0-0 quad) (-> arg0 quad))
+      v0-0
+      )
+    )
   )
 
 (defun set-security-texture-masks! ((arg0 vector))
-  ; (local-vars (a3-3 uint128) (a3-4 uint128))
-  ; (let ((v1-3 (-> *security-texture-anim-array* array-data 0 data 0 tex))
-  ;       (a1-3 (-> *security-texture-anim-array* array-data 1 data 1 tex))
-  ;       )
-  ;   (when (and v1-3 a1-3)
-  ;     (dotimes (a2-1 3)
-  ;       (let ((a3-2 (-> (the-as (pointer uint128) (+ (the-as uint arg0) (* a2-1 16)))))
-  ;             (t0-2 (-> v1-3 masks data a2-1 mask quad))
-  ;             )
-  ;         (.por a3-3 a3-2 t0-2)
-  ;         )
-  ;       (let ((t0-5 (-> a1-3 masks data a2-1 mask quad)))
-  ;         (.por a3-4 a3-3 t0-5)
-  ;         )
-  ;       (set! (-> (the-as (pointer uint128) (+ (the-as uint arg0) (* a2-1 16)))) a3-4)
-  ;       )
-  ;     #f
-  ;     )
-  ;   )
-  #f
+  (local-vars (a3-3 uint128) (a3-4 uint128))
+  (let ((v1-3 (-> *security-texture-anim-array* array-data 0 data 0 tex))
+        (a1-3 (-> *security-texture-anim-array* array-data 1 data 1 tex))
+        )
+    (when (and v1-3 a1-3)
+      (dotimes (a2-1 3)
+        (let ((a3-2 (-> (the-as (pointer uint128) (+ (the-as uint arg0) (* a2-1 16)))))
+              (t0-2 (-> v1-3 masks data a2-1 mask quad))
+              )
+          (.por a3-3 a3-2 t0-2)
+          )
+        (let ((t0-5 (-> a1-3 masks data a2-1 mask quad)))
+          (.por a3-4 a3-3 t0-5)
+          )
+        (set! (-> (the-as (pointer uint128) (+ (the-as uint arg0) (* a2-1 16)))) a3-4)
+        )
+      #f
+      )
+    )
   )
diff --git a/goal_src/jak3/levels/city/slums/ctyslumb-part.gc b/goal_src/jak3/levels/city/slums/ctyslumb-part.gc
index a0579b5e54..7ff1ed910f 100644
--- a/goal_src/jak3/levels/city/slums/ctyslumb-part.gc
+++ b/goal_src/jak3/levels/city/slums/ctyslumb-part.gc
@@ -1227,170 +1227,169 @@
     )
   )
 
-;; og:preserve-this not-yet-implemented texture anim
-; (define *ctyslumb-water-texture-anim-array*
-;   (new 'static 'texture-anim-array :type texture-anim
-;     (new 'static 'texture-anim
-;       :num-layers #x3
-;       :func #f
-;       :init-func-id 'texture-anim-overide-size-init
-;       :tex #f
-;       :tex-name "ctyslumb-water-dest"
-;       :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
-;       :color (new 'static 'rgba :a #x80)
-;       :frame-delta 300.0
-;       :frame-mod 2100.0
-;       :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;       :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;       :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;       :data (new 'static 'array texture-anim-layer 6
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 2100.0
-;           :tex-name "ctyslumb-water"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-st-rot (degrees 180)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-st-rot (degrees 180)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 2100.0
-;           :tex-name "ctyslumb-water"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-st-rot (degrees 90)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-st-rot (degrees 90)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 2100.0
-;           :tex-name "ctyslumb-water"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         )
-;       )
-;     (new 'static 'texture-anim
-;       :num-layers #x3
-;       :func #f
-;       :init-func-id 'texture-anim-overide-size-init
-;       :tex #f
-;       :tex-name "ctyslumb-fountain-fall-dest"
-;       :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
-;       :color (new 'static 'rgba :a #x80)
-;       :frame-delta 300.0
-;       :frame-mod 600.0
-;       :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;       :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;       :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;       :data (new 'static 'array texture-anim-layer 6
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 600.0
-;           :tex-name "ctyslumb-fountain-fall"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 600.0
-;           :tex-name "ctyslumb-fountain-fall"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 600.0
-;           :tex-name "ctyslumb-fountain-fall"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         )
-;       )
-;     )
-;   )
+(define *ctyslumb-water-texture-anim-array*
+  (new 'static 'texture-anim-array :type texture-anim
+    (new 'static 'texture-anim
+      :num-layers #x3
+      :func #f
+      :init-func-id 'texture-anim-overide-size-init
+      :tex #f
+      :tex-name "ctyslumb-water-dest"
+      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+      :color (new 'static 'rgba :a #x80)
+      :frame-delta 300.0
+      :frame-mod 2100.0
+      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+      :data (new 'static 'array texture-anim-layer 6
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 2100.0
+          :tex-name "ctyslumb-water"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-st-rot (degrees 180)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-st-rot (degrees 180)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 2100.0
+          :tex-name "ctyslumb-water"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-st-rot (degrees 90)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-st-rot (degrees 90)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 2100.0
+          :tex-name "ctyslumb-water"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        )
+      )
+    (new 'static 'texture-anim
+      :num-layers #x3
+      :func #f
+      :init-func-id 'texture-anim-overide-size-init
+      :tex #f
+      :tex-name "ctyslumb-fountain-fall-dest"
+      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+      :color (new 'static 'rgba :a #x80)
+      :frame-delta 300.0
+      :frame-mod 600.0
+      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+      :data (new 'static 'array texture-anim-layer 6
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 600.0
+          :tex-name "ctyslumb-fountain-fall"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 600.0
+          :tex-name "ctyslumb-fountain-fall"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 600.0
+          :tex-name "ctyslumb-fountain-fall"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/city/slums/ctyslumc-obs.gc b/goal_src/jak3/levels/city/slums/ctyslumc-obs.gc
index e72a2205f3..8e7c82ee49 100644
--- a/goal_src/jak3/levels/city/slums/ctyslumc-obs.gc
+++ b/goal_src/jak3/levels/city/slums/ctyslumc-obs.gc
@@ -64,173 +64,172 @@
   (none)
   )
 
-;; og:preserve-this not-yet-implemented texture anim
-; (define *ctyslumc-water-texture-anim-array*
-;   (new 'static 'texture-anim-array :type texture-anim
-;     (new 'static 'texture-anim
-;       :num-layers #x3
-;       :func #f
-;       :init-func-id 'texture-anim-overide-size-init
-;       :tex #f
-;       :tex-name "ctyslumc-water-dest"
-;       :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
-;       :color (new 'static 'rgba :a #x80)
-;       :frame-delta 300.0
-;       :frame-mod 2100.0
-;       :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;       :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;       :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;       :data (new 'static 'array texture-anim-layer 6
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 2100.0
-;           :tex-name "ctyslumc-water"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-st-rot (degrees 180)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-st-rot (degrees 180)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 2100.0
-;           :tex-name "ctyslumc-water"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-st-rot (degrees 90)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-st-rot (degrees 90)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 2100.0
-;           :tex-name "ctyslumc-water"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         )
-;       )
-;     (new 'static 'texture-anim
-;       :num-layers #x3
-;       :func #f
-;       :init-func-id 'texture-anim-overide-size-init
-;       :tex #f
-;       :tex-name "ctyslumc-fountain-fall-dest"
-;       :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
-;       :color (new 'static 'rgba :a #x80)
-;       :frame-delta 300.0
-;       :frame-mod 600.0
-;       :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;       :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;       :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;       :data (new 'static 'array texture-anim-layer 6
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 600.0
-;           :tex-name "ctyslumc-fountain-fall"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 600.0
-;           :tex-name "ctyslumc-fountain-fall"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 600.0
-;           :tex-name "ctyslumc-fountain-fall"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         )
-;       )
-;     )
-;   )
+(define *ctyslumc-water-texture-anim-array*
+  (new 'static 'texture-anim-array :type texture-anim
+    (new 'static 'texture-anim
+      :num-layers #x3
+      :func #f
+      :init-func-id 'texture-anim-overide-size-init
+      :tex #f
+      :tex-name "ctyslumc-water-dest"
+      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+      :color (new 'static 'rgba :a #x80)
+      :frame-delta 300.0
+      :frame-mod 2100.0
+      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+      :data (new 'static 'array texture-anim-layer 6
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 2100.0
+          :tex-name "ctyslumc-water"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-st-rot (degrees 180)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-st-rot (degrees 180)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 2100.0
+          :tex-name "ctyslumc-water"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-st-rot (degrees 90)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-st-rot (degrees 90)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 2100.0
+          :tex-name "ctyslumc-water"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        )
+      )
+    (new 'static 'texture-anim
+      :num-layers #x3
+      :func #f
+      :init-func-id 'texture-anim-overide-size-init
+      :tex #f
+      :tex-name "ctyslumc-fountain-fall-dest"
+      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+      :color (new 'static 'rgba :a #x80)
+      :frame-delta 300.0
+      :frame-mod 600.0
+      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+      :data (new 'static 'array texture-anim-layer 6
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 600.0
+          :tex-name "ctyslumc-fountain-fall"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 600.0
+          :tex-name "ctyslumc-fountain-fall"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 600.0
+          :tex-name "ctyslumc-fountain-fall"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        )
+      )
+    )
+  )
 
 (deftype ctyslumc-flag (process-drawable)
   ()
diff --git a/goal_src/jak3/levels/city/vinroom/ljkdxvin-texture.gc b/goal_src/jak3/levels/city/vinroom/ljkdxvin-texture.gc
index bd628f6fbf..c5de882cf1 100644
--- a/goal_src/jak3/levels/city/vinroom/ljkdxvin-texture.gc
+++ b/goal_src/jak3/levels/city/vinroom/ljkdxvin-texture.gc
@@ -7,3 +7,206 @@
 
 ;; DECOMP BEGINS
 
+(define *ljkdxvin-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'ljkdxvin-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(defun ljkdxvin-texture-anim-func ()
+  (let ((gp-0 *ljkdxvin-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
diff --git a/goal_src/jak3/levels/comb/comb-mood.gc b/goal_src/jak3/levels/comb/comb-mood.gc
index 85f754f5a4..b05d62b738 100644
--- a/goal_src/jak3/levels/comb/comb-mood.gc
+++ b/goal_src/jak3/levels/comb/comb-mood.gc
@@ -100,192 +100,190 @@
   (none)
   )
 
-;; og:preserve-this not-yet-implemented texture anim stuff
-; (define *comb-field-texture-anim-array*
-;   (the-as (texture-anim-array texture-anim)
-;     (new 'static 'texture-anim-array :type texture-anim
-;       (new 'static 'texture-anim
-;         :num-layers #x2
-;         :func #f
-;         :init-func #f
-;         :tex #f
-;         :tex-name "security-env-dest"
-;         :color (new 'static 'rgba :a #x80)
-;         :frame-delta 300.0
-;         :frame-mod 4800.0
-;         :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;         :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;         :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;         :data (new 'static 'array texture-anim-layer 2
-;           (new 'static 'texture-anim-layer
-;             :func-id 'default-texture-anim-layer-func
-;             :init-func #f
-;             :tex #f
-;             :end-time 4800.0
-;             :tex-name "security-env-uscroll"
-;             :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
-;             :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;             :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
-;             :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 4.0 0.5))
-;             :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             )
-;           (new 'static 'texture-anim-layer
-;             :func-id 'default-texture-anim-layer-func
-;             :init-func #f
-;             :tex #f
-;             :end-time 4800.0
-;             :tex-name "security-env-uscroll"
-;             :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
-;             :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;             :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0 3.0))
-;             :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             )
-;           )
-;         )
-;       (new 'static 'texture-anim
-;         :num-layers #x3
-;         :func #f
-;         :init-func #f
-;         :tex #f
-;         :tex-name "security-dot-dest"
-;         :color (new 'static 'rgba :a #x80)
-;         :frame-delta 300.0
-;         :frame-mod 600.0
-;         :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;         :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;         :data (new 'static 'array texture-anim-layer 6
-;           (new 'static 'texture-anim-layer
-;             :func-id 'default-texture-anim-layer-func
-;             :init-func #f
-;             :tex #f
-;             :end-time 4800.0
-;             :tex-name "common-white"
-;             :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;             :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;             :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
-;             :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
-;             :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             )
-;           (new 'static 'texture-anim-layer
-;             :func-id 'default-texture-anim-layer-func
-;             :init-func #f
-;             :tex #f
-;             :end-time 600.0
-;             :tex-name "security-dot-src"
-;             :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;             :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;             :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0078125 0.015625))
-;             :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0078125 0.015625))
-;             :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             )
-;           (new 'static 'texture-anim-layer
-;             :func-id 'default-texture-anim-layer-func
-;             :init-func #f
-;             :tex #f
-;             :end-time 600.0
-;             :tex-name "security-dot-src"
-;             :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;             :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;             :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0078125 0.140625))
-;             :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;             :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;             :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0078125 0.140625))
-;             :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;             )
-;           )
-;         )
-;       )
-;     )
-;   )
+(define *comb-field-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func #f
+        :tex #f
+        :tex-name "security-env-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 4800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4800.0
+            :tex-name "security-env-uscroll"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 4.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4800.0
+            :tex-name "security-env-uscroll"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func #f
+        :tex #f
+        :tex-name "security-dot-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4800.0
+            :tex-name "common-white"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "security-dot-src"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0078125 0.015625))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0078125 0.015625))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "security-dot-src"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0078125 0.140625))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0078125 0.140625))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
 
 ;; WARN: Return type mismatch vector vs none.
 (defun set-comb-field-color! ((arg0 vector))
-  ; (let ((v1-1 (-> *comb-field-texture-anim-array* array-data 0)))
-  ;   (set! (-> v1-1 data 0 start-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-1 data 0 end-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-1 data 1 start-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-1 data 1 end-color quad) (-> arg0 quad))
-  ;   )
-  ; (let ((v1-5 (-> *comb-field-texture-anim-array* array-data 1)))
-  ;   (set! (-> v1-5 data 1 start-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-5 data 1 end-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-5 data 2 start-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-5 data 2 end-color quad) (-> arg0 quad))
-  ;   )
+  (let ((v1-1 (-> *comb-field-texture-anim-array* array-data 0)))
+    (set! (-> v1-1 data 0 start-color quad) (-> arg0 quad))
+    (set! (-> v1-1 data 0 end-color quad) (-> arg0 quad))
+    (set! (-> v1-1 data 1 start-color quad) (-> arg0 quad))
+    (set! (-> v1-1 data 1 end-color quad) (-> arg0 quad))
+    )
+  (let ((v1-5 (-> *comb-field-texture-anim-array* array-data 1)))
+    (set! (-> v1-5 data 1 start-color quad) (-> arg0 quad))
+    (set! (-> v1-5 data 1 end-color quad) (-> arg0 quad))
+    (set! (-> v1-5 data 2 start-color quad) (-> arg0 quad))
+    (set! (-> v1-5 data 2 end-color quad) (-> arg0 quad))
+    )
   (none)
   )
 
 ;; WARN: Return type mismatch vector vs none.
 (defun set-comb-field-flash! ((arg0 vector))
-  ; (let ((v1-1 (-> *comb-field-texture-anim-array* array-data 1)))
-  ;   (set! (-> v1-1 data 0 start-color quad) (-> arg0 quad))
-  ;   (set! (-> v1-1 data 0 end-color quad) (-> arg0 quad))
-  ;   )
+  (let ((v1-1 (-> *comb-field-texture-anim-array* array-data 1)))
+    (set! (-> v1-1 data 0 start-color quad) (-> arg0 quad))
+    (set! (-> v1-1 data 0 end-color quad) (-> arg0 quad))
+    )
   (none)
   )
 
 (defun set-comb-field-texture-masks! ((arg0 vector))
-  ; (local-vars (a3-3 uint128) (a3-4 uint128))
-  ; (let ((v1-3 (-> *comb-field-texture-anim-array* array-data 0 data 0 tex))
-  ;       (a1-3 (-> *comb-field-texture-anim-array* array-data 1 data 1 tex))
-  ;       )
-  ;   (when (and v1-3 a1-3)
-  ;     (dotimes (a2-1 3)
-  ;       (let ((a3-2 (-> (the-as (pointer uint128) (+ (the-as uint arg0) (* a2-1 16)))))
-  ;             (t0-2 (-> v1-3 masks data a2-1 mask quad))
-  ;             )
-  ;         (.por a3-3 a3-2 t0-2)
-  ;         )
-  ;       (let ((t0-5 (-> a1-3 masks data a2-1 mask quad)))
-  ;         (.por a3-4 a3-3 t0-5)
-  ;         )
-  ;       (set! (-> (the-as (pointer uint128) (+ (the-as uint arg0) (* a2-1 16)))) a3-4)
-  ;       )
-  ;     #f
-  ;     )
-  ;   )
-  #f
+  (local-vars (a3-3 uint128) (a3-4 uint128))
+  (let ((v1-3 (-> *comb-field-texture-anim-array* array-data 0 data 0 tex))
+        (a1-3 (-> *comb-field-texture-anim-array* array-data 1 data 1 tex))
+        )
+    (when (and v1-3 a1-3)
+      (dotimes (a2-1 3)
+        (let ((a3-2 (-> (the-as (pointer uint128) (+ (the-as uint arg0) (* a2-1 16)))))
+              (t0-2 (-> v1-3 masks data a2-1 mask quad))
+              )
+          (.por a3-3 a3-2 t0-2)
+          )
+        (let ((t0-5 (-> a1-3 masks data a2-1 mask quad)))
+          (.por a3-4 a3-3 t0-5)
+          )
+        (set! (-> (the-as (pointer uint128) (+ (the-as uint arg0) (* a2-1 16)))) a3-4)
+        )
+      #f
+      )
+    )
   )
diff --git a/goal_src/jak3/levels/desert/desertd-texture.gc b/goal_src/jak3/levels/desert/desertd-texture.gc
index 1a6df2ee1d..c6c75a5487 100644
--- a/goal_src/jak3/levels/desert/desertd-texture.gc
+++ b/goal_src/jak3/levels/desert/desertd-texture.gc
@@ -7,3 +7,88 @@
 
 ;; DECOMP BEGINS
 
+(define *desertd-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "des-waterfall-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "des-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "des-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "des-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/desert/hover/deshover-texture.gc b/goal_src/jak3/levels/desert/hover/deshover-texture.gc
index fd8b77cd73..a48ea094e2 100644
--- a/goal_src/jak3/levels/desert/hover/deshover-texture.gc
+++ b/goal_src/jak3/levels/desert/hover/deshover-texture.gc
@@ -7,3 +7,206 @@
 
 ;; DECOMP BEGINS
 
+(define *deshover-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'deshover-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(defun deshover-texture-anim-func ()
+  (let ((gp-0 *deshover-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
diff --git a/goal_src/jak3/levels/desert/rescue/desresc-texture.gc b/goal_src/jak3/levels/desert/rescue/desresc-texture.gc
index ad99b7a2ae..c4323056be 100644
--- a/goal_src/jak3/levels/desert/rescue/desresc-texture.gc
+++ b/goal_src/jak3/levels/desert/rescue/desresc-texture.gc
@@ -7,3 +7,88 @@
 
 ;; DECOMP BEGINS
 
+(define *desresc-warp-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sat-shield-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "sat-shield-env-uvscroll"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "sat-shield-env-uvscroll"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "sat-shield"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/factory/factorya-texture.gc b/goal_src/jak3/levels/factory/factorya-texture.gc
index e9d3da7dbd..e27b7daaf1 100644
--- a/goal_src/jak3/levels/factory/factorya-texture.gc
+++ b/goal_src/jak3/levels/factory/factorya-texture.gc
@@ -7,3 +7,104 @@
 
 ;; DECOMP BEGINS
 
+(define *factoryb-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "hemi-gradient-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "hemi-gradient-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 4.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "hemi-gradient-flames"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 12.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x1
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "hemi-gradient-flames-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "hemi-gradient-flames"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 12.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/factory/factoryc-texture.gc b/goal_src/jak3/levels/factory/factoryc-texture.gc
index 7552a532ef..ea5a552dc5 100644
--- a/goal_src/jak3/levels/factory/factoryc-texture.gc
+++ b/goal_src/jak3/levels/factory/factoryc-texture.gc
@@ -7,3 +7,88 @@
 
 ;; DECOMP BEGINS
 
+(define *factoryc-alpha-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x1
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "facc-convey-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 555.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "facc-convey"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x1
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "facc-convey-02-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 555.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "facc-convey-02"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(defun set-facc-conveyor-speed! ((arg0 float))
+  (set! (-> *factoryc-alpha-texture-anim-array* array-data 1 frame-delta) (* 0.018066408 arg0))
+  0.0
+  )
diff --git a/goal_src/jak3/levels/forest/forest-texture.gc b/goal_src/jak3/levels/forest/forest-texture.gc
index 86df176c4e..ee6e7f2890 100644
--- a/goal_src/jak3/levels/forest/forest-texture.gc
+++ b/goal_src/jak3/levels/forest/forest-texture.gc
@@ -7,3 +7,581 @@
 
 ;; DECOMP BEGINS
 
+(define *foresta-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "fora-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "fora-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "fora-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "fora-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "fora-waterfall-01-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "fora-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "fora-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "fora-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "fora-water-wave-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "fora-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "fora-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "fora-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *forestb-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "forb-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "forb-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "forb-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "forb-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "forb-waterfall-01-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "forb-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "forb-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "forb-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "forb-water-wave-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "forb-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "forb-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "forb-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *lforplnt-pris-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mh-gem-dest"
+        :extra (new 'static 'vector :x 32.0 :y 32.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mh-gem"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mh-gem-alpha-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.6 :y 0.6 :z 0.6 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.6 :y 0.5 :z 0.6 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mh-gem-alpha-02"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.6 :y 0.6 :z 0.6 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.6 :y 0.6 :z 0.6 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/glider/glider-ring-part.gc b/goal_src/jak3/levels/glider/glider-ring-part.gc
index 51946f2fef..785f41e242 100644
--- a/goal_src/jak3/levels/glider/glider-ring-part.gc
+++ b/goal_src/jak3/levels/glider/glider-ring-part.gc
@@ -7,519 +7,518 @@
 
 ;; DECOMP BEGINS
 
-;; og:preserve-this texture anim
-; (define *hanga-sprite-texture-anim-array*
-;   (new 'static 'texture-anim-array :type texture-anim
-;     (new 'static 'texture-anim
-;       :num-layers #x11
-;       :func #f
-;       :init-func-id 'texture-anim-overide-size-init
-;       :tex #f
-;       :tex-name "glider-ring-dest2"
-;       :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
-;       :color (new 'static 'rgba :a #x80)
-;       :frame-delta 300.0
-;       :frame-mod 150.0
-;       :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;       :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;       :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;       :data (new 'static 'array texture-anim-layer 18
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 25.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.9166667 0.9166667))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :start-time 25.0
-;           :end-time 150.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.9166667 0.9166667))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :start-time 25.0
-;           :end-time 50.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 70)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.875 -0.875))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 70)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :start-time 50.0
-;           :end-time 150.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.875 -0.875))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 70)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.2)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.375 -0.375))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 70)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 25.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.2)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.375 -0.375))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 70)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.25 -0.25))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 70)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :start-time 50.0
-;           :end-time 75.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 115)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 115)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :start-time 75.0
-;           :end-time 150.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 115)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.4)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.55 0.55))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 115)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 50.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.4)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.55 0.55))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 115)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.33333334 0.33333334))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 115)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :start-time 75.0
-;           :end-time 100.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 185)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.93333334 -0.93333334))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 185)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :start-time 100.0
-;           :end-time 150.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.93333334 -0.93333334))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 185)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.6)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.8 -0.8))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 185)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 75.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.6)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.8 -0.8))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 185)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.5833333 -0.5833333))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 185)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :start-time 100.0
-;           :end-time 125.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 249.99998)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.94166666 0.94166666))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 249.99998)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :start-time 125.0
-;           :end-time 150.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.94166666 0.94166666))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 249.99998)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.8)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 249.99998)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 100.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.8)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 249.99998)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.6666667 0.6666667))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 249.99998)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :start-time 125.0
-;           :end-time 150.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 305)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.9166667 -0.9166667))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 305)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 125.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;           :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.9166667 -0.9166667))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 305)
-;           :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -0.5))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 305)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'set-alpha-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 150.0
-;           :tex-name "splash-foam"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         )
-;       )
-;     (new 'static 'texture-anim
-;       :num-layers #x3
-;       :func #f
-;       :init-func-id 'texture-anim-overide-size-init
-;       :tex #f
-;       :tex-name "glider-ring-dest"
-;       :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
-;       :color (new 'static 'rgba :a #x80)
-;       :frame-delta 300.0
-;       :frame-mod 9000.0
-;       :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;       :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;       :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-;       :data (new 'static 'array texture-anim-layer 6
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 9000.0
-;           :tex-name "glider-ring-dest2"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 9000.0
-;           :tex-name "racegate"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-rot (degrees 360)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 9000.0
-;           :tex-name "racegate"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-rot (degrees 360)
-;           :end-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         )
-;       )
-;     )
-;   )
+(define *hanga-sprite-texture-anim-array*
+  (new 'static 'texture-anim-array :type texture-anim
+    (new 'static 'texture-anim
+      :num-layers #x11
+      :func #f
+      :init-func-id 'texture-anim-overide-size-init
+      :tex #f
+      :tex-name "glider-ring-dest2"
+      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+      :color (new 'static 'rgba :a #x80)
+      :frame-delta 300.0
+      :frame-mod 150.0
+      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+      :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+      :data (new 'static 'array texture-anim-layer 18
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 25.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.9166667 0.9166667))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :start-time 25.0
+          :end-time 150.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.9166667 0.9166667))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :start-time 25.0
+          :end-time 50.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 70)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.875 -0.875))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 70)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :start-time 50.0
+          :end-time 150.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.875 -0.875))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 70)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.2)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.375 -0.375))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 70)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 25.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.2)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.375 -0.375))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 70)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.25 -0.25))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 70)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :start-time 50.0
+          :end-time 75.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 115)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 115)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :start-time 75.0
+          :end-time 150.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 115)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.4)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.55 0.55))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 115)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 50.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.4)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.55 0.55))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 115)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.33333334 0.33333334))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 115)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :start-time 75.0
+          :end-time 100.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 185)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.93333334 -0.93333334))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 185)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :start-time 100.0
+          :end-time 150.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.93333334 -0.93333334))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 185)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.6)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.8 -0.8))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 185)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 75.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.6)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.8 -0.8))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 185)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.5833333 -0.5833333))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 185)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :start-time 100.0
+          :end-time 125.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 249.99998)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.94166666 0.94166666))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 249.99998)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :start-time 125.0
+          :end-time 150.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.94166666 0.94166666))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 249.99998)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.8)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 249.99998)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 100.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.8)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 249.99998)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.6666667 0.6666667))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 249.99998)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :start-time 125.0
+          :end-time 150.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 305)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.9166667 -0.9166667))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 305)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 125.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.9166667 -0.9166667))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 305)
+          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -0.5))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 305)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'set-alpha-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 150.0
+          :tex-name "splash-foam"
+          :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        )
+      )
+    (new 'static 'texture-anim
+      :num-layers #x3
+      :func #f
+      :init-func-id 'texture-anim-overide-size-init
+      :tex #f
+      :tex-name "glider-ring-dest"
+      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+      :color (new 'static 'rgba :a #x80)
+      :frame-delta 300.0
+      :frame-mod 9000.0
+      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+      :data (new 'static 'array texture-anim-layer 6
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 9000.0
+          :tex-name "glider-ring-dest2"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 9000.0
+          :tex-name "racegate"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-rot (degrees 360)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 9000.0
+          :tex-name "racegate"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-rot (degrees 360)
+          :end-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        )
+      )
+    )
+  )
 
 (defpartgroup group-glider-ring
   :id 652
diff --git a/goal_src/jak3/levels/glider/hanga-init.gc b/goal_src/jak3/levels/glider/hanga-init.gc
index a86c9d9ae9..3fd9d51877 100644
--- a/goal_src/jak3/levels/glider/hanga-init.gc
+++ b/goal_src/jak3/levels/glider/hanga-init.gc
@@ -30,86 +30,85 @@
   (none)
   )
 
-;; og:preserve-this texture anim
-; (define *hanga-water-texture-anim-array*
-;   (new 'static 'texture-anim-array :type texture-anim
-;     (new 'static 'texture-anim
-;       :num-layers #x3
-;       :func #f
-;       :init-func-id 'texture-anim-overide-size-init
-;       :tex #f
-;       :tex-name "des-thermal-01-dest"
-;       :extra (new 'static 'vector :x 128.0 :y 64.0 :z 1.0)
-;       :color (new 'static 'rgba :a #x80)
-;       :frame-delta 300.0
-;       :frame-mod 1200.0
-;       :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;       :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;       :data (new 'static 'array texture-anim-layer 6
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 1200.0
-;           :tex-name "des-thermal-01"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 -0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 1200.0
-;           :tex-name "des-thermal-01"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -2.5 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 1200.0
-;           :tex-name "des-thermal-01"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.25 0.5))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -3.25 0.5))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         )
-;       )
-;     )
-;   )
+(define *hanga-water-texture-anim-array*
+  (new 'static 'texture-anim-array :type texture-anim
+    (new 'static 'texture-anim
+      :num-layers #x3
+      :func #f
+      :init-func-id 'texture-anim-overide-size-init
+      :tex #f
+      :tex-name "des-thermal-01-dest"
+      :extra (new 'static 'vector :x 128.0 :y 64.0 :z 1.0)
+      :color (new 'static 'rgba :a #x80)
+      :frame-delta 300.0
+      :frame-mod 1200.0
+      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+      :data (new 'static 'array texture-anim-layer 6
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 1200.0
+          :tex-name "des-thermal-01"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 -0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 1200.0
+          :tex-name "des-thermal-01"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -2.5 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 1200.0
+          :tex-name "des-thermal-01"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.25 0.5))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -3.25 0.5))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/gungame/gungame-texture.gc b/goal_src/jak3/levels/gungame/gungame-texture.gc
index 5be1004419..a28ca381f4 100644
--- a/goal_src/jak3/levels/gungame/gungame-texture.gc
+++ b/goal_src/jak3/levels/gungame/gungame-texture.gc
@@ -7,3 +7,151 @@
 
 ;; DECOMP BEGINS
 
+(define *lgunnorm-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x6
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "kg-target-c-forcefield-01-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 240.0
+        :frame-mod 150.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 75.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 75.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 75.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 75.0
+            :end-time 150.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.33)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 75.0
+            :end-time 150.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.33)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 75.0
+            :end-time 150.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.33)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/hiphog/ltnfxhip-texture.gc b/goal_src/jak3/levels/hiphog/ltnfxhip-texture.gc
index b32dfa2e53..530c626bc5 100644
--- a/goal_src/jak3/levels/hiphog/ltnfxhip-texture.gc
+++ b/goal_src/jak3/levels/hiphog/ltnfxhip-texture.gc
@@ -7,3 +7,206 @@
 
 ;; DECOMP BEGINS
 
+(define *ltnfxhip-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'ltnfxhip-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(defun ltnfxhip-texture-anim-func ()
+  (let ((gp-0 *ltnfxhip-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
diff --git a/goal_src/jak3/levels/mhcity/mhcitya-texture.gc b/goal_src/jak3/levels/mhcity/mhcitya-texture.gc
index f306bd6d16..42ecc0b8f6 100644
--- a/goal_src/jak3/levels/mhcity/mhcitya-texture.gc
+++ b/goal_src/jak3/levels/mhcity/mhcitya-texture.gc
@@ -7,3 +7,182 @@
 
 ;; DECOMP BEGINS
 
+(define *lmhcitya-tfrag-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mhcitya-base-goo-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 6000.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcitya-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcitya-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcitya-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *mhcitya-pris-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mhcity-de-door-skin-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-mod 2.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "mhcity-de-door-skin-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x80)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "mhcity-de-door-skin-02"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x80)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'copy-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "mhcity-de-door-skin-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(defun set-mhcity-de-door-skin! ((arg0 float))
+  (set! (-> *mhcitya-pris-texture-anim-array* array-data 0 frame-time) arg0)
+  arg0
+  )
diff --git a/goal_src/jak3/levels/mhcity/mhcityb-texture.gc b/goal_src/jak3/levels/mhcity/mhcityb-texture.gc
index 945aa85205..7840ba0d16 100644
--- a/goal_src/jak3/levels/mhcity/mhcityb-texture.gc
+++ b/goal_src/jak3/levels/mhcity/mhcityb-texture.gc
@@ -7,3 +7,92 @@
 
 ;; DECOMP BEGINS
 
+(define *lmhcityb-tfrag-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mhcityb-base-goo-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 6000.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcityb-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcityb-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcityb-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/mine/mined-texture.gc b/goal_src/jak3/levels/mine/mined-texture.gc
index 12bc2a6014..8733fc648d 100644
--- a/goal_src/jak3/levels/mine/mined-texture.gc
+++ b/goal_src/jak3/levels/mine/mined-texture.gc
@@ -7,7 +7,466 @@
 
 ;; DECOMP BEGINS
 
-;; stub
+(define *mined-tfrag-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mined-pillar-side-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'no-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-side-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-side-cooling"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-side-hot"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-molten"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'copy-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-side-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mined-pillar-top2side-dest"
+        :extra (new 'static 'vector :x 128.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'no-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top2side-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top2side-cooling"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top2side-hot"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-molten"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'copy-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top2side-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x8
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mined-pillar-top-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 10
+          (new 'static 'texture-anim-layer
+            :func-id 'no-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top-cooling"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top-hot"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 150.0
+            :tex-name "mined-pillar-molten-top"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 2.0 2.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 150.0
+            :end-time 300.0
+            :tex-name "mined-pillar-molten-top"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 150.0
+            :tex-name "mined-pillar-molten-top"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 150.0
+            :end-time 300.0
+            :tex-name "mined-pillar-molten-top"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 2.0 2.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'copy-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; WARN: Return type mismatch float vs none.
 (defun set-mined-pillar-texture! ((arg0 float))
+  (let ((f0-1 (- 1.0 (fmax 0.0 (fmin 1.0 (* 4.0 arg0)))))
+        (f1-3 (fmax 0.0 (fmin 1.0 (- 1.0 (* 2.0 arg0)))))
+        (f2-5 (- 1.0 (fabs (+ -1.0 (* 2.0 arg0)))))
+        (v1-9 *mined-tfrag-texture-anim-array*)
+        )
+    (set! (-> v1-9 array-data 0 data 1 start-color w) f2-5)
+    (set! (-> v1-9 array-data 0 data 1 end-color w) f2-5)
+    (set! (-> v1-9 array-data 1 data 1 start-color w) f2-5)
+    (set! (-> v1-9 array-data 1 data 1 end-color w) f2-5)
+    (set! (-> v1-9 array-data 2 data 1 start-color w) f2-5)
+    (set! (-> v1-9 array-data 2 data 1 end-color w) f2-5)
+    (set! (-> v1-9 array-data 0 data 2 start-color w) f1-3)
+    (set! (-> v1-9 array-data 0 data 2 end-color w) f1-3)
+    (set! (-> v1-9 array-data 1 data 2 start-color w) f1-3)
+    (set! (-> v1-9 array-data 1 data 2 end-color w) f1-3)
+    (set! (-> v1-9 array-data 2 data 2 start-color w) f1-3)
+    (set! (-> v1-9 array-data 2 data 2 end-color w) f1-3)
+    (set! (-> v1-9 array-data 0 data 3 start-color w) f0-1)
+    (set! (-> v1-9 array-data 0 data 3 end-color w) f0-1)
+    (set! (-> v1-9 array-data 1 data 3 start-color w) f0-1)
+    (set! (-> v1-9 array-data 1 data 3 end-color w) f0-1)
+    (set! (-> v1-9 array-data 2 data 3 end-color w) f0-1)
+    (set! (-> v1-9 array-data 2 data 4 start-color w) f0-1)
+    (set! (-> v1-9 array-data 2 data 5 start-color w) f0-1)
+    (set! (-> v1-9 array-data 2 data 6 end-color w) f0-1)
+    )
   (none)
-  )
\ No newline at end of file
+  )
+
+(set-mined-pillar-texture! 0.0)
diff --git a/goal_src/jak3/levels/nest/nstb-texture.gc b/goal_src/jak3/levels/nest/nstb-texture.gc
index fdf52e7855..c332bc6f29 100644
--- a/goal_src/jak3/levels/nest/nstb-texture.gc
+++ b/goal_src/jak3/levels/nest/nstb-texture.gc
@@ -7,3 +7,44 @@
 
 ;; DECOMP BEGINS
 
+(define *nstb-quicksand-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x1
+        :func #f
+        :init-func #f
+        :tex #f
+        :tex-name "nstb-quicksand-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "nstb-quicksand-scroll"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/sewer/sewer-texture.gc b/goal_src/jak3/levels/sewer/sewer-texture.gc
index c23ac99400..5d347a9465 100644
--- a/goal_src/jak3/levels/sewer/sewer-texture.gc
+++ b/goal_src/jak3/levels/sewer/sewer-texture.gc
@@ -7,3 +7,3193 @@
 
 ;; DECOMP BEGINS
 
+(define *sewc-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-c-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-01-c-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-c-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-c-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-highlight-01-c-dest"
+        :extra (new 'static 'vector :x 64.0 :y 32.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *sewd-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-d-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-d-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-highlight-01-d-dest"
+        :extra (new 'static 'vector :x 64.0 :y 32.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-d-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-02-d-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "sewer-water-wave-02-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "sewer-water-wave-02-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 3.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-still-01-d-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 4500.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 1.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 0.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *sewe-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-e-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-01-e-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 450.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 450.0
+            :tex-name "sewer-waterfall-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 450.0
+            :tex-name "sewer-waterfall-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 450.0
+            :tex-name "sewer-waterfall-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-e-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-highlight-01-e-dest"
+        :extra (new 'static 'vector :x 64.0 :y 32.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *sewg-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-g-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-g-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-g-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *sewh-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-h-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-h-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-02-h-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-wave-02-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-wave-02-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 3.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-watefall-froth-01-h-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 525.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *sewi-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-still-01-i-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 4500.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 1.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 0.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-i-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-i-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *sewj-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-j-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-watefall-froth-01-j-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 525.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *sewl-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-l-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-watefall-froth-01-l-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 525.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *sewm-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-m-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-01-m-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-m-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-highlight-01-m-dest"
+        :extra (new 'static 'vector :x 64.0 :y 32.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-m-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-still-01-m-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 4500.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 1.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 0.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-watefall-froth-01-m-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 525.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *sewn-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-01-n-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-n-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      ;; og:preserve-this destination texture is missing
+      ; (new 'static 'texture-anim
+      ;   :num-layers #x2
+      ;   :func #f
+      ;   :init-func-id 'texture-anim-overide-size-init
+      ;   :tex #f
+      ;   :tex-name "sewer-water-highlight-01-n-dest"
+      ;   :extra (new 'static 'vector :x 64.0 :y 32.0 :z 1.0)
+      ;   :color (new 'static 'rgba :a #x80)
+      ;   :frame-delta 300.0
+      ;   :frame-mod 600.0
+      ;   :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+      ;   :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+      ;   :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+      ;   :data (new 'static 'array texture-anim-layer 2
+      ;     (new 'static 'texture-anim-layer
+      ;       :func-id 'default-texture-anim-layer-func
+      ;       :init-func #f
+      ;       :tex #f
+      ;       :end-time 600.0
+      ;       :tex-name "sewer-water-highlight-01-n"
+      ;       :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+      ;       :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+      ;       :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+      ;       :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+      ;       :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+      ;       :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+      ;       :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+      ;       :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+      ;       :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+      ;       :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+      ;       :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+      ;       :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+      ;       :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+      ;       :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+      ;       )
+      ;     (new 'static 'texture-anim-layer
+      ;       :func-id 'default-texture-anim-layer-func
+      ;       :init-func #f
+      ;       :tex #f
+      ;       :end-time 600.0
+      ;       :tex-name "sewer-water-highlight-01-n"
+      ;       :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+      ;       :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+      ;       :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+      ;       :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+      ;       :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+      ;       :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+      ;       :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+      ;       :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+      ;       :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+      ;       :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+      ;       :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+      ;       :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+      ;       :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+      ;       :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+      ;       )
+      ;     )
+      ;   )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-n-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-still-01-n-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 4500.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/stadium/rubble-texture.gc b/goal_src/jak3/levels/stadium/rubble-texture.gc
index 7c31981330..9cd236dc6e 100644
--- a/goal_src/jak3/levels/stadium/rubble-texture.gc
+++ b/goal_src/jak3/levels/stadium/rubble-texture.gc
@@ -7,3 +7,362 @@
 
 ;; DECOMP BEGINS
 
+(define *rubblea-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "rub-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *rubblea2-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "rub-water-desta2"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-watera2"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-watera2"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-watera2"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *rubbleb-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "rub-water-destb"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterb"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterb"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterb"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *rubblec-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "rub-water-destc"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterc"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterc"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterc"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/temple/templea-texture.gc b/goal_src/jak3/levels/temple/templea-texture.gc
index cead19b3d8..2c434d7d7b 100644
--- a/goal_src/jak3/levels/temple/templea-texture.gc
+++ b/goal_src/jak3/levels/temple/templea-texture.gc
@@ -7,3 +7,646 @@
 
 ;; DECOMP BEGINS
 
+(define *templea-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "templea-waterfall-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "templea-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "templea-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "templea-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "lightjak-wings"
+        :extra (new 'static 'vector :x 64.0 :y 16.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "lightjak-wings-u-src"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "lightjak-wings-v-src"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define *templea-warp-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'templea-warp-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(defun templea-warp-texture-anim-func ()
+  (let ((gp-0 *templea-warp-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+(define *templeb-warp-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'templeb-warp-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(defun templeb-warp-texture-anim-func ()
+  (let ((gp-0 *templeb-warp-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+(define *templec-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "tplc-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "tplc-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "tplc-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "tplc-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/temple/templex-texture.gc b/goal_src/jak3/levels/temple/templex-texture.gc
index 3416cf8f13..d62da727ca 100644
--- a/goal_src/jak3/levels/temple/templex-texture.gc
+++ b/goal_src/jak3/levels/temple/templex-texture.gc
@@ -7,3 +7,88 @@
 
 ;; DECOMP BEGINS
 
+(define *templex-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "temple-waterfall-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "temple-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "temple-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "temple-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/tower/tower-mood.gc b/goal_src/jak3/levels/tower/tower-mood.gc
index 0774098391..b5386d91c9 100644
--- a/goal_src/jak3/levels/tower/tower-mood.gc
+++ b/goal_src/jak3/levels/tower/tower-mood.gc
@@ -85,90 +85,89 @@
   (none)
   )
 
-;; og:preserve-this temporarily removed tex anim array
-; (define *towerb-water-texture-anim-array*
-;   (new 'static 'texture-anim-array :type texture-anim
-;     (new 'static 'texture-anim
-;       :num-layers #x3
-;       :func #f
-;       :init-func-id 'texture-anim-overide-size-init
-;       :tex #f
-;       :tex-name "tow-energy-bridge-dest"
-;       :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
-;       :color (new 'static 'rgba :a #x80)
-;       :frame-delta 300.0
-;       :frame-mod 2100.0
-;       :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;       :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-;       :data (new 'static 'array texture-anim-layer 6
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 2100.0
-;           :tex-name "tow-energy-bridge"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-st-rot (degrees 180)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-st-rot (degrees 180)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 2100.0
-;           :tex-name "tow-energy-bridge"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-st-rot (degrees 90)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-st-rot (degrees 90)
-;           )
-;         (new 'static 'texture-anim-layer
-;           :func-id 'default-texture-anim-layer-func
-;           :init-func #f
-;           :tex #f
-;           :end-time 2100.0
-;           :tex-name "tow-energy-bridge"
-;           :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-;           :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-;           :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
-;           :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-;           :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-;           :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
-;           :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-;           )
-;         )
-;       )
-;     )
-;   )
+(define *towerb-water-texture-anim-array*
+  (new 'static 'texture-anim-array :type texture-anim
+    (new 'static 'texture-anim
+      :num-layers #x3
+      :func #f
+      :init-func-id 'texture-anim-overide-size-init
+      :tex #f
+      :tex-name "tow-energy-bridge-dest"
+      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+      :color (new 'static 'rgba :a #x80)
+      :frame-delta 300.0
+      :frame-mod 2100.0
+      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+      :data (new 'static 'array texture-anim-layer 6
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 2100.0
+          :tex-name "tow-energy-bridge"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-st-rot (degrees 180)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-st-rot (degrees 180)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 2100.0
+          :tex-name "tow-energy-bridge"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-st-rot (degrees 90)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-st-rot (degrees 90)
+          )
+        (new 'static 'texture-anim-layer
+          :func-id 'default-texture-anim-layer-func
+          :init-func #f
+          :tex #f
+          :end-time 2100.0
+          :tex-name "tow-energy-bridge"
+          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/volcano/volcano-texture.gc b/goal_src/jak3/levels/volcano/volcano-texture.gc
index d4c29a1c71..e19a373dd6 100644
--- a/goal_src/jak3/levels/volcano/volcano-texture.gc
+++ b/goal_src/jak3/levels/volcano/volcano-texture.gc
@@ -7,3 +7,209 @@
 
 ;; DECOMP BEGINS
 
+(define *volcanoa-alpha-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        ;; og:preserve-this ignore last layer, handled in C++
+        :num-layers #x3 ; #x4
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "vola-lava-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 6000.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 2.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'set-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name #f
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        ;; og:preserve-this ignore last layer, handled in C++
+        :num-layers #x3 ; #x4
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "vola-lava-fall-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2400.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2400.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2400.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2400.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'set-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name #f
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/volcano/volcanox-texture.gc b/goal_src/jak3/levels/volcano/volcanox-texture.gc
index 38978c85f7..3ccfe378d0 100644
--- a/goal_src/jak3/levels/volcano/volcanox-texture.gc
+++ b/goal_src/jak3/levels/volcano/volcanox-texture.gc
@@ -7,3 +7,206 @@
 
 ;; DECOMP BEGINS
 
+(define *volcanox-warp-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'volcanox-warp-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.35 :y 0.25 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.35 :y 0.25 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.175 :y 0.125 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.175 :y 0.125 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+(defun volcanox-warp-texture-anim-func ()
+  (let ((gp-0 *volcanox-warp-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
diff --git a/goal_src/jak3/levels/wascity/palace/waspal-texture.gc b/goal_src/jak3/levels/wascity/palace/waspal-texture.gc
index 21952d82ed..7cf6b6b07c 100644
--- a/goal_src/jak3/levels/wascity/palace/waspal-texture.gc
+++ b/goal_src/jak3/levels/wascity/palace/waspal-texture.gc
@@ -7,3 +7,171 @@
 
 ;; DECOMP BEGINS
 
+(define *waspal-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "waspala-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "waspala-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "waspala-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "waspala-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "waspala-waterfall-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "waspala-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "waspala-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "waspala-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/goal_src/jak3/levels/wascity/wasstadium/wasstada-texture.gc b/goal_src/jak3/levels/wascity/wasstadium/wasstada-texture.gc
index 775c7f8723..f3cf4a5922 100644
--- a/goal_src/jak3/levels/wascity/wasstadium/wasstada-texture.gc
+++ b/goal_src/jak3/levels/wascity/wasstadium/wasstada-texture.gc
@@ -7,3 +7,109 @@
 
 ;; DECOMP BEGINS
 
+(define *wasstada-alpha-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        ;; og:preserve-this ignore last layer, handled in C++
+        :num-layers #x3 ; #x4
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "wstd-lava-base-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 6000.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "wstd-lava-base"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "wstd-lava-base"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "wstd-lava-base"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'set-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name #f
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
diff --git a/test/decompiler/reference/jak3/engine/gfx/background/hfrag/hfrag-texture-anim_REF.gc b/test/decompiler/reference/jak3/engine/gfx/background/hfrag/hfrag-texture-anim_REF.gc
new file mode 100644
index 0000000000..02db74a326
--- /dev/null
+++ b/test/decompiler/reference/jak3/engine/gfx/background/hfrag/hfrag-texture-anim_REF.gc
@@ -0,0 +1,214 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for function wang-texture-anim-init
+;; INFO: Used lq/sq
+;; WARN: Return type mismatch int vs none.
+(defun wang-texture-anim-init ((arg0 texture-anim))
+  (let ((v1-1 (new 'loading-level 'texture)))
+    (let ((a0-2 122))
+      (set! (-> arg0 tex) v1-1)
+      (set! (-> v1-1 w) 16)
+      (set! (-> v1-1 h) 16)
+      (set! (-> v1-1 num-mips) (the-as uint 1))
+      (set! (-> v1-1 psm) (gs-psm mt8))
+      (set! (-> v1-1 clutpsm) (the-as uint 0))
+      (set! (-> v1-1 dest 0) (the-as uint (* a0-2 32)))
+      (set! (-> v1-1 clutdest) (the-as uint (* a0-2 32)))
+      )
+    (set! (-> v1-1 width 0) (the-as uint 1))
+    (set! (-> v1-1 masks data 0 mask quad) (the-as uint128 0))
+    (set! (-> v1-1 masks data 1 mask quad) (the-as uint128 0))
+    (set! (-> v1-1 masks data 2 mask quad) (the-as uint128 0))
+    )
+  0
+  0
+  (none)
+  )
+
+;; definition for function real-wang-texture-anim-func
+;; WARN: Return type mismatch float vs none.
+(defun real-wang-texture-anim-func ((arg0 texture-anim) (arg1 texture-anim))
+  (let ((v1-1 (-> *level* level-default mood-context))
+        (f0-0 0.0)
+        )
+    (let* ((f1-2 (* 0.75 (fmax (-> v1-1 times 0 x) (fmax (-> v1-1 times 0 y) (-> v1-1 times 0 z))) (-> v1-1 times 0 w)))
+           (f1-3 (- 1.0 f1-2))
+           (a0-4 1)
+           (a2-0 4)
+           )
+      (while (>= a2-0 a0-4)
+        (let* ((f2-6 (* (-> v1-1 times a0-4 w)
+                        (fmax (-> v1-1 times a0-4 x) (fmax (-> v1-1 times a0-4 y) (-> v1-1 times a0-4 z)))
+                        f1-3
+                        )
+                     )
+               (f2-7 (fmax 0.0 f2-6))
+               (f2-8 (fmin 1.0 f2-7))
+               )
+          (set! (-> arg1 data a0-4 start-color w) f2-8)
+          (set! (-> arg1 data a0-4 end-color w) f2-8)
+          (+! f0-0 f2-8)
+          )
+        (+! a0-4 1)
+        )
+      )
+    (let ((f0-1 (if (= f0-0 0.0)
+                    0.0
+                    (/ 0.75 f0-0)
+                    )
+                )
+          (v1-7 1)
+          (a0-5 4)
+          )
+      (while (>= a0-5 v1-7)
+        (set! (-> arg1 data v1-7 start-color w) (* (-> arg1 data v1-7 start-color w) f0-1))
+        (set! (-> arg1 data v1-7 end-color w) (* (-> arg1 data v1-7 end-color w) f0-1))
+        (+! v1-7 1)
+        )
+      )
+    )
+  (set! (-> arg1 data 0 start-color w) 0.7)
+  (set! (-> arg1 data 0 end-color w) 0.7)
+  (set! (-> arg1 data 2 start-color w) (* 0.65 (-> arg1 data 2 start-color w)))
+  (set! (-> arg1 data 2 end-color w) (* 0.65 (-> arg1 data 2 end-color w)))
+  (set! (-> arg1 data 3 start-color w) (* 0.65 (-> arg1 data 3 start-color w)))
+  (set! (-> arg1 data 3 end-color w) (* 0.65 (-> arg1 data 3 end-color w)))
+  (none)
+  )
+
+;; definition for function wang-texture-anim-func
+(defun wang-texture-anim-func ((arg0 texture-anim) (arg1 texture-anim))
+  (real-wang-texture-anim-func arg0 arg1)
+  (none)
+  )
+
+;; definition for symbol *hfrag-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *hfrag-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'wang-texture-anim-func
+        :init-func-id 'wang-texture-anim-init
+        :tex #f
+        :tex-name #f
+        :color (new 'static 'rgba :a #x80)
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'blend-clut-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "wang_0"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'add-clut-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "wang_1"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'add-clut-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "wang_2"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'add-clut-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "wang_3"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'add-clut-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "wang_4"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/city/slums/ctyslumb-part_REF.gc b/test/decompiler/reference/jak3/levels/city/slums/ctyslumb-part_REF.gc
index aa38cff8ac..afe40f618b 100644
--- a/test/decompiler/reference/jak3/levels/city/slums/ctyslumb-part_REF.gc
+++ b/test/decompiler/reference/jak3/levels/city/slums/ctyslumb-part_REF.gc
@@ -1289,174 +1289,172 @@
     )
   )
 
-;; definition for symbol *ctyslumb-water-texture-anim-array*, type texture-anim-array
+;; definition for symbol *ctyslumb-water-texture-anim-array*, type (texture-anim-array texture-anim)
 (define *ctyslumb-water-texture-anim-array*
-  (new 'static 'texture-anim-array :type texture-anim
-    (new 'static 'texture-anim
-      :num-layers #x3
-      :func #f
-      :init-func-id 'texture-anim-overide-size-init
-      :tex #f
-      :tex-name "ctyslumb-water-dest"
-      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
-      :color (new 'static 'rgba :a #x80)
-      :frame-delta 300.0
-      :frame-mod 2100.0
-      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-      :data (new 'static 'array texture-anim-layer 6
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 2100.0
-          :tex-name "ctyslumb-water"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-st-rot (degrees 180)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-st-rot (degrees 180)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 2100.0
-          :tex-name "ctyslumb-water"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-st-rot (degrees 90)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-st-rot (degrees 90)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 2100.0
-          :tex-name "ctyslumb-water"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "ctyslumb-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "ctyslumb-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "ctyslumb-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "ctyslumb-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
           )
         )
-      )
-    (new 'static 'texture-anim
-      :num-layers #x3
-      :func #f
-      :init-func-id 'texture-anim-overide-size-init
-      :tex #f
-      :tex-name "ctyslumb-fountain-fall-dest"
-      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
-      :color (new 'static 'rgba :a #x80)
-      :frame-delta 300.0
-      :frame-mod 600.0
-      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-      :data (new 'static 'array texture-anim-layer 6
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 600.0
-          :tex-name "ctyslumb-fountain-fall"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 600.0
-          :tex-name "ctyslumb-fountain-fall"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 600.0
-          :tex-name "ctyslumb-fountain-fall"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "ctyslumb-fountain-fall-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "ctyslumb-fountain-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "ctyslumb-fountain-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "ctyslumb-fountain-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
           )
         )
       )
     )
   )
-
-
-
-
diff --git a/test/decompiler/reference/jak3/levels/city/slums/ctyslumc-obs_REF.gc b/test/decompiler/reference/jak3/levels/city/slums/ctyslumc-obs_REF.gc
index e44a7cb3be..c3a5d23f47 100644
--- a/test/decompiler/reference/jak3/levels/city/slums/ctyslumc-obs_REF.gc
+++ b/test/decompiler/reference/jak3/levels/city/slums/ctyslumc-obs_REF.gc
@@ -75,168 +75,170 @@
   (none)
   )
 
-;; definition for symbol *ctyslumc-water-texture-anim-array*, type texture-anim-array
+;; definition for symbol *ctyslumc-water-texture-anim-array*, type (texture-anim-array texture-anim)
 (define *ctyslumc-water-texture-anim-array*
-  (new 'static 'texture-anim-array :type texture-anim
-    (new 'static 'texture-anim
-      :num-layers #x3
-      :func #f
-      :init-func-id 'texture-anim-overide-size-init
-      :tex #f
-      :tex-name "ctyslumc-water-dest"
-      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
-      :color (new 'static 'rgba :a #x80)
-      :frame-delta 300.0
-      :frame-mod 2100.0
-      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-      :data (new 'static 'array texture-anim-layer 6
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 2100.0
-          :tex-name "ctyslumc-water"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-st-rot (degrees 180)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-st-rot (degrees 180)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 2100.0
-          :tex-name "ctyslumc-water"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-st-rot (degrees 90)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-st-rot (degrees 90)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 2100.0
-          :tex-name "ctyslumc-water"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "ctyslumc-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "ctyslumc-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "ctyslumc-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "ctyslumc-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
           )
         )
-      )
-    (new 'static 'texture-anim
-      :num-layers #x3
-      :func #f
-      :init-func-id 'texture-anim-overide-size-init
-      :tex #f
-      :tex-name "ctyslumc-fountain-fall-dest"
-      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
-      :color (new 'static 'rgba :a #x80)
-      :frame-delta 300.0
-      :frame-mod 600.0
-      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-      :data (new 'static 'array texture-anim-layer 6
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 600.0
-          :tex-name "ctyslumc-fountain-fall"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 600.0
-          :tex-name "ctyslumc-fountain-fall"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 600.0
-          :tex-name "ctyslumc-fountain-fall"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "ctyslumc-fountain-fall-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "ctyslumc-fountain-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "ctyslumc-fountain-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "ctyslumc-fountain-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
           )
         )
       )
@@ -311,7 +313,3 @@
     )
   (go-virtual idle)
   )
-
-
-
-
diff --git a/test/decompiler/reference/jak3/levels/city/vinroom/ljkdxvin-texture_REF.gc b/test/decompiler/reference/jak3/levels/city/vinroom/ljkdxvin-texture_REF.gc
new file mode 100644
index 0000000000..0d12fb661b
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/city/vinroom/ljkdxvin-texture_REF.gc
@@ -0,0 +1,213 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *ljkdxvin-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *ljkdxvin-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'ljkdxvin-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function ljkdxvin-texture-anim-func
+;; WARN: Return type mismatch int vs none.
+(defun ljkdxvin-texture-anim-func ()
+  (let ((gp-0 *ljkdxvin-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/desert/desertd-texture_REF.gc b/test/decompiler/reference/jak3/levels/desert/desertd-texture_REF.gc
new file mode 100644
index 0000000000..e547776d1b
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/desert/desertd-texture_REF.gc
@@ -0,0 +1,93 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *desertd-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *desertd-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "des-waterfall-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "des-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "des-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "des-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/desert/hover/deshover-texture_REF.gc b/test/decompiler/reference/jak3/levels/desert/hover/deshover-texture_REF.gc
new file mode 100644
index 0000000000..954fb10018
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/desert/hover/deshover-texture_REF.gc
@@ -0,0 +1,213 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *deshover-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *deshover-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'deshover-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function deshover-texture-anim-func
+;; WARN: Return type mismatch int vs none.
+(defun deshover-texture-anim-func ()
+  (let ((gp-0 *deshover-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/desert/rescue/desresc-texture_REF.gc b/test/decompiler/reference/jak3/levels/desert/rescue/desresc-texture_REF.gc
new file mode 100644
index 0000000000..b75a317ecf
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/desert/rescue/desresc-texture_REF.gc
@@ -0,0 +1,93 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *desresc-warp-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *desresc-warp-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sat-shield-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "sat-shield-env-uvscroll"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "sat-shield-env-uvscroll"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "sat-shield"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/factory/factorya-texture_REF.gc b/test/decompiler/reference/jak3/levels/factory/factorya-texture_REF.gc
new file mode 100644
index 0000000000..3c5c7a4cc4
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/factory/factorya-texture_REF.gc
@@ -0,0 +1,109 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *factoryb-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *factoryb-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "hemi-gradient-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "hemi-gradient-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 4.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "hemi-gradient-flames"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 12.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x1
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "hemi-gradient-flames-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "hemi-gradient-flames"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 12.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/factory/factoryc-texture_REF.gc b/test/decompiler/reference/jak3/levels/factory/factoryc-texture_REF.gc
new file mode 100644
index 0000000000..2d45c790b2
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/factory/factoryc-texture_REF.gc
@@ -0,0 +1,94 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *factoryc-alpha-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *factoryc-alpha-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x1
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "facc-convey-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 555.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "facc-convey"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x1
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "facc-convey-02-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 555.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "facc-convey-02"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function set-facc-conveyor-speed!
+(defun set-facc-conveyor-speed! ((arg0 float))
+  (set! (-> *factoryc-alpha-texture-anim-array* array-data 1 frame-delta) (* 0.018066408 arg0))
+  0.0
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/forest/forest-texture_REF.gc b/test/decompiler/reference/jak3/levels/forest/forest-texture_REF.gc
new file mode 100644
index 0000000000..8e63e421e1
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/forest/forest-texture_REF.gc
@@ -0,0 +1,588 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *foresta-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *foresta-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "fora-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "fora-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "fora-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "fora-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "fora-waterfall-01-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "fora-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "fora-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "fora-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "fora-water-wave-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "fora-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "fora-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "fora-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *forestb-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *forestb-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "forb-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "forb-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "forb-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "forb-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "forb-waterfall-01-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "forb-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "forb-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "forb-waterfall-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "forb-water-wave-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "forb-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "forb-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "forb-water-wave-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *lforplnt-pris-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *lforplnt-pris-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mh-gem-dest"
+        :extra (new 'static 'vector :x 32.0 :y 32.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mh-gem"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mh-gem-alpha-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.6 :y 0.6 :z 0.6 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.6 :y 0.5 :z 0.6 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mh-gem-alpha-02"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.6 :y 0.6 :z 0.6 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.6 :y 0.6 :z 0.6 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 2.0 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/glider/glider-ring-part_REF.gc b/test/decompiler/reference/jak3/levels/glider/glider-ring-part_REF.gc
index a3135ed36e..83df219275 100644
--- a/test/decompiler/reference/jak3/levels/glider/glider-ring-part_REF.gc
+++ b/test/decompiler/reference/jak3/levels/glider/glider-ring-part_REF.gc
@@ -1,514 +1,516 @@
 ;;-*-Lisp-*-
 (in-package goal)
 
-;; definition for symbol *hanga-sprite-texture-anim-array*, type texture-anim-array
+;; definition for symbol *hanga-sprite-texture-anim-array*, type (texture-anim-array texture-anim)
 (define *hanga-sprite-texture-anim-array*
-  (new 'static 'texture-anim-array :type texture-anim
-    (new 'static 'texture-anim
-      :num-layers #x11
-      :func #f
-      :init-func-id 'texture-anim-overide-size-init
-      :tex #f
-      :tex-name "glider-ring-dest2"
-      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
-      :color (new 'static 'rgba :a #x80)
-      :frame-delta 300.0
-      :frame-mod 150.0
-      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-      :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-      :data (new 'static 'array texture-anim-layer 18
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 25.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.9166667 0.9166667))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :start-time 25.0
-          :end-time 150.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.9166667 0.9166667))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :start-time 25.0
-          :end-time 50.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 70)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.875 -0.875))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 70)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :start-time 50.0
-          :end-time 150.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.875 -0.875))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 70)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.2)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.375 -0.375))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 70)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 25.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.2)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.375 -0.375))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 70)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.25 -0.25))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 70)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :start-time 50.0
-          :end-time 75.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 115)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 115)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :start-time 75.0
-          :end-time 150.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 115)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.4)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.55 0.55))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 115)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 50.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.4)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.55 0.55))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 115)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.33333334 0.33333334))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 115)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :start-time 75.0
-          :end-time 100.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 185)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.93333334 -0.93333334))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 185)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :start-time 100.0
-          :end-time 150.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.93333334 -0.93333334))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 185)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.6)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.8 -0.8))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 185)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 75.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.6)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.8 -0.8))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 185)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.5833333 -0.5833333))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 185)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :start-time 100.0
-          :end-time 125.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 249.99998)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.94166666 0.94166666))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 249.99998)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :start-time 125.0
-          :end-time 150.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.94166666 0.94166666))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 249.99998)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.8)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 249.99998)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 100.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.8)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 249.99998)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.6666667 0.6666667))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 249.99998)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :start-time 125.0
-          :end-time 150.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 305)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.9166667 -0.9166667))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 305)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 125.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-          :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.9166667 -0.9166667))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 305)
-          :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -0.5))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 305)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'set-alpha-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 150.0
-          :tex-name "splash-foam"
-          :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x11
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "glider-ring-dest2"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 150.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 18
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 25.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.9166667 0.9166667))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 25.0
+            :end-time 150.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.9166667 0.9166667))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 25.0
+            :end-time 50.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 70)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.875 -0.875))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 70)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 50.0
+            :end-time 150.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.875 -0.875))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 70)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.2)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.375 -0.375))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 70)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 25.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.2)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.375 -0.375))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 70)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.25 -0.25))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 70)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 50.0
+            :end-time 75.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 115)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 115)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 75.0
+            :end-time 150.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 115)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.4)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.55 0.55))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 115)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 50.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.4)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.55 0.55))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 115)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.33333334 0.33333334))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 115)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 75.0
+            :end-time 100.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 185)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.93333334 -0.93333334))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 185)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 100.0
+            :end-time 150.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.93333334 -0.93333334))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 185)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.6)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.8 -0.8))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 185)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 75.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.6)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.8 -0.8))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 185)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.5833333 -0.5833333))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 185)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 100.0
+            :end-time 125.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 249.99998)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.94166666 0.94166666))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 249.99998)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 125.0
+            :end-time 150.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.94166666 0.94166666))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 249.99998)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.8)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 249.99998)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 100.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 0.8)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.8833334 0.8833334))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 249.99998)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 0.6666667 0.6666667))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 249.99998)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 125.0
+            :end-time 150.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 305)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.9166667 -0.9166667))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 305)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 125.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.9166667 -0.9166667))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 305)
+            :end-color (new 'static 'vector :x 0.078125 :y 0.5 :z 1.9921875)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -0.5))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 305)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'set-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 150.0
+            :tex-name "splash-foam"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
           )
         )
-      )
-    (new 'static 'texture-anim
-      :num-layers #x3
-      :func #f
-      :init-func-id 'texture-anim-overide-size-init
-      :tex #f
-      :tex-name "glider-ring-dest"
-      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
-      :color (new 'static 'rgba :a #x80)
-      :frame-delta 300.0
-      :frame-mod 9000.0
-      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-      :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
-      :data (new 'static 'array texture-anim-layer 6
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 9000.0
-          :tex-name "glider-ring-dest2"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 9000.0
-          :tex-name "racegate"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-rot (degrees 360)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 9000.0
-          :tex-name "racegate"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-rot (degrees 360)
-          :end-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "glider-ring-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 9000.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 9000.0
+            :tex-name "glider-ring-dest2"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 9000.0
+            :tex-name "racegate"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 9000.0
+            :tex-name "racegate"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 360)
+            :end-color (new 'static 'vector :x 0.5 :y 0.625 :z 1.9921875 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
           )
         )
       )
@@ -1007,7 +1009,3 @@
 (defpart 2554
   :init-specs ((:fade-r 0.0) (:fade-g 0.0) (:fade-b 0.0) (:fade-a -0.006 -0.0024))
   )
-
-
-
-
diff --git a/test/decompiler/reference/jak3/levels/glider/hanga-init_REF.gc b/test/decompiler/reference/jak3/levels/glider/hanga-init_REF.gc
index 572c35a308..fd7b50fe0a 100644
--- a/test/decompiler/reference/jak3/levels/glider/hanga-init_REF.gc
+++ b/test/decompiler/reference/jak3/levels/glider/hanga-init_REF.gc
@@ -30,90 +30,88 @@
   (none)
   )
 
-;; definition for symbol *hanga-water-texture-anim-array*, type texture-anim-array
+;; definition for symbol *hanga-water-texture-anim-array*, type (texture-anim-array texture-anim)
 (define *hanga-water-texture-anim-array*
-  (new 'static 'texture-anim-array :type texture-anim
-    (new 'static 'texture-anim
-      :num-layers #x3
-      :func #f
-      :init-func-id 'texture-anim-overide-size-init
-      :tex #f
-      :tex-name "des-thermal-01-dest"
-      :extra (new 'static 'vector :x 128.0 :y 64.0 :z 1.0)
-      :color (new 'static 'rgba :a #x80)
-      :frame-delta 300.0
-      :frame-mod 1200.0
-      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-      :data (new 'static 'array texture-anim-layer 6
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 1200.0
-          :tex-name "des-thermal-01"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 -0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 1200.0
-          :tex-name "des-thermal-01"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -2.5 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 1200.0
-          :tex-name "des-thermal-01"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.25 0.5))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -3.25 0.5))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "des-thermal-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "des-thermal-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 -0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "des-thermal-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -2.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "des-thermal-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.25 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -3.25 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
           )
         )
       )
     )
   )
-
-
-
-
diff --git a/test/decompiler/reference/jak3/levels/gungame/gungame-texture_REF.gc b/test/decompiler/reference/jak3/levels/gungame/gungame-texture_REF.gc
new file mode 100644
index 0000000000..2faac93a93
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/gungame/gungame-texture_REF.gc
@@ -0,0 +1,156 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *lgunnorm-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *lgunnorm-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x6
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "kg-target-c-forcefield-01-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 240.0
+        :frame-mod 150.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 75.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 75.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 75.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 75.0
+            :end-time 150.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.33)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 75.0
+            :end-time 150.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.33)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 75.0
+            :end-time 150.0
+            :tex-name "kg-target-c-forcefield-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.33)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.1)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/hiphog/ltnfxhip-texture_REF.gc b/test/decompiler/reference/jak3/levels/hiphog/ltnfxhip-texture_REF.gc
new file mode 100644
index 0000000000..b772fef9b2
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/hiphog/ltnfxhip-texture_REF.gc
@@ -0,0 +1,213 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *ltnfxhip-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *ltnfxhip-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'ltnfxhip-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function ltnfxhip-texture-anim-func
+;; WARN: Return type mismatch int vs none.
+(defun ltnfxhip-texture-anim-func ()
+  (let ((gp-0 *ltnfxhip-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/mhcity/mhcitya-texture_REF.gc b/test/decompiler/reference/jak3/levels/mhcity/mhcitya-texture_REF.gc
new file mode 100644
index 0000000000..7d2e0e9d44
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/mhcity/mhcitya-texture_REF.gc
@@ -0,0 +1,189 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *lmhcitya-tfrag-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *lmhcitya-tfrag-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mhcitya-base-goo-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 6000.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcitya-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcitya-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcitya-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *mhcitya-pris-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *mhcitya-pris-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mhcity-de-door-skin-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-mod 2.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "mhcity-de-door-skin-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x80)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "mhcity-de-door-skin-02"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x80)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'copy-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1.0
+            :tex-name "mhcity-de-door-skin-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function set-mhcity-de-door-skin!
+(defun set-mhcity-de-door-skin! ((arg0 float))
+  (set! (-> *mhcitya-pris-texture-anim-array* array-data 0 frame-time) arg0)
+  arg0
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/mhcity/mhcityb-texture_REF.gc b/test/decompiler/reference/jak3/levels/mhcity/mhcityb-texture_REF.gc
new file mode 100644
index 0000000000..1ff8eaacc8
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/mhcity/mhcityb-texture_REF.gc
@@ -0,0 +1,97 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *lmhcityb-tfrag-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *lmhcityb-tfrag-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mhcityb-base-goo-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 6000.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcityb-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcityb-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "mhcityb-base-goo-01"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :c #x2 :d #x1 :fix #x2b)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/mine/mined-texture_REF.gc b/test/decompiler/reference/jak3/levels/mine/mined-texture_REF.gc
new file mode 100644
index 0000000000..603e08f7b5
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/mine/mined-texture_REF.gc
@@ -0,0 +1,473 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *mined-tfrag-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *mined-tfrag-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mined-pillar-side-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'no-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-side-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-side-cooling"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-side-hot"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-molten"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'copy-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-side-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mined-pillar-top2side-dest"
+        :extra (new 'static 'vector :x 128.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'no-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top2side-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top2side-cooling"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top2side-hot"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-molten"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'copy-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top2side-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x8
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "mined-pillar-top-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 10
+          (new 'static 'texture-anim-layer
+            :func-id 'no-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top-cooling"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top-hot"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 150.0
+            :tex-name "mined-pillar-molten-top"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 2.0 2.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 150.0
+            :end-time 300.0
+            :tex-name "mined-pillar-molten-top"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 150.0
+            :tex-name "mined-pillar-molten-top"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :start-time 150.0
+            :end-time 300.0
+            :tex-name "mined-pillar-molten-top"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 2.0 2.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'copy-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "mined-pillar-top-cold"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function set-mined-pillar-texture!
+;; WARN: Return type mismatch float vs none.
+(defun set-mined-pillar-texture! ((arg0 float))
+  (let ((f0-1 (- 1.0 (fmax 0.0 (fmin 1.0 (* 4.0 arg0)))))
+        (f1-3 (fmax 0.0 (fmin 1.0 (- 1.0 (* 2.0 arg0)))))
+        (f2-5 (- 1.0 (fabs (+ -1.0 (* 2.0 arg0)))))
+        (v1-9 *mined-tfrag-texture-anim-array*)
+        )
+    (set! (-> v1-9 array-data 0 data 1 start-color w) f2-5)
+    (set! (-> v1-9 array-data 0 data 1 end-color w) f2-5)
+    (set! (-> v1-9 array-data 1 data 1 start-color w) f2-5)
+    (set! (-> v1-9 array-data 1 data 1 end-color w) f2-5)
+    (set! (-> v1-9 array-data 2 data 1 start-color w) f2-5)
+    (set! (-> v1-9 array-data 2 data 1 end-color w) f2-5)
+    (set! (-> v1-9 array-data 0 data 2 start-color w) f1-3)
+    (set! (-> v1-9 array-data 0 data 2 end-color w) f1-3)
+    (set! (-> v1-9 array-data 1 data 2 start-color w) f1-3)
+    (set! (-> v1-9 array-data 1 data 2 end-color w) f1-3)
+    (set! (-> v1-9 array-data 2 data 2 start-color w) f1-3)
+    (set! (-> v1-9 array-data 2 data 2 end-color w) f1-3)
+    (set! (-> v1-9 array-data 0 data 3 start-color w) f0-1)
+    (set! (-> v1-9 array-data 0 data 3 end-color w) f0-1)
+    (set! (-> v1-9 array-data 1 data 3 start-color w) f0-1)
+    (set! (-> v1-9 array-data 1 data 3 end-color w) f0-1)
+    (set! (-> v1-9 array-data 2 data 3 end-color w) f0-1)
+    (set! (-> v1-9 array-data 2 data 4 start-color w) f0-1)
+    (set! (-> v1-9 array-data 2 data 5 start-color w) f0-1)
+    (set! (-> v1-9 array-data 2 data 6 end-color w) f0-1)
+    )
+  (none)
+  )
+
+;; failed to figure out what this is:
+(set-mined-pillar-texture! 0.0)
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/nest/nstb-texture_REF.gc b/test/decompiler/reference/jak3/levels/nest/nstb-texture_REF.gc
new file mode 100644
index 0000000000..47ea494437
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/nest/nstb-texture_REF.gc
@@ -0,0 +1,49 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *nstb-quicksand-anim-array*, type (texture-anim-array texture-anim)
+(define *nstb-quicksand-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x1
+        :func #f
+        :init-func #f
+        :tex #f
+        :tex-name "nstb-quicksand-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "nstb-quicksand-scroll"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/sewer/sewer-texture_REF.gc b/test/decompiler/reference/jak3/levels/sewer/sewer-texture_REF.gc
new file mode 100644
index 0000000000..10cee24832
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/sewer/sewer-texture_REF.gc
@@ -0,0 +1,3206 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *sewc-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *sewc-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-c-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-01-c-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-c-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-c-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-highlight-01-c-dest"
+        :extra (new 'static 'vector :x 64.0 :y 32.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-c"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *sewd-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *sewd-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-d-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-d-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-highlight-01-d-dest"
+        :extra (new 'static 'vector :x 64.0 :y 32.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-d-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-02-d-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "sewer-water-wave-02-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "sewer-water-wave-02-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 3.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-still-01-d-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 4500.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 1.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 0.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-d"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *sewe-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *sewe-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-e-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-01-e-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 450.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 450.0
+            :tex-name "sewer-waterfall-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 450.0
+            :tex-name "sewer-waterfall-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 450.0
+            :tex-name "sewer-waterfall-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-e-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-highlight-01-e-dest"
+        :extra (new 'static 'vector :x 64.0 :y 32.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-e"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *sewg-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *sewg-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-g-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-g-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-g-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-g"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *sewh-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *sewh-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-h-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-h-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-02-h-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-wave-02-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-wave-02-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 3.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-watefall-froth-01-h-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 525.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-h"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *sewi-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *sewi-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-still-01-i-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 4500.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 1.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 0.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-i-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-i-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-i"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *sewj-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *sewj-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-j-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-watefall-froth-01-j-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 525.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-j"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *sewl-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *sewl-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-l-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-watefall-froth-01-l-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 525.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-l"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *sewm-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *sewm-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-01-m-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 900.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 900.0
+            :tex-name "sewer-water-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-01-m-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-m-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-highlight-01-m-dest"
+        :extra (new 'static 'vector :x 64.0 :y 32.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-m-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-still-01-m-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 4500.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 1.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 0.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-watefall-froth-01-m-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 525.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 525.0
+            :tex-name "sewer-watefall-froth-01-m"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *sewn-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *sewn-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-01-n-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-waterfall-02-n-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-waterfall-02-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-highlight-01-n-dest"
+        :extra (new 'static 'vector :x 64.0 :y 32.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "sewer-water-highlight-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.5)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-wave-01-n-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1800.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.67 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.67 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 2.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1800.0
+            :tex-name "sewer-water-wave-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "sewer-water-still-01-n-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 4500.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 4500.0
+            :tex-name "sewer-water-still-01-n"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/stadium/rubble-texture_REF.gc b/test/decompiler/reference/jak3/levels/stadium/rubble-texture_REF.gc
new file mode 100644
index 0000000000..4e0a28faaf
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/stadium/rubble-texture_REF.gc
@@ -0,0 +1,370 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *rubblea-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *rubblea-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "rub-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *rubblea2-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *rubblea2-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "rub-water-desta2"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-watera2"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-watera2"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-watera2"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *rubbleb-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *rubbleb-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "rub-water-destb"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterb"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterb"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterb"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *rubblec-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *rubblec-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "rub-water-destc"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterc"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterc"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "rub-waterc"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/temple/templea-texture_REF.gc b/test/decompiler/reference/jak3/levels/temple/templea-texture_REF.gc
new file mode 100644
index 0000000000..dd0c775838
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/temple/templea-texture_REF.gc
@@ -0,0 +1,658 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *templea-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *templea-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "templea-waterfall-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "templea-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "templea-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "templea-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x2
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "lightjak-wings"
+        :extra (new 'static 'vector :x 64.0 :y 16.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 300.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 2
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "lightjak-wings-u-src"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wmt (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.0 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 300.0
+            :tex-name "lightjak-wings-v-src"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp))
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for symbol *templea-warp-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *templea-warp-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'templea-warp-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function templea-warp-texture-anim-func
+;; WARN: Return type mismatch int vs none.
+(defun templea-warp-texture-anim-func ()
+  (let ((gp-0 *templea-warp-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for symbol *templeb-warp-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *templeb-warp-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'templeb-warp-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.25 :y 0.35 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.125 :y 0.175 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function templeb-warp-texture-anim-func
+;; WARN: Return type mismatch int vs none.
+(defun templeb-warp-texture-anim-func ()
+  (let ((gp-0 *templeb-warp-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+;; definition for symbol *templec-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *templec-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "tplc-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "tplc-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "tplc-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "tplc-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/temple/templex-texture_REF.gc b/test/decompiler/reference/jak3/levels/temple/templex-texture_REF.gc
new file mode 100644
index 0000000000..b1d8ad9592
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/temple/templex-texture_REF.gc
@@ -0,0 +1,93 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *templex-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *templex-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "temple-waterfall-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "temple-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "temple-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "temple-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/tower/tower-mood_REF.gc b/test/decompiler/reference/jak3/levels/tower/tower-mood_REF.gc
index db4d849029..c4e95af505 100644
--- a/test/decompiler/reference/jak3/levels/tower/tower-mood_REF.gc
+++ b/test/decompiler/reference/jak3/levels/tower/tower-mood_REF.gc
@@ -108,94 +108,92 @@
   (none)
   )
 
-;; definition for symbol *towerb-water-texture-anim-array*, type texture-anim-array
+;; definition for symbol *towerb-water-texture-anim-array*, type (texture-anim-array texture-anim)
 (define *towerb-water-texture-anim-array*
-  (new 'static 'texture-anim-array :type texture-anim
-    (new 'static 'texture-anim
-      :num-layers #x3
-      :func #f
-      :init-func-id 'texture-anim-overide-size-init
-      :tex #f
-      :tex-name "tow-energy-bridge-dest"
-      :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
-      :color (new 'static 'rgba :a #x80)
-      :frame-delta 300.0
-      :frame-mod 2100.0
-      :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-      :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
-      :data (new 'static 'array texture-anim-layer 6
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 2100.0
-          :tex-name "tow-energy-bridge"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-st-rot (degrees 180)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-st-rot (degrees 180)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 2100.0
-          :tex-name "tow-energy-bridge"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-st-rot (degrees 90)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-st-rot (degrees 90)
-          )
-        (new 'static 'texture-anim-layer
-          :func-id 'default-texture-anim-layer-func
-          :init-func #f
-          :tex #f
-          :end-time 2100.0
-          :tex-name "tow-energy-bridge"
-          :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
-          :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
-          :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
-          :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
-          :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
-          :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
-          :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
-          :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "tow-energy-bridge-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "tow-energy-bridge"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "tow-energy-bridge"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "tow-energy-bridge"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
           )
         )
       )
     )
   )
-
-
-
-
diff --git a/test/decompiler/reference/jak3/levels/volcano/volcano-texture_REF.gc b/test/decompiler/reference/jak3/levels/volcano/volcano-texture_REF.gc
new file mode 100644
index 0000000000..9ddf4efc45
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/volcano/volcano-texture_REF.gc
@@ -0,0 +1,212 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *volcanoa-alpha-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *volcanoa-alpha-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x4
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "vola-lava-01-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 6000.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 2.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 1.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 0.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'set-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name #f
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x4
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "vola-lava-fall-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2400.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2400.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2400.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2400.0
+            :tex-name "vola-lava-fall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'set-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name #f
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/volcano/volcanox-texture_REF.gc b/test/decompiler/reference/jak3/levels/volcano/volcanox-texture_REF.gc
new file mode 100644
index 0000000000..2315a5f903
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/volcano/volcanox-texture_REF.gc
@@ -0,0 +1,213 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *volcanox-warp-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *volcanox-warp-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x5
+        :func-id 'volcanox-warp-texture-anim-func
+        :init-func #f
+        :tex #f
+        :tex-name "holograph-env-rim-dest"
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 1200.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-noise"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 21600)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-scan"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.35 :y 0.25 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.35 :y 0.25 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "holograph-env-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.5 :y 0.5 :z 0.5 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 -1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 360)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 1200.0
+            :tex-name "environment-phong-rim"
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 0.175 :y 0.125 :z 0.25 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 0.175 :y 0.125 :z 0.25 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+;; definition for function volcanox-warp-texture-anim-func
+;; WARN: Return type mismatch int vs none.
+(defun volcanox-warp-texture-anim-func ()
+  (let ((gp-0 *volcanox-warp-texture-anim-array*))
+    (when (not (paused?))
+      (let ((s5-0 (-> gp-0 array-data 0 data 0)))
+        (cond
+          ((= (-> s5-0 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 150.0 300.0))
+              (set! (-> s5-0 extra z) (-> s5-0 extra y))
+              (set! (-> s5-0 extra w) (rand-vu-float-range 0.1 0.5))
+              (set! (-> s5-0 extra x) 1.0)
+              )
+             (else
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> s5-0 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> s5-0 extra y))
+              (set! (-> s5-0 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> s5-0 extra x) 0.0)
+              )
+             (else
+               (let ((f0-16 (+ 0.1 (* (-> s5-0 extra w) (sin (* 32768.0 (/ (-> s5-0 extra y) (-> s5-0 extra z))))))))
+                 (set-vector! (-> s5-0 start-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 (set-vector! (-> s5-0 end-color) (* 0.5 f0-16) (* 0.7 f0-16) f0-16 1.0)
+                 )
+               (set! (-> s5-0 extra y) (- (-> s5-0 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      (let ((gp-1 (-> gp-0 array-data 0 data 1)))
+        (cond
+          ((= (-> gp-1 extra x) 0.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 75.0 150.0))
+              (set! (-> gp-1 extra z) (-> gp-1 extra y))
+              (set! (-> gp-1 extra x) 1.0)
+              )
+             (else
+               (set! (-> gp-1 start-st-offset y) 0.0)
+               (set! (-> gp-1 end-st-offset y) 0.0)
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          ((= (-> gp-1 extra x) 1.0)
+           (cond
+             ((>= 0.0 (-> gp-1 extra y))
+              (set! (-> gp-1 extra y) (rand-vu-float-range 300.0 600.0))
+              (set! (-> gp-1 extra x) 0.0)
+              )
+             (else
+               (let ((f0-34 (- 1.0 (/ (-> gp-1 extra y) (-> gp-1 extra z)))))
+                 (set! (-> gp-1 start-st-offset y) f0-34)
+                 (set! (-> gp-1 end-st-offset y) f0-34)
+                 )
+               (set! (-> gp-1 extra y) (- (-> gp-1 extra y) (* 300.0 (seconds-per-frame))))
+               )
+             )
+           )
+          )
+        )
+      )
+    )
+  0
+  (none)
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/wascity/palace/waspal-texture_REF.gc b/test/decompiler/reference/jak3/levels/wascity/palace/waspal-texture_REF.gc
new file mode 100644
index 0000000000..572bb5fd29
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/wascity/palace/waspal-texture_REF.gc
@@ -0,0 +1,176 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *waspal-water-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *waspal-water-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "waspala-water-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 2100.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "waspala-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.33 0.33))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 180)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.33 1.33))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 180)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "waspala-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.67 0.67))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-st-rot (degrees 90)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.67 1.67))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-st-rot (degrees 90)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name "waspala-water"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      (new 'static 'texture-anim
+        :num-layers #x3
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "waspala-waterfall-dest"
+        :extra (new 'static 'vector :x 64.0 :y 64.0 :z 1.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 600.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :clamp (new 'static 'gs-clamp :wms (gs-tex-wrap-mode clamp) :wmt (gs-tex-wrap-mode clamp))
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "waspala-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.5 -1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "waspala-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 600.0
+            :tex-name "waspala-waterfall"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 -3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/decompiler/reference/jak3/levels/wascity/wasstadium/wasstada-texture_REF.gc b/test/decompiler/reference/jak3/levels/wascity/wasstadium/wasstada-texture_REF.gc
new file mode 100644
index 0000000000..06c9313373
--- /dev/null
+++ b/test/decompiler/reference/jak3/levels/wascity/wasstadium/wasstada-texture_REF.gc
@@ -0,0 +1,113 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *wasstada-alpha-texture-anim-array*, type (texture-anim-array texture-anim)
+(define *wasstada-alpha-texture-anim-array*
+  (the-as (texture-anim-array texture-anim)
+    (new 'static 'texture-anim-array :type texture-anim
+      (new 'static 'texture-anim
+        :num-layers #x4
+        :func #f
+        :init-func-id 'texture-anim-overide-size-init
+        :tex #f
+        :tex-name "wstd-lava-base-dest"
+        :extra (new 'static 'vector :x 128.0 :y 128.0 :z 4.0)
+        :color (new 'static 'rgba :a #x80)
+        :frame-delta 300.0
+        :frame-mod 6000.0
+        :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+        :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+        :data (new 'static 'array texture-anim-layer 6
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "wstd-lava-base"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.25))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 3.25))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "wstd-lava-base"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -0.3 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 -1.3 2.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'default-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 6000.0
+            :tex-name "wstd-lava-base"
+            :test (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x2 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.3 0.0))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 0.333)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 1.3 1.0))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          (new 'static 'texture-anim-layer
+            :func-id 'set-alpha-texture-anim-layer-func
+            :init-func #f
+            :tex #f
+            :end-time 2100.0
+            :tex-name #f
+            :test (new 'static 'gs-test :ate #x1 :afail #x3 :zte #x1 :ztst (gs-ztest always))
+            :alpha (new 'static 'gs-alpha :b #x1 :d #x1)
+            :start-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :start-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :start-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :start-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-color (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            :end-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-st-scale (new 'static 'vector2 :data (new 'static 'array float 2 1.0 1.0))
+            :end-st-offset (new 'static 'vector2 :data (new 'static 'array float 2 0.5 0.5))
+            :end-qs (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
+            )
+          )
+        )
+      )
+    )
+  )
+
+
+
+
diff --git a/test/offline/config/jak3/config.jsonc b/test/offline/config/jak3/config.jsonc
index a8509a7516..0fada79667 100644
--- a/test/offline/config/jak3/config.jsonc
+++ b/test/offline/config/jak3/config.jsonc
@@ -118,7 +118,9 @@
     "DGO/LCTYPALT.DGO",
     "DGO/PRECA.DGO",
     "DGO/PRECD.DGO",
-    "DGO/LFACCITY.DGO"
+    "DGO/LFACCITY.DGO",
+    "DGO/MHCA.DGO",
+    "DGO/MHCB.DGO"
   ],
 
   "skip_compile_files": [