Compare commits

..

221 Commits

Author SHA1 Message Date
briaguya 72b12890fd bump version (#2632) 2023-03-14 09:16:54 -04:00
briaguya 0ade1aad69 use LUS with atmosphere fix (#2629) 2023-03-14 03:56:14 -04:00
Malkierian 264623f40a Shopsanity Affordable Logic Update (#2617)
* Modified Affordable logic to select randomly from 10, 105, 205, and 505 depending on the selected wallet tier. Updated the tooltip to reflect.

* Clarified logic in comments and variable names.

* Streamlined affordable check for starter wallet.

One more function comment.

* More streamlining of affordable price generation, comment clarification.
2023-03-13 17:24:51 -04:00
Christopher Leggett d9008938f8 Makes sequenceMap and seqLoadStatus a dynamic size (#2610)
Refactors to allow the above two arrays to be a dynamic size when the game launches, size is set during the AudioLoad_Init function.
2023-03-12 15:55:25 -04:00
Adam Bird 1ce9634f65 clear bongo bongo static effect on actor reset (#2603) 2023-03-12 08:06:52 +01:00
Adam Bird 39acd71fc4 remove left over boss location logic from mq logic (#2619) 2023-03-12 08:01:18 +01:00
aMannus 095066ffcd Enemy Rando - Arwing range check (Khan Edition) (#2613)
* Arwing range check

* Small code cleanup
2023-03-11 09:47:56 -08:00
aMannus 1c00d56053 Exclude club moblins in clear rooms (#2593) 2023-03-08 13:10:14 -05:00
Adam Bird 7c558ae089 fix rando quest selection falling back to vanilla saves (#2599) 2023-03-08 13:09:22 -05:00
Adam Bird 60f4f71495 fix flag wind speed to use correct uint type (#2600) 2023-03-08 13:08:54 -05:00
Adam Bird 2117d98178 fix skulltula token count message on vanilla (#2597) 2023-03-08 10:18:02 -05:00
Malkierian 5d32343919 Modify cutsceneIndex in scene transition autosave to include use-cases outside of normal vanilla play. (#2588) 2023-03-06 23:17:27 -05:00
Adam Bird ce115272cd fix equip now enhancement running with non-equipment items (#2590) 2023-03-06 23:15:51 -05:00
Adam Bird 0a67e42f6c handle angry happy mask throwing link out in entrance randomizer (#2578) 2023-03-04 00:30:20 -05:00
Adam Bird a5bf135541 fix change age cheat causing link to spawn in the wrong spot (#2573) 2023-03-02 17:12:46 -05:00
Josh Bodner 0d54cb15df Spot fix so autosave dropdown will save immediately (#2568) 2023-03-02 16:57:55 -05:00
briaguya e07de4b3b5 bump version (#2559) 2023-03-01 00:56:31 -05:00
briaguya 05723bc8d6 bump lus (#2558) 2023-02-28 23:13:37 -05:00
David Chavez b74be9196c [Accessibility] Add ability to disable camera re-centering on idle (#2503)
* Add ability to disable camera recentering on idle

* Remove platform check

* Update else camera comment
2023-02-28 21:42:15 -05:00
Dakota Brown 0daa91f4e3 Update BUILDING.md (#2385)
I use PyEnv and rebuilding after recent commits was giving me a cmake error about not being able to find the Python3 executable. Advising other users who might run into this problem on how to fix it.
2023-02-28 21:10:19 -05:00
Adam Bird 1fc6a2f08f Rando version warning on different builds (#2420)
* save build version to savefile

* adjust rando hash icons to use fade in/out

* add dialog message support on the file select screen and display rando version warning

* remove duplicated message functions and use stubbed play state instead for rando warning

* add major/minor/patch version saving to file and compare against

* use strncpy and memset for build version

* don't show rando warning one copy/erase screens

* review feedback

* Add german and french translations for rando warning

Co-authored-by: PurpleHato <linkvssangoku.jr@gmail.com>

---------

Co-authored-by: PurpleHato <linkvssangoku.jr@gmail.com>
2023-02-28 20:46:55 -05:00
David Chavez 27d7cb0bc1 [CMake] Clean soh/CMakeLists (#2556) 2023-02-28 19:19:34 +01:00
briaguya 2df6acc908 Fix: some greg hint stuff (#2557)
Co-authored-by: briaguya <briaguya@alice>
2023-02-28 18:23:22 +01:00
David Chavez c91a044d46 [GameInteractor] Introduce GameFrameUpdate Hook and Migrate Cheats (#2554) 2023-02-28 11:20:43 +01:00
Evgenii Babinets afc61e65ee Restored vanilla pause buffering and input behavior broken by 'easy frame advance' cheat (#2511)
* Restored vanilla pause buffering and input behavior broken by 'easy frame advance' cheat

Currently, holding A and repeatedly pausing and unpausing will cause that A input to be repeated, resulting in Link rolling without additional A inputs. Similarly, holding Z and unpausing in front of a candidate actor will cause Link to switch Z-targeting to that actor.

As a side effect, this also does not allow inputs to be buffered before the Subscreen has finished its closing animation, which is how vanilla also works. This is slightly unfortunate because the "freeze" before the game resumes is considerably shorter in Shipwright, but it'd be better to implement a fake delay there if we want to make it more forgiving.

* Fixed writing past end of the buffer when loading personal item tracker notes longer than 8 characters

* Revert "Fixed writing past end of the buffer when loading personal item tracker notes longer than 8 characters"

This reverts commit 721c18d488.
2023-02-28 04:22:26 -05:00
briaguya 7f5221b149 Supersonic merge fixes (#2553)
* ss2

* Remove Comments and Rupees when dead.

* Rupees removal for real

* Updated Inline formatting as well as changed Mode Idenitifier from Super Sonic to Rupee Dash.

* Add OnPlayerUpdate hook

* Move rupee dash to hooks

* Update comment for DashInterval

* ss2

* Remove Comments and Rupees when dead.

* Rupees removal for real

* Updated Inline formatting as well as changed Mode Idenitifier from Super Sonic to Rupee Dash.

* Add OnPlayerUpdate hook

* Move rupee dash to hooks

* Update comment for DashInterval

* Update Health to not crash on less than 16 units.

* lus

* fix build, use `Health_ChangeBy`

---------

Co-authored-by: Caladius <Caladius@users.noreply.github.com>
Co-authored-by: David Chavez <david@dcvz.io>
2023-02-28 03:52:32 -05:00
David Chavez f0be8c7b0c [Dev] Add Support for Github Codespaces (#2551)
* Add apt packages

* Move to docker based codspace
2023-02-28 01:11:56 -05:00
Josh Bodner f481b86386 Change autosave to use dropdown (#2550) 2023-02-28 00:07:47 -05:00
briaguya 061e232685 fix greg hint (and an RSK parsing issue) (#2547)
* fix RSK parsing error introduced by  #2541

* add logic to not give greg hint when we shouldn't

---------

Co-authored-by: briaguya <briaguya@alice>
2023-02-27 21:03:00 -05:00
Adam Bird 9ec091a636 add missing settings values that weren't being parsed (#2541) 2023-02-26 23:05:07 -05:00
Adam Bird f7bb807940 [Game Interactor] Add LoadGame and ExitGame hooks (#2542)
* add loadgame/exitgame GI hooks

* implement loadgame/exitgame hooks in game code

* move entrance tracker data lifecycle to hooks

* update cosmetic editor to update onloadgame hook
2023-02-26 23:04:57 -05:00
briaguya 17aeec4b13 add greg to gameplay stats (#2544)
Co-authored-by: briaguya <briaguya>
2023-02-26 23:04:47 -05:00
David Chavez 2cb4a6ee7e [Resources] Cleanup old hacks and rename (#2546) 2023-02-27 02:55:40 +01:00
David Chavez 448b4e49d3 [GameInteractor] Update Naming Modhooks (#2543) 2023-02-27 01:46:25 +01:00
Adam Bird c1ddeec02a fix cutscenes loading wrong resource when only an mq rom is loaded (#2545) 2023-02-27 01:44:30 +01:00
briaguya 60b206140d Greg Hint + Hint cleanup (#2537)
* Restore greg stuff

* Cleanup

* Actually check for Greg when creating Greg hint

Co-authored-by: briaguya <70942617+briaguya-ai@users.noreply.github.com>

* whoops

* Update soh/soh/Enhancements/randomizer/3drando/hints.cpp

Co-authored-by: briaguya <70942617+briaguya-ai@users.noreply.github.com>

* fix greg hint crash, clean up hint generation (clear out hints when setting is off)

* update vanillafill too

* fix text id, parse json, expand array to fit hint

* actually parse/use greg hint RSK

* specify "after buying a key" in hover text hint

---------

Co-authored-by: David Chavez <david@dcvz.io>
Co-authored-by: Ralphie Morell <stratomaster64@gmail.com>
2023-02-24 20:35:15 -05:00
briaguya 390bdf10f6 bump lus (#2536) 2023-02-24 16:27:52 -05:00
briaguya fef230bc87 make greg bridge more greg (#2532)
* make greg bridge more greg

* use green rupee color from cosmetics editor

* use hooks to not patch/unpatch every frame

* use gi hook

---------

Co-authored-by: briaguya <briaguya@alice>
2023-02-24 15:55:53 -05:00
Malkierian 29daec879b Shopsanity price range selection (#2517)
* Adds price range select box for shopsanity when shopsanity is 1 or more items.
Default option is the original functionality, now under "Random" select option.

Other options include Affordable, which makes each item 10 rupees, and one option for each level of wallet available with shopsanity, where each wallet's max capacity is the upper limit on the price randomization. These still go in 5 rupee increments, like Random.

Also keeps track of and saves/loads settings appropriately on game start.

* Changed "Random" default shopsanity price selection to "Balanced" to be more properly descriptive.

Refactored GetRandomShopPrice to try to keep Balanced as the default, with a sane fallback price of 150 should the weighted randomizer somehow fail.

* Missed one change from Random to Balanced.

* Changed wallet range to minimum of 5, and removed the multiple of 5 requirement (full rando within range).

* Modified the system to add a checkbox for affordability which then adds a price cap that is just above the max value of the previous wallet tier. Effectively this keeps the wallet lock in place, but prevents anything from getting more expensive than 5 past the previous tier.

* Fixed hover help text and tooltip formatting.

* Changed wallet ranges to generate multiples of 5. May need weighted generation after playtesting.
2023-02-24 04:21:13 -05:00
briaguya 23d2e4a2cc improve cvar usage in AudioEditor (#2523)
Co-authored-by: briaguya <briaguya@alice>
2023-02-24 03:21:46 -05:00
briaguya 95fe6b492b fix: use trick names for scrub and house of skulltula hints (#2528)
* update writealllocations to always write trickname and start seeing where things break

* handle simple vs complex items

* always grab a trick name

---------

Co-authored-by: briaguya <briaguya@alice>
2023-02-24 03:21:35 -05:00
briaguya df6da69f7d add greg bridge altar text (#2524)
Co-authored-by: briaguya <briaguya@alice>
2023-02-24 03:20:24 -05:00
briaguya 96dd7073e4 always add a gossip stone hint for greg when greg bridge is enabled (#2530)
* always add a gossip stone hint for greg when greg bridge is enabled

* don't double loop

---------

Co-authored-by: briaguya <briaguya@alice>
2023-02-24 02:57:31 -05:00
briaguya 231b7eecca "greg the green rupee" (#2529)
Co-authored-by: briaguya <briaguya@alice>
2023-02-24 02:57:19 -05:00
briaguya e25b11c5ac Add menu option for changing disappearing path behavior (#2527)
* Adding CVar for z-fighting fix

* ultraship update

* remove commented out code

* formatting

---------

Co-authored-by: Bagbar <ckonrad86@gmx.de>
2023-02-23 22:42:58 -05:00
briaguya ff94d35ea9 fix a couple junk hints that were making AutoFormatHintTextString loop forever (#2525) 2023-02-23 22:14:17 -05:00
Adam Bird 6e4b1aec2a fix excluded locations being removed if you haven't viewed the location tab (#2518) 2023-02-23 08:47:13 +01:00
Adam Bird 3d30f1701a make the gf chest as child use the correct RC check (#2519) 2023-02-23 08:47:13 +01:00
Adam Bird ffbaef7823 fix incorrect hint key for child spawn location (#2507) 2023-02-23 08:47:13 +01:00
Amaro Martínez 656e593a67 Fix Lakeside Laboratory title card (#2501) 2023-02-23 08:47:13 +01:00
Adam Bird 6a09934e3b fix logic to use fire timer for deku scrub in DMC (#2502) 2023-02-23 08:47:13 +01:00
briaguya d238533aba bump lus (#2521) 2023-02-23 01:49:54 -05:00
Matt Wiens 7860f88241 Fix menu bar fix description typo (#2504) 2023-02-23 01:14:27 -05:00
Evgenii Babinets e8e4afbbcd Fixed potential memory corruption when loading personal item tracker notes (#2512) 2023-02-23 01:13:32 -05:00
Ralphie Morell 4a4f7e6d96 [Fix] Static Bomb Radius (#2515) 2023-02-21 08:49:53 +01:00
David Chavez 12e1814dad Update to latest LUS (#2514) 2023-02-21 01:38:27 +01:00
briaguya 9325e6d0a5 fix: don't show duplicate gregs on item tracker (#2498)
Co-authored-by: briaguya <briaguya@alice>
2023-02-17 11:05:15 -05:00
briaguya 494bdcdb25 gibbs -> dev 2023-02-17 08:02:08 -05:00
Malkierian 868689ce3e Entrance tracker tweaks (#2446)
* Hide return transitions for dungeon, grotto and interior entrances when "Decouple entrances" is off.

* "Highlight last entrance" now highlights the override reverseIndex entry in the list if "Decouple entrances" is off, to correspond with not displaying return directions for the same setting (without this, nothing gets highlighted with the return transitions hidden with "Decouple entrances" off).

* Removed unnecessary printf

* Moved redundancy check to filtering loop instead of display loop.

Introduced setting to optionally force showing redundant entrances when decoupled is off.

Formatting changes suggested by Archez.

* Changed "show redundant" to "hide reverse" where applicable, and change

Added option disabling based on Decouple Entrances.

* Finished descriptive comment.

* Moved "Hide reverse" to left column of tracker settings.

Changed to PaddedEnhancementCheckbox, changed checkbox padding accordingly, and set default to true.

* Restore tooltip to Hide Reverse option, fix default value.

Co-authored-by: Adam Bird <Archez@users.noreply.github.com>

* Restored padding underneath last option in entrance tracker List Items section.

---------

Co-authored-by: Adam Bird <Archez@users.noreply.github.com>
2023-02-17 07:38:07 -05:00
Adam Bird 3f3f4ff3ef Fix: Prevent certain items from being marked as "major" (#2496)
* fix certain items being marked as major

* simplify check

* avoid string check
2023-02-17 07:14:43 -05:00
briaguya 68c8f50a71 greg bridge in logic (#2460)
* greg bridge in logic

---------

Co-authored-by: briaguya <briaguya@alice>
2023-02-16 21:53:08 -05:00
briaguya 3d8752b3aa you found greg! (#2458)
adds greg to the item tracker

---------

Co-authored-by: briaguya <briaguya@alice>
2023-02-16 20:10:31 -05:00
briaguya f4f10e4a49 don't show duped sequence names, don't repeat track intros on barinade (#2482)
* better fix for repeated sequence names, add delay to fix repeated bgm on barinade

---------

Co-authored-by: briaguya <briaguya@alice>
2023-02-16 18:45:51 -05:00
briaguya 6b93da37d4 fix: use cache on LoadFileRaw (#2489)
* fix: use cache on LoadFileRaw

this makes it so explosions don't use the dpad texture

---------

Co-authored-by: briaguya <briaguya@alice>
2023-02-16 18:05:36 -05:00
David Chavez 6cd7066706 Generate assets with MQ present (#2485) 2023-02-16 13:32:01 -05:00
AltoXorg 877fc2dcca use the convenient printf fomat as ImGui::Text supports it (#2486) 2023-02-16 11:37:27 -05:00
briaguya 1e6ec1bdda exclude audio from shuffle (#2411)
* Rename "SFX Editor" to "Audio Editor"
* Move some functionality out into a new class `AudioCollection`
* Add a tab to exclude sfx/sequences from shuffle pool 

---------

Co-authored-by: briaguya <briaguya@alice>
Co-authored-by: briaguya <briaguya>
Co-authored-by: David Chavez <david@dcvz.io>
2023-02-16 09:49:45 -05:00
briaguya 27f961ac4f bump lus (#2483)
Co-authored-by: briaguya <briaguya@alice>
2023-02-16 00:27:01 -05:00
briaguya deb47ea430 hintless altar text (#2456)
Co-authored-by: briaguya <briaguya@alice>
2023-02-15 21:00:44 -05:00
Bigs d275740c88 Separate X/Y axis sensitivity sliders (#2472)
* Update z_camera.c

* Update GameControlEditor.cpp

* Update GameControlEditor.cpp

* Update GameControlEditor.cpp

Adding Sliders for first person X and Y axis

* Update z_player.c

Modified variables to allowed separate sensitivity settings for x and y axis
2023-02-15 20:42:21 -05:00
David Chavez 8934274c67 [GameInteractor] Game Hooks (#2481) 2023-02-15 20:30:34 +01:00
David Chavez 2c10bca615 Fix compilation against latest libultraship (#2479) 2023-02-15 11:06:19 +01:00
Bigs b19c72070d Enhancement Toggle - Disable Automatic First Person Mode for Bombchus (#2471)
* Update z_camera.c

* Revert "Update z_camera.c"

* Update GameMenuBar.cpp

Added tickbox for NoFPChus

* Update z_player.c

Added check for Disable First Person Bomchus enhancement

* Update z_player.c

Removed comment as statement is clear on its own

* Update GameMenuBar.cpp
2023-02-15 01:47:38 -05:00
Kenix3 3a4a260e21 SoH now uses the multithreaded resource manager. (#2467)
* SoH now uses the multithreaded resource manager.

* Fixes build errors on Linux and decreases audio heap size.

* Updates LUS.
2023-02-15 01:02:09 -05:00
Ralphie Morell 7c3c662eba Rando: Allow strings as seed hashes (#2438)
* Allows strings to be used for rando seed hashes;
updated conversion method from `stoi` to `stoul`

* apply suggestions

* Allow spaces + autoselect on input field focus

* Added new text filter; applied suggestions

* leaving 3d rando logic alone

* Apply more suggestions

* Revert buffer size to 1024
2023-02-14 21:43:25 -05:00
PurpleHato e60f2b0c55 ADD: Time Savers -> Link as default file name (#2475) 2023-02-14 21:15:15 -05:00
Cardboy777 2241635ac5 Option for link's models reflect the projectile weapon he's holding (Bow/Slingshot) (#2454)
* Link's models reflect the projectile weapon he's holding

extracted logic from months-old PR

* apply bow/slingshot model changes only if 'gBowSlingShotAmmoFix' is enabled

* Apply suggestions from code review

Co-authored-by: briaguya <70942617+briaguya-ai@users.noreply.github.com>

* whitespace

---------

Co-authored-by: briaguya <70942617+briaguya-ai@users.noreply.github.com>
2023-02-14 21:14:42 -05:00
Cardboy777 218971c4a9 Option for projectile ammo to match item instead of age (#2453)
* Projectile ammo matches ItemAction instead of age

extracted logic from months-old PR

* Added cvar under "Enhancements -> Gameplay -> Items" for bow/slingshot ammo

* Update GameMenuBar.cpp
2023-02-14 21:14:20 -05:00
Garrett Cox 462ab00c7e Save skipped checks (#2476) 2023-02-14 20:50:59 -05:00
PurpleHato 622d8c4aff TWEAK: Debug Warp Translations errors (#2464)
Volvagia is Vulcania in french (I'm so used to it in English)
and I somehow put the german version of dodongo's cavern in french, oops
2023-02-14 08:56:25 -05:00
PurpleHato 75782e4019 TWEAK: German Rando Navi Hint (Shiek Name) (#2463)
In German Shiek is called Sheik (something related to how they switched letter to conserve the wanted pronunciation of the name)
2023-02-14 08:55:12 -05:00
David Chavez 66b2d2d5fa Add asset headers (#2465) 2023-02-14 08:29:46 -05:00
louist103 8c87bc13db More junk hints. (#2417)
* More junk hints.

* More hints.

* Update soh/soh/Enhancements/randomizer/3drando/hint_list.cpp

Co-authored-by: briaguya <70942617+briaguya-ai@users.noreply.github.com>

* More junk hints.

* More hints.

* Remove a hint.

---------

Co-authored-by: briaguya <70942617+briaguya-ai@users.noreply.github.com>
2023-02-13 22:50:13 -05:00
Adam Bird 67421179e4 Fix: Rando settings not being initialized in time (#2461)
* fix entrance init and entrance tracker not working properly when no spoiler log is loaded

* fix rando adult trade spoilable items reverting when no spoiler log loaded
2023-02-13 02:00:59 -05:00
Adam Bird 1e9f8df33b Fix: Hyrule Field bridge entrance and sun song placing link out of bounds in Entrance Rando (#2457)
* fix market night escape to work with entrance rando; adjust HF bridge spawn to not have link fall in water at night

* use scene enums for ER logic instead of magic nums

* fix sun song loading are with wrong link position with grotto shuffle on

* Update soh/soh/Enhancements/randomizer/randomizer_entrance.c
2023-02-12 23:34:16 -05:00
PurpleHato 8f9dc17752 FIX: Inverted Night and Day in German (#2448) 2023-02-12 17:58:57 -05:00
briaguya df1e26d4cd fix rainbow popping (#2441) 2023-02-08 00:19:48 -05:00
Adam Bird fdf9d51444 update cvar name for n64 mode (#2440) 2023-02-08 00:18:53 -05:00
briaguya 242a35c3a0 bump version (#2434) 2023-02-07 00:04:19 -05:00
Adam Bird f57cae120d Fix: exclude locations not updating and add more location logic (#2428)
* fix location tab not updating and remove hidden excludes during generation

* add more exclude locations and fix broken ones

* update check tracker check visibility

* rename enum

* rename enums again
2023-02-06 20:51:26 -05:00
PurpleHato 177194ca5a ADD: Exit Market at Night to rando preset (#2432) 2023-02-06 17:06:40 -05:00
PurpleHato 3218b2def2 FIX: Song's Overlay with Fast Ocarina Playback (#2431)
* FIX: Affected songs

* TWEAK: Addressed comments
2023-02-06 10:56:40 -05:00
David Chavez 8a76a3aa83 Fix: Hang on exit game and CC is enabled (#2427)
Happens during dev - might affect release, so PRing this.
2023-02-06 11:02:51 +01:00
Ralphie Morell 5771e6cd1f Fix spillover on goron messages (#2425) 2023-02-01 00:12:21 -05:00
aMannus e14fcf92d2 Fix GI overruling link size over anything else (#2424) 2023-01-31 07:21:16 -05:00
aMannus 612700c2ab Change gPauseAnyCursor into combobox (#2423)
* Change gPauseAnyCursor into combobox

* Add enums

* Change naming
2023-01-31 06:53:22 -05:00
Adam Bird 4e08eca1b9 adjust closed forest and starting age settings for edge cases (#2421) 2023-01-30 22:51:41 -05:00
Sirius902 44f963e310 Rumble and check tracker fixes (#2419)
* Fix rumble

* Fix check tracker crash
2023-01-30 12:33:52 -05:00
Sirius902 544460d909 QPA restoration (#2422) 2023-01-30 08:43:30 -05:00
PurpleHato f6c310ae84 TWEAK: Controller Navigation rename + tooltip (#2407)
* TWEAK: Controller Navigation rename + tooltip

* TWEAK: add back FW

* TWEAK: Button size + name

* TWEAK: Tooltip and text position

* TWEAK: added a PaddedSeparator

* TWEAK: Removed the padding from aMannus Request
2023-01-28 12:02:38 -05:00
PurpleHato 9b020c0986 TWEAK: Misspelling "Gold" in German + Box formating (#2416) 2023-01-28 10:51:41 -05:00
lilDavid 3617b2e5b7 Fix chest sizes making contents unobtainable (#2410) 2023-01-28 10:17:47 -05:00
aMannus 72dcf3466b Check tracker fixes (#2414) 2023-01-27 19:16:31 -05:00
Adam Bird 0aab836d1f Fix: Override jail capture for the Gerudo fighter (#2413)
* handle overriding gerudo capture for the fighter

* add entrance include
2023-01-27 18:36:38 -05:00
Garrett Cox 9fe7839f9a Adjustment to gFastFarores tooltip (#2409) 2023-01-27 01:39:35 -05:00
David Chavez 22efba8cd7 Fix: Quit Game (#2403)
* Fix quit implemention in console & window

* Point to latest LUS

* match lus from develop
2023-01-26 20:10:00 -05:00
Adam Bird 1e2b60c6e0 clear cvars that lock up randomizer menu on boot (#2405) 2023-01-26 20:09:33 -05:00
PurpleHato 279553e6b3 TWEAK: Forgot some translation on Debug Warp Screen (#2406) 2023-01-26 20:09:21 -05:00
briaguya 0df5060541 bump lus (#2408) 2023-01-26 19:41:16 -05:00
Kenix3 47f206825d Debug camera (#2400)
* Moves SoH mixer to SoH from LUS.

* Debug camera now works in SoH, but mempak saving does not (yet).

* Debug camera is now enabled/disabled based on the gDebugEnabled cvar.

* Updates OTRGlobals comments

* Updates OTRGlobals comments
2023-01-26 18:43:09 -05:00
Christopher Leggett 569013535e Improves the Block Pushing Speed Enhancement (#2396)
* Increases the actual block pushing speed.

Previously this enhancement only decreased the delay between pushes in any noticeable way because the top speed of the blocks was clamped. The enhancement now increases the top speed of the blocks according to the slider's value.

* Applies previous changes to milk crates.

* Applies same fix to fire temple stone blocks

(I believe these are the ones with the faces on them)

* Applies fixes to Poe painting blocks (forest temple)
2023-01-26 00:58:26 -05:00
Adam Bird 589e25948e Add manual seed input for rando generation (#2057)
* add manual seed input for rando generation

* add tooltip for seed input

* switch to calloc

* add seed testing count generator

* add console command for rando gen

* add boost and custom hash_32 functions

* use hash_32 funcs for rando generation

* limit seed input field to uint32

* rename custom boost header imports to boost_custom
2023-01-25 18:33:27 -05:00
aMannus 170a9103f9 Implement GameInteractor & move CrowdControl and console commands to it (#2358)
* Begin GameInteractor

* Basic skeleton of PoC

* WIP

* First 2 CC effects transitioned to GameInteractor

* Prepare GameInteractor classes for CrowdControl

* More effects & replace chaosEffects with GameInteractor

* CC connection fixes & all CC effects (enemy spawns still borked)

* First couple of build error fixes

* Fix build

* Proper enemy spawning

* Clean up old CC code

* Extract link size/invisibility into GameInteractor

* Small fix/cleanup

* Suggestions for PR

* Address PR comment

* Addressed more comments & small adjustments

* Fix crash when spawning enemies

* Remove Remove()

* Move checks into Apply() and move CC and some console commands to it

* Use inheritance to abstract check on application

* Rename prefix Actions with RawAction

* Make Remove return a Result

* Fix issue with compilation

* debugconsole -> GameInteractionEffects progress

* Add State in GI

* Unify some Effects

* Port more debug console items

* Remove state modifyiers from raw actions

* Port over last raw action / state in console

* Adjust some types

* Consolidate link size modifier effect

* Adjust more types

* Define category strings in CC

* Clean up remaining non defined strings

* Fix bug in timed effects

* Rename old pack

* CC fixes

* Translate GI enum function

* Console cleanup/fixes/consistency

Co-authored-by: David Chavez <david@dcvz.io>
2023-01-25 18:13:33 -05:00
tcpowell ec4cee787c Gameplay Stats Tweaks (#2379)
* persist stat tracker across sessions

* fix tab spaces

* configurable gameplay stats display

* streamline to use AddWindow method
2023-01-25 17:43:50 -05:00
Garrett Cox 7a75fe8411 Add faster farores enhancement (#2394)
* Add faster farores enhancement

* Add preset entry
2023-01-25 17:27:11 -05:00
Ralphie Morell 6d6c1c8c32 Enhancement: Better Farore's Wind (#2374)
* Updated SaveManager, SaveContext;
lifted restriction from gtg and ganon's castle;
disabled clearing fw during master sword lift;
added checkbox

* increment load version (whoops); clear age fw after use

* beef up fw console handler (for testing)

* Simplify better FW (2 copies > 1 copy)

* Apply suggestions

* whoops
2023-01-25 14:32:21 -05:00
Garrett Cox 21ae445548 Add missing trade sequence items from gameplay stats (#2393)
* Add missing trade sequence items from gameplay stats

* Update soh/soh/Enhancements/gameplaystats.cpp
2023-01-24 16:08:38 -05:00
PurpleHato 5c21bb0b8a TWEAK: German mistake (#2392) 2023-01-24 15:39:37 -05:00
briaguya 6b6cfa5ebe rupee name cleanup (#2391)
* fix: add missing comma to fix oob

* bring back some old rupee names, remove some that don't render properly

Co-authored-by: briaguya <briaguya@alice>
2023-01-24 01:11:48 -05:00
Adam Bird 402d7dd3b7 fix wrong flag name for zeldas letter define (#2390) 2023-01-24 00:51:48 -05:00
Garrett Cox 0629140357 Don't require input for credits textboxes (#2193)
* Don't require input for credits textboxes

* Use cvar instead of rando flag
2023-01-23 17:47:54 -05:00
Garrett Cox beb414eb0a Add cheat for extending hookshot reach (#2178)
* Add cheat for extending hookshot reach

* Adjust cvar usage
2023-01-23 17:28:50 -05:00
lilDavid 2422c94f6b Rando: Shuffle 100 Gold Skulltula Reward (#1944)
* Shuffle 100 token reward

* Add 100 token hint

* 100 GS Shuffle: Fix name inconsistency

* Add 10 tokens to plentiful pool

* Ganon's Boss Key on 100 GS Reward

* Golden Skull Token -> Gold Skulltula Token

* Properly disable 100 GS reward shuffle check box

* Use enums for 100 GS shuffle

* Fix mismatched LUS

* Fix CVar calls

* ADD: French translation

* Only add extra tokens in Tokensanity

Co-authored-by: PurpleHato <linkvssangoku.jr@gmail.com>
2023-01-23 17:01:52 -05:00
Garrett Cox e5bc5188e7 Actor view values now using pointers rather than copies, add playerState flags to save editor (#2388) 2023-01-23 16:39:05 -05:00
Garrett Cox eb222f3998 Add enhancement for dog following you everywhere (#2050)
* Add enhancement for dog following you everywhere

* Persist dogParams to save file

* Make doggo float in water

* Wrap change in cvar condition and update cvar usage
2023-01-23 16:22:28 -05:00
Garrett Cox a1cb921042 v1 Dlist Viewer (#2387) 2023-01-23 16:04:37 -05:00
PurpleHato e79bd2587d ADD: Debug Warp Restoration + Translations (#2386)
* Finish translations for Map Select

* First Pass

* TWEAK: Add back Japanese as default to conserve vanilla

* TWEAK: replace some array with structs + some translations

* TWEAK: loading messages [TODO: proper translations]

* TWEAK: forgot to push z64.h for loading messages + translated scene type

* TWEAK: spacing

* TWEAK: comment

* TWEAK: Small german OPT position

* TWEAK: german typo

* TWEAK: translation to cutsceneLabels

* TWEAK: Nabooru's name + Lairs

* TWEAK: Updated Cvar to new way to call them

* ADD: German

* Debug localization

* TWEAK: Age

They are noted as a flag thingy and not a literal age

* Tweak: Frogot the Great Fairy

* TWEAK: adressed comment

Co-authored-by: Amaro Martínez <xoas@airmail.cc>
2023-01-23 15:36:28 -05:00
Adam Bird cb5faa1ac8 fix mido spawn for dungeon entrance rando (#2384) 2023-01-23 14:08:16 -05:00
Adam Bird 37f31116b3 Add reset/randomize all SFX and Cosmetic commands to console (#2378)
* add reset/randomize all commands to debug console for sfx and cosmetic editor

* fix cvar func
2023-01-22 03:51:23 -05:00
AltoXorg 52a976489b implement audio backend fallbacks (#1857)
* audio & rendering backend option greyed out if theres only one

* add audio fallback code

* InitializeAudioPlayer/WindowManager add param

* string -> string_view

* Revert "audio & rendering backend option greyed out if theres only one"

This reverts commit e94a7fff50.

* revert lus changes

* moved fallback function to LUS

* use audioplayerbridge
2023-01-21 18:05:05 -05:00
splemb 643a98244b Enhancement: MM-Style Static Explosion Radius (#2322)
* Adds Static Explosion Radius Enhancement

* Changed default value

* Update libultraship

* Update CVar Syntax

* Revert "Update libultraship"

This reverts commit d0e243565a.
2023-01-21 17:45:43 -05:00
nianjiilical a58705eaf4 Rando: Adds 90~ new random rupee names, alphabetizes them (#2330)
* more rupee names

* typo

* feedback

* more feedback
2023-01-21 17:09:42 -05:00
briaguya a9e7faa180 Full health spawn (#2377)
* full health spawn

Co-authored-by: MoriyaFaith <46070717+MoriyaFaith@users.noreply.github.com>

* add enahancement to gamemenubar, update to use new cvar method names, simplify save loading logic so loading a save with less than 3 hearts spawns with full hearts with enhancement enabled instead of spawing with 3

* formatting

Co-authored-by: MoriyaFaith <46070717+MoriyaFaith@users.noreply.github.com>
2023-01-21 09:36:35 -05:00
aMannus 4291ec8252 Rando - Ganon & Ganondorf cutscene skips (#2321)
* Ganon(dorf) cutscene skips

* Remove leftover code

* Comment out the Ganondorf dying cutscene skip
2023-01-21 07:55:53 -05:00
briaguya 2a9d93dd65 fix: return enum value so mido moves away properly (#2376)
when pulling in documentation i missed a couple returns
this was causing mido to never stop blocking the path to the deku tree
after searchign the codebase, i found two instances of this mistake
this pr fixes them

Co-authored-by: briaguya <briaguya@alice>
2023-01-21 06:31:33 -05:00
David Chavez 33539be458 [CI] Linux Performance Builds (#2323)
* Add linux matrix for performance linux build

* Update README
2023-01-20 22:23:35 -05:00
pancake-byte 6e417713b9 Update BUILDING.md (#2332)
* Update BUILDING.md

Adds a note to be sure to pull in libultraship when building for Windows

* Fix syntax for consistency

* Maybe this is better?

I'm doing great. XD
2023-01-20 22:06:14 -05:00
Christopher Leggett 1b9962dfc2 Enhancement: Adds Slider for Duration of Sequence Names on the Overlay (#2375)
* New function: overlay text duration in seconds.

`Overlay_DisplayText` took a float as an argument, with no clear indication of what that float represented. That float also evaluates to different durations given different frame rates. However, since we know what the frame rate should be at any given time (since it's stored in a CVar) we can calculate what this duration should be based on the number of seconds we want the overlay to be displayed. That's what `Overlay_DisplayText_Seconds` does.

* Adds Slider for Overlay Sequence Name Durations
2023-01-20 21:48:17 -05:00
aMannus 1b9ab52e35 Tweak - Rando freestanding/skulltula ice trap behaviour (#2230)
* Improve skulltula ice traps

* Improve freestanding ice traps

* Merge fix
2023-01-20 21:30:49 -05:00
Adam Bird 261db2c3e1 Rando: Boss Entrance Shuffle (#2194)
* sync 3ds upstream logic changes for boss rooms

* add boss shuffle settings and handling to 3ds code

* add boss shuffle handling to game code

* repair authentically bugged entrances for boss shuffle

* add boss entrances to the entrance tracker

* unset hint area for boss rooms to fix altar hint

* update boss reward hints to not mention dungeons

* one more boss heart container hint fix

* reorder entrance rando funcs

* support closed forest with boss shuffle and simple boss room entrance pairs in shuffle table

* fix death warp in boss rooms without saving; fix KD boss room in tracker

* remove boss shuffle check from dungeon open checks and some cleanups

* add boss shuffle to preset clear

* remove dungeon entry exit connection from boss rooms

* another no hint fix for boss shuffle

* undo change for exact location hints

* clarify comments
2023-01-20 01:00:12 -05:00
Ralphie Morell 7964bde063 Rando: Misc. Hints (#1947)
* Added too much

* Added 3d settings and brought over to soh

* fixed conditionals for replacing LA hint

* whoops

* Finshed making settings consistent; minor text edit

* fix leftovers from adding warp hints

* more fixes from merge

* fix skull hint messages

* Added fire temple goron junk hints; menu stuff

* Address feedback

* Added optional scrub text

* whoops

* Add hint cvars to clear preset func

* whoops again

* whoops the third

* ADD: French Pass

* FIXED: Dampe + Skull Reward

* TWEAK: German skulltula hint

* TWEAK: French oopsie

* Address feedback

* whoops

* remove "staticness" from altar/ganon text funcs

* ADD: German

* actually add warp song hints to things;
always generate ganon hint and let OTRGlobals handle showing it

* Fix CVar Getters

* whoops

* for real this time

* Actually implemented scrub text in 3d rando

Co-authored-by: PurpleHato <linkvssangoku.jr@gmail.com>
2023-01-19 23:45:34 -05:00
Christopher Leggett 1e178c4497 Bugfix: Update LUS submodule to fix Matrix crash. (#2373) 2023-01-19 21:55:19 -05:00
Patrick12115 c0ad43e509 Add Starting Songs Option (#2221) 2023-01-19 04:54:29 -05:00
th-2021 d6dbaacb03 add OPTIONAL flag to avaid error when OTRGui is not build (#2299) 2023-01-19 04:47:21 -05:00
briaguya d9662ab63b fix: update cvar usage from merge 2023-01-19 04:33:07 -05:00
briaguya 52b182d4dc Merge pull request #2371 from HarbourMasters/develop-bradley
brad -> dev
2023-01-19 04:31:34 -05:00
Christopher Leggett 12737143c7 Adds option to add higher pitches to silver rupee jingle (#2246)
* Adds option to add higher pitches to silver rupee jingle.

Some rooms in Master Quest had 10 silver rupees, but the game was programmed to only play the jingle 5 times and then just went silent for the rest. This option adds 5 more transposition values to the array, and an option to play them (so that authentic behavior is preserved by default).

* Adds the new option to Vanilla Plus preset and up

Also adds it to the list to be reset back to 0 when applying the default preset.

* Changes display name of checkbox.

* Change CVar_GetS32 to CVarGetInteger
2023-01-19 04:10:47 -05:00
Christopher Leggett a335aba987 Adds option for showing sequence names on the overlay (#2237)
* Adds option for showing sequence names on the overlay

Allows sequences to appear on the overlay in the bottom right corner for a few seconds whenever a new one is loaded into the primary sequence player. This means it does not apply to fanfares or enemy bgm. Fanfares I chose not to display because it would cause a lot of text to display back to back in some areas, and enemy bgm would have some technical challenges with this due to the way it loads. Mainly because the Lost Woods music would load in Goron City the same way (as well as the opposite).

* Fixes crash when a sequence without a name is attempted to be displayed.

* Removes accidentally committed CMakeSettings.json

* Updates CVar_GetS32 to CVarGetInteger
2023-01-19 03:50:50 -05:00
Christopher Leggett edceb2d460 Adds lock/unlock all buttons to Cosmetics Editor. (#2225)
* Adds lock/unlock all buttons to Cosmetics Editor.

Adds Lock All and Unlock All, which locks all visible cosmetics options (i.e. does not lock the advanced options if Advanced isn't checked, just like the existing randomize all buttons), and a Lock All Advanced and Unlock All Advanced button that is only visible while the Advanced Options are enabled.

* Updates latest develop and CVar API Changes.
2023-01-19 03:32:05 -05:00
briaguya 7c8be2153c documentation: use NpcInteractInfo from zret (#2370) 2023-01-19 02:38:04 -05:00
David Chavez 32ad0ab4b8 Bump version 2023-01-18 19:21:38 +01:00
aMannus a5f7478b99 Fix CC connection bugs (#2367) 2023-01-18 16:56:32 +01:00
briaguya 207d38e476 bradley -> dev #2365 2023-01-18 01:43:46 -05:00
briaguya c36e9cc32d Merge remote-tracking branch 'origin/develop-bradley' into bradmerge 2023-01-18 01:21:18 -05:00
briaguya 745444fa90 update LUS submodule (#2363) 2023-01-18 01:15:54 -05:00
briaguya 750ae907c2 sdl windowed fullscreen (#2351) 2023-01-17 22:14:45 -05:00
Kenix3 2e4a19c0ee Moves SoH mixer to SoH from LUS. (#2361) 2023-01-17 22:03:55 -05:00
briaguya f665326a67 workaround for vanilla save check tracker crash (#2359)
Co-authored-by: briaguya <briaguya@alice>
2023-01-17 21:40:02 -05:00
briaguya 418d0f8e6c fix: default cvar values before applying presets (#2357) 2023-01-17 17:57:02 -05:00
UltraHDR 13b8f26435 Set LSApplicationCategoryType to games 2023-01-17 17:19:35 -05:00
AltoXorg ba5d5c25d1 changes to the asset extraction script (#2068)
- fixes exiting with Ctrl+C on linux
- chooseROM returns Z64Rom object in addition to speed
- adds simple verbosity for inspecting roms
2023-01-17 17:05:24 -05:00
briaguya 6be1f28d7b brad -> dev 2023-01-17 16:45:59 -05:00
briaguya 15a6568607 Merge branch 'develop' into bradmerge 2023-01-17 16:44:46 -05:00
briaguya 1fe862515d fix top left dungeon entrance icon in graveyard (#2303)
Co-authored-by: briaguya <briaguya>
2023-01-17 15:42:09 -05:00
Adam Bird 6eef813e5d fix wrong entrances in epona check handler (#2352) 2023-01-17 15:20:21 -05:00
Adam Bird 76c9895432 add missing medigoron hint text (#2339) 2023-01-17 15:19:22 -05:00
Adam Bird 048207eb7d Fix exiting courtyard at night not taking link to castle grounds in dungeon entrance randomizer (#2316) 2023-01-17 15:18:59 -05:00
Amaro Martínez 170b9c1224 Disable BEL char by default when terminal attached (#2306) 2023-01-17 15:18:13 -05:00
Adam Bird 1e7cf8858f fix one-way entrances making some entrances disappear from the overrides (#2318) 2023-01-17 21:07:58 +01:00
Adam Bird 4b10a887a6 Fix: Remove MQ Spirit Temple silver block for child to guarantee access to the chest (#2342) 2023-01-17 21:05:19 +01:00
Adam Bird ff3548a1b6 Rando: Adjust locked door logic for temples and give starting keys for MQ Spirit (#2343) 2023-01-17 21:03:08 +01:00
Adam Bird fda198db76 Fix: Reset waterbox collisions in Lake Hylia and Morphas room (#2346) 2023-01-17 21:01:45 +01:00
Andrew Van Caem 7f06087cef Altered save flag docs concerning events in Mido's house (#2311) 2023-01-17 14:46:42 -05:00
Garrett Cox 6ae28273d1 Fix Ganon Boss Key for MQ only otrs (#2295) 2023-01-17 14:23:00 -05:00
Amaro Martínez 5b2a50cac2 Remove repeated preset entries (#2294) 2023-01-17 14:01:45 -05:00
briaguya 1e258318a1 fix: properly randomize mirror shield and silver gaunts chests when using only an mq otr (#2291) 2023-01-17 13:17:00 -05:00
PurpleHato 156de816fb FIX: Equip now message (#2286) 2023-01-17 12:40:05 -05:00
briaguya ba13e6b2c4 refactor: use LUS 1.0 RC
Co-authored-by: kenix3 <kenixwhisperwind@gmail.com>
Co-authored-by: David Chavez <david@dcvz.io>
Co-authored-by: KiritoDv <kiritodev01@gmail.com>
Co-authored-by: Christopher Leggett <chris@leggett.dev>
2023-01-17 00:33:56 -05:00
briaguya ecb10e6ac2 chore: bump sdl version in appimage (#2288)
Co-authored-by: briaguya <briaguya@alice>
2022-12-27 19:33:40 -05:00
briaguya ab104623a7 Merge pull request #2233 from HarbourMasters/develop-bradley
bradley -> dev
2022-12-27 16:47:49 -05:00
briaguya f42f86e3ef fix: make fisherman rumble text work (#2279)
we weren't correctly setting the pakType in padMgr because
the depreciated `gRumbleEnabled` cvar was being checked
2022-12-26 06:37:40 -05:00
briaguya 85bccab1bb bump lus version (#2269)
* bump lus version

* Fixed StringHelper issues caused by the latest lus version

Co-authored-by: KiritoDv <kiritodev01@gmail.com>
2022-12-24 17:49:54 -05:00
briaguya 7768869251 bump version 2022-12-24 00:58:15 -05:00
briaguya 013244560e hi mom (#2261)
Co-authored-by: aMannus <mannusmenting@gmail.com>
2022-12-24 00:45:02 -05:00
Adam Bird 9529cc1217 SFX: Support replaying the current BGM when changed (#2150)
* add support for reloading the current bgm when changing it in the sfx editor

* clarify audio command with comment

* fix wrong seq type after merge
2022-12-23 23:50:39 -05:00
briaguya 0017bf1fcc fix: correct item ordering in kak potion shop (#2256)
Co-authored-by: briaguya <briaguya>
2022-12-23 22:27:19 -05:00
aMannus f6a7f3d13c Fix enemy rando flags (#2253) 2022-12-23 22:27:01 -05:00
aMannus 99367ebb53 Fix silver rupee room in GtG (#2252) 2022-12-23 22:26:26 -05:00
Adam Bird d215c76eba fix shopsanity spawning objects for actors (#2247) 2022-12-23 22:26:01 -05:00
aMannus 07bae6b84c Fix common enemy rando crashes (#2242) 2022-12-23 22:25:38 -05:00
briaguya 6eaf51c2bd version bump (#2232) 2022-12-21 14:11:19 -05:00
aMannus 565775a3dc Fix ice trap particles (#2229) 2022-12-21 11:14:00 -05:00
aMannus 9eb190e734 Fix particle regression (#2228) 2022-12-21 10:40:23 -05:00
briaguya 5ce4e75bd2 Merge pull request #2227 from HarbourMasters/develop-bradley
bradley -> dev
2022-12-21 03:46:12 -05:00
Garrett Cox 0e7a89d117 Fix crash on mac with custom sequences (#2226) 2022-12-21 03:04:11 -05:00
briaguya 73873a6dbc fix: no longer leak memory, invalidate textures properly (#2223)
* Revert "Fix Ganondorf boss battle ending (MQ only) (#2072)"

This reverts commit 52b896271c.

* yolo this should work

* finish comment

* see if this doesn't lag switches!

* formatting

* formatting

Co-authored-by: briaguya <briaguya@alice>
2022-12-21 01:26:13 -05:00
aMannus e03ef85f3b Enemy Rando Hyrule Field crash hotfix (#2222) 2022-12-21 01:03:05 -05:00
Christopher Leggett 8c8111c7b8 Small improvement to sfx randomize button. (#2219)
Should result in less allocations.
2022-12-21 00:31:51 -05:00
GaryOderNichts 1a10d8f627 Fix AdpcmBook allocations (#2214) 2022-12-21 00:15:05 -05:00
aMannus a1a6c07549 Rando - Fix ice traps & get item logic (#2210)
* Fix ice traps & get item logic

* Fix shop keepers & more draw logic cleanup
2022-12-20 23:32:01 -05:00
Adam Bird 6f7361e1a4 only save authentic sequence cvars (#2216) 2022-12-20 17:09:12 -05:00
Garrett Cox 95f1ba7202 Fix cosmetic oob hacks (#2211) 2022-12-20 16:21:00 -05:00
GaryOderNichts 4eee417520 WiiU: Don't invalidate tex cache for dodongo (#2220) 2022-12-20 15:52:13 -05:00
GaryOderNichts 0f3c2d7c78 Fix gfx patching on 32-bit platforms (#2213) 2022-12-20 14:19:25 -05:00
louist103 4d8c70fb1f git subrepo push ZAPDTR
subrepo:
  subdir:   "ZAPDTR"
  merged:   "e23b125d8"
upstream:
  origin:   "https://github.com/HarbourMasters/ZAPDTR.git"
  branch:   "master"
  commit:   "e23b125d8"
git-subrepo:
  version:  "0.4.3"
  origin:   "???"
  commit:   "???"
2022-12-20 02:54:33 +01:00
aMannus 17b1a8e7fd [CI] Support for Windows runners + update docs (#2192) 2022-12-19 13:58:22 +01:00
briaguya a95b1067b4 Merge pull request #2207 from HarbourMasters/develop-bradley
bradley -> dev
2022-12-19 05:31:43 -05:00
Christopher Leggett 56ac27b8f4 Fixes crash during randomization of individual sound effects. (#2203)
* Fixes randomization of individual sound effects.

* Re-adds the mistakenly removed const specifier.

* Implements new randomization syntax that actually fixes the crash.

* Increases default width of sfx editor menu.

The default width was cutting off a lot of the text in the dropdowns due to the added Randomize button.
2022-12-19 05:12:36 -05:00
PurpleHato 4999df5395 TWEAK: Rando Text (French / German) (#2204)
* TWEAK: Some Rando Text

French and German tweaks (German made by Timmy_GamerNepgear on Discord)

Tweak: water control level style to fits Navi's style textboxes

* TWEAK: %c instead of %w
2022-12-18 21:07:05 -05:00
Adam Bird 51f3e37010 fix medi goron not selling randomized item and continuously selling knifes (#2206) 2022-12-18 20:07:35 -05:00
Adam Bird c4b077d83b fix warp song hints not being set if gossip stones are turned off (#2197) 2022-12-17 20:06:23 -05:00
Garrett Cox be38b41644 [#361] Fix ganon boss offset on retail rom (#2190) 2022-12-17 19:51:52 -05:00
Garrett Cox d3f2da2a8f [#1803] Fix hookshot target offset on retail rom (#2189) 2022-12-17 19:21:00 -05:00
KiritoDev 166a6691fc Fixed nintendo switch debug flags (#2202) 2022-12-17 19:08:32 -05:00
briaguya a6120811d5 bradley -> dev #2187 2022-12-14 01:33:30 -05:00
briaguya a05bc1e29f bump version (#2185)
Co-authored-by: briaguya <briaguya@alice>
2022-12-13 23:48:54 -05:00
briaguya 2720292b08 bump lus verison (#2184)
Co-authored-by: briaguya <briaguya@alice>
2022-12-13 23:47:12 -05:00
Christopher Leggett 8a69f1f020 Fixes receiving the wrong item when picking up ammo drops near a chest. (#2183)
* Fixes receiving the wrong item when picking up ammo drops near a chest.

Still shows the wrong model above links head but does give the right
item and shows the right text.

* Fixes get item model during first time pickup anim near chest.
2022-12-13 23:27:51 -05:00
briaguya e71583d47c fix: populate merchant prices table with expensive scrub prices (#2181)
* fix: populate merchant prices with vanilla scrub prices

* temporary expensive scrub workaround

Co-authored-by: briaguya <briaguya@alice>
2022-12-13 21:57:59 -05:00
Garrett Cox 5965cdb193 Fix save compatibility issue from renames (#2177)
* Revert json key changes in save v1 and v2

* Introduce save v3

* Add workaround for breaking save compatibility in 5.1.0

* Handle scarecrow long song a bit differently since the array is never empty
2022-12-13 19:18:18 -05:00
Christopher Leggett 7718e74d73 Always use authentic cache policy for replaced seqs (#2176) 2022-12-13 14:55:00 -05:00
2640 changed files with 163487 additions and 11702 deletions
+27
View File
@@ -0,0 +1,27 @@
FROM mcr.microsoft.com/devcontainers/cpp:ubuntu-22.04
RUN apt-get update && apt-get install -y libsdl2-dev libsdl2-net-dev libpng-dev libglew-dev ninja-build
# Install latest SDL2
RUN wget https://www.libsdl.org/release/SDL2-2.26.1.tar.gz && \
tar -xzf SDL2-2.26.1.tar.gz && \
cd SDL2-2.26.1 && \
./configure && \
make && \
make install && \
cd .. && \
rm -rf SDL2-2.26.1 && \
rm SDL2-2.26.1.tar.gz && \
cp -av /usr/local/lib/libSDL* /lib/x86_64-linux-gnu/
# Install latest SDL2_net
RUN wget https://www.libsdl.org/projects/SDL_net/release/SDL2_net-2.2.0.tar.gz && \
tar -xzf SDL2_net-2.2.0.tar.gz && \
cd SDL2_net-2.2.0 && \
./configure && \
make && \
make install && \
cd .. && \
rm -rf SDL2_net-2.2.0 && \
rm SDL2_net-2.2.0.tar.gz && \
cp -av /usr/local/lib/libSDL* /lib/x86_64-linux-gnu/
+29
View File
@@ -0,0 +1,29 @@
// For format details, see https://aka.ms/devcontainer.json. For config options, see the
// README at: https://github.com/devcontainers/templates/tree/main/src/cpp
{
"name": "SoH",
"build": {
"dockerfile": "Dockerfile"
},
// Features to add to the dev container. More info: https://containers.dev/features.
// "features": {},
// Configure tool-specific properties.
"customizations": {
// Configure properties specific to VS Code.
"vscode": {
"settings": {},
"extensions": []
}
}
// Use 'forwardPorts' to make a list of ports inside the container available locally.
// "forwardPorts": [],
// Use 'postCreateCommand' to run commands after the container is created.
// "postCreateCommand": "gcc -v",
// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
// "remoteUser": "root"
}
+18 -60
View File
@@ -6,25 +6,7 @@ concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
jobs:
extract-assets:
runs-on: [ self-hosted, asset-builder ]
steps:
- uses: actions/checkout@v3
with:
submodules: true
- name: Extract assets
run: |
cp ../../../ZELOOTD.z64 OTRExporter/baserom_non_mq.z64
cmake --no-warn-unused-cli -H. -Bbuild-cmake -GNinja -DCMAKE_BUILD_TYPE:STRING=Release
cmake --build build-cmake --target ExtractAssets --config Release
zip -r assets.zip soh/assets
- uses: actions/upload-artifact@v3
with:
name: assets
path: assets.zip
retention-days: 1
build-macos:
needs: extract-assets
runs-on: macos-12
steps:
- uses: actions/checkout@v3
@@ -61,14 +43,8 @@ jobs:
brew uninstall --ignore-dependencies libpng
sudo port install $(cat .github/workflows/macports-deps.txt)
brew install ninja
- name: Restore assets
uses: actions/download-artifact@v3
with:
name: assets
- name: Build SoH
run: |
unzip -o assets.zip
export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
cmake --no-warn-unused-cli -H. -Bbuild-cmake -GNinja -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_OSX_ARCHITECTURES="x86_64;arm64"
cmake --build build-cmake --config Release --parallel 10
@@ -84,8 +60,17 @@ jobs:
SoH.dmg
readme.txt
build-linux:
needs: extract-assets
runs-on: ubuntu-20.04
strategy:
fail-fast: true
matrix:
include:
- os: ubuntu-20.04
gcc: 10
archive-suffix: compatibility
- os: ubuntu-22.04
gcc: 12
archive-suffix: performance
runs-on: ${{ matrix.os }}
steps:
- uses: actions/checkout@v3
with:
@@ -97,13 +82,13 @@ jobs:
- name: ccache
uses: hendrikmuhs/ccache-action@v1.2
with:
key: ${{ runner.os }}-ccache
key: ${{ matrix.os }}-ccache
- name: Install latest SDL
run: |
export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
wget https://www.libsdl.org/release/SDL2-2.24.1.tar.gz
tar -xzf SDL2-2.24.1.tar.gz
cd SDL2-2.24.1
wget https://www.libsdl.org/release/SDL2-2.26.1.tar.gz
tar -xzf SDL2-2.26.1.tar.gz
cd SDL2-2.26.1
./configure
make -j 10
sudo make install
@@ -118,14 +103,8 @@ jobs:
make -j 10
sudo make install
sudo cp -av /usr/local/lib/libSDL* /lib/x86_64-linux-gnu/
- name: Restore assets
uses: actions/download-artifact@v3
with:
name: assets
- name: Build SoH
run: |
unzip -o assets.zip
export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
cmake --no-warn-unused-cli -H. -Bbuild-cmake -GNinja -DCMAKE_BUILD_TYPE:STRING=Release
cmake --build build-cmake --target OTRGui -j3
@@ -135,17 +114,16 @@ jobs:
mv README.md readme.txt
mv build-cmake/*.appimage soh.appimage
env:
CC: gcc-10
CXX: g++-10
CC: gcc-${{ matrix.gcc }}
CXX: g++-${{ matrix.gcc }}
- name: Upload build
uses: actions/upload-artifact@v3
with:
name: soh-linux
name: soh-linux-${{ matrix.archive-suffix }}
path: |
soh.appimage
readme.txt
build-switch:
needs: extract-assets
runs-on: ubuntu-latest
container:
image: devkitpro/devkita64:latest
@@ -161,14 +139,8 @@ jobs:
uses: hendrikmuhs/ccache-action@v1.2
with:
key: ${{ runner.os }}-switch-ccache
- name: Restore assets
uses: actions/download-artifact@v3
with:
name: assets
- name: Build SoH
run: |
unzip -o assets.zip
cmake -H. -Bbuild-switch -GNinja -DCMAKE_TOOLCHAIN_FILE=/opt/devkitpro/cmake/Switch.cmake -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_C_COMPILER_LAUNCHER=ccache
cmake --build build-switch --target soh_nro -j3
@@ -182,7 +154,6 @@ jobs:
soh.nro
readme.txt
build-wiiu:
needs: extract-assets
runs-on: ubuntu-latest
container:
image: devkitpro/devkitppc:latest
@@ -198,14 +169,8 @@ jobs:
uses: hendrikmuhs/ccache-action@v1.2
with:
key: ${{ runner.os }}-wiiu-ccache
- name: Restore assets
uses: actions/download-artifact@v3
with:
name: assets
- name: Build SoH
run: |
unzip -o assets.zip
cmake -H. -Bbuild-wiiu -GNinja -DCMAKE_TOOLCHAIN_FILE=/opt/devkitpro/cmake/WiiU.cmake -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_C_COMPILER_LAUNCHER=ccache
cmake --build build-wiiu --target soh_wuhb --config Release -j3
@@ -224,7 +189,6 @@ jobs:
soh.wuhb
readme.txt
build-windows:
needs: extract-assets
runs-on: windows-latest
steps:
- name: Install dependencies
@@ -238,18 +202,12 @@ jobs:
uses: dcvz/ccache-action@27b9f33213c0079872f064f6b6ba0233dfa16ba2
with:
key: ${{ runner.os }}-ccache
- name: Restore assets
uses: actions/download-artifact@v3
with:
name: assets
- uses: ilammy/msvc-dev-cmd@v1
- name: Setup 7-Zip
run: |
"C:\Program Files\7-Zip" >> $env:GITHUB_PATH
- name: Build SoH
run: |
7z x assets.zip -aoa
set $env:PATH="$env:USERPROFILE/.cargo/bin;$env:PATH"
cmake -S . -B build-windows -G Ninja -DCMAKE_MAKE_PROGRAM=ninja -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
cmake --build build-windows --target OTRGui --config Release --parallel 10
+16 -1
View File
@@ -22,6 +22,9 @@ You can also find the v142 toolset by searching through the individual component
While you're there, you can also install Python 3 and Git if needed.
1. Clone the Ship of Harkinian repository
_Note: Be sure to either clone with the ``--recursive`` flag or do ``git submodule init`` after cloning to pull in the libultraship submodule!_
2. Place one or more [compatible](#compatible-roms) roms in the `OTRExporter` directory with namings of your choice
_Note: Instructions assume using powershell_
@@ -90,7 +93,7 @@ git submodule update --init
# Copy the baserom to the OTRExporter folder
cp <path to your ROM> OTRExporter
# Generate Ninja project
cmake -H. -Bbuild-cmake -GNinja # -DCMAKE_BUILD_TYPE:STRING=Release (if you're packaging)
cmake -H. -Bbuild-cmake -GNinja # -DCMAKE_BUILD_TYPE:STRING=Release (if you're packaging) -DPython3_EXECUTABLE=$(which python3) (if you are using non-standard Python installations such as PyEnv)
# Extract assets & generate OTR (run this anytime you need to regenerate OTR)
cmake --build build-cmake --target ExtractAssets
# Compile the project
@@ -215,3 +218,15 @@ Use the `extract_assets.py` script file to run the exporter using any of the fol
4) In a terminal run `python3 extract_assets.py <path_to_rom>`
If the script finds multiple roms the user is prompted which to use. Selection is done using the number keys and then pressing the carriage return key.
## Getting CI to work on your fork
The CI works via [Github Actions](https://github.com/features/actions) where we mostly make use of machines hosted by Github; except for the very first step of the CI process called "Extract assets". This steps extracts assets from the game file and generates an "assets" folder in `soh/`.
To get this step working on your fork, you'll need to add a machine to your own repository as a self-hosted runner via "Settings > Actions > Runners" in your repository settings. Make sure to add the 'asset-builder' tag to your newly added runner to assign it to run this step. To setup your runner as a service read the docs [here](https://docs.github.com/en/actions/hosting-your-own-runners/configuring-the-self-hosted-runner-application-as-a-service?platform=linux).
### Runner on Windows
You'll have to enable the ability to run unsigned scripts through PowerShell. To do this, open Powershell as administrator and run `set-executionpolicy remotesigned`. Most dependencies get installed as part of the CI process. You will also need to seperately install 7z and add it to the PATH so `7z` can be run as a command. [Chocolatey](https://chocolatey.org/) or other package managers can be used to install it easily.
### Runner on UNIX systems
If you're on macOS or Linux take a look at `macports-deps.txt` or `apt-deps.txt` to see the dependencies expected to be on your machine.
+5 -7
View File
@@ -2,13 +2,11 @@ cmake_minimum_required(VERSION 3.16.0 FATAL_ERROR)
set(CMAKE_SYSTEM_VERSION 10.0 CACHE STRING "" FORCE)
set(CMAKE_CXX_STANDARD 20 CACHE STRING "The C++ standard to use")
#set(CMAKE_C_STANDARD 11 CACHE STRING "The C standard to use") - issue with soh compile with MSVC
set(CMAKE_OSX_DEPLOYMENT_TARGET "10.15" CACHE STRING "Minimum OS X deployment version" FORCE)
project(Ship LANGUAGES C CXX
VERSION 5.1.0)
set(PROJECT_BUILD_NAME "BRADLEY ALFA" CACHE STRING "")
project(Ship VERSION 6.1.1 LANGUAGES C CXX)
set(PROJECT_BUILD_NAME "KHAN BRAVO" CACHE STRING "")
set(PROJECT_TEAM "github.com/harbourmasters" CACHE STRING "")
set_property(DIRECTORY ${CMAKE_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT soh)
@@ -49,8 +47,8 @@ endif()
# Global configuration types
################################################################################
if (CMAKE_SYSTEM_NAME STREQUAL "NintendoSwitch")
set(CMAKE_C_FLAGS_DEBUG "-O3 -ffast-math")
set(CMAKE_CXX_FLAGS_DEBUG "-O3 -ffast-math")
set(CMAKE_C_FLAGS_DEBUG "-g -ffast-math -DDEBUG")
set(CMAKE_CXX_FLAGS_DEBUG "-g -ffast-math -DDEBUG")
set(CMAKE_C_FLAGS_RELEASE "-O3 -ffast-math -DNDEBUG")
set(CMAKE_CXX_FLAGS_RELEASE "-O3 -ffast-math -DNDEBUG")
else()
@@ -92,7 +90,7 @@ add_subdirectory(libultraship ${CMAKE_BINARY_DIR}/libultraship)
add_subdirectory(ZAPDTR/ZAPD ${CMAKE_BINARY_DIR}/ZAPD)
add_subdirectory(OTRExporter)
add_subdirectory(soh)
if(NOT CMAKE_SYSTEM_NAME MATCHES "Darwin|NintendoSwitch|CafeOS")
if(CMAKE_SYSTEM_NAME MATCHES "Windows|Linux")
add_subdirectory(OTRGui)
endif()
@@ -1,11 +1,11 @@
#include "AnimationExporter.h"
#include <Animation.h>
#include <resource/type/Animation.h>
void OTRExporter_Animation::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
{
ZAnimation* anim = (ZAnimation*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::Animation);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Animation);
ZNormalAnimation* normalAnim = dynamic_cast<ZNormalAnimation*>(anim);
ZCurveAnimation* curveAnim = dynamic_cast<ZCurveAnimation*>(anim);
+4 -5
View File
@@ -1,6 +1,5 @@
#include "AudioExporter.h"
#include "Main.h"
#include <Animation.h>
#include <Utils/MemoryStream.h>
#include <Globals.h>
#include <Utils/File.h>
@@ -30,7 +29,7 @@ void OTRExporter_Audio::WriteSampleEntryReference(ZAudio* audio, SampleEntry* en
void OTRExporter_Audio::WriteSampleEntry(SampleEntry* entry, BinaryWriter* writer)
{
WriteHeader(nullptr, "", writer, Ship::ResourceType::AudioSample, Ship::Version::Rachael);
WriteHeader(nullptr, "", writer, Ship::ResourceType::SOH_AudioSample, Ship::Version::Rachael);
writer->Write(entry->codec);
writer->Write(entry->medium);
@@ -82,7 +81,7 @@ void OTRExporter_Audio::Save(ZResource* res, const fs::path& outPath, BinaryWrit
{
ZAudio* audio = (ZAudio*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::Audio, Ship::Version::Rachael);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Audio, Ship::Version::Rachael);
// Write Samples as individual files
for (auto pair : audio->samples)
@@ -115,7 +114,7 @@ void OTRExporter_Audio::Save(ZResource* res, const fs::path& outPath, BinaryWrit
MemoryStream* fntStream = new MemoryStream();
BinaryWriter fntWriter = BinaryWriter(fntStream);
WriteHeader(nullptr, "", &fntWriter, Ship::ResourceType::AudioSoundFont, Ship::Version::Rachael);
WriteHeader(nullptr, "", &fntWriter, Ship::ResourceType::SOH_AudioSoundFont, Ship::Version::Rachael);
fntWriter.Write((uint32_t)i);
fntWriter.Write(audio->soundFontTable[i].medium);
@@ -174,7 +173,7 @@ void OTRExporter_Audio::Save(ZResource* res, const fs::path& outPath, BinaryWrit
MemoryStream* seqStream = new MemoryStream();
BinaryWriter seqWriter = BinaryWriter(seqStream);
WriteHeader(nullptr, "", &seqWriter, Ship::ResourceType::AudioSequence, Ship::Version::Rachael);
WriteHeader(nullptr, "", &seqWriter, Ship::ResourceType::SOH_AudioSequence, Ship::Version::Rachael);
seqWriter.Write((uint32_t)seq.size());
seqWriter.Write(seq.data(), seq.size());
@@ -4,6 +4,10 @@
void OTRExporter_Background::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
{
ZBackground* bg = (ZBackground*)res;
WriteHeader(bg, outPath, writer, Ship::ResourceType::SOH_Background);
writer->Write((uint32_t)bg->GetRawDataSize());
auto data = bg->parent->GetRawData();
writer->Write((char*)data.data() + bg->GetRawDataIndex(), bg->GetRawDataSize());
+10 -7
View File
@@ -158,16 +158,19 @@ endif()
target_include_directories(${PROJECT_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/../../ZAPDTR/ZAPD/
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/ZAPDUtils
${CMAKE_CURRENT_SOURCE_DIR}/../../ZAPDTR/lib/tinyxml2
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/include
# TODO: these should no longer be necessary if we were to link against LUS
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src/resource
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src/resource/types
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/spdlog/include
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src/graphic/Fast3D/U64
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/Mercury
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/tinyxml2
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/ZAPDUtils
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/StormLib/src
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/spdlog/include
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/nlohmann-json/include
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src/resource
${CMAKE_CURRENT_SOURCE_DIR}/../../soh/soh
.
)
@@ -1,11 +1,11 @@
#include "CollisionExporter.h"
#include <Resource.h>
#include <libultraship/bridge.h>
void OTRExporter_Collision::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
{
ZCollisionHeader* col = (ZCollisionHeader*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::CollisionHeader);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_CollisionHeader);
writer->Write(col->absMinX);
writer->Write(col->absMinY);
+2 -2
View File
@@ -1,11 +1,11 @@
#include "CutsceneExporter.h"
#include <Resource.h>
#include <libultraship/bridge.h>
void OTRExporter_Cutscene::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
{
ZCutscene* cs = (ZCutscene*)res;
WriteHeader(cs, outPath, writer, Ship::ResourceType::Cutscene);
WriteHeader(cs, outPath, writer, Ship::ResourceType::SOH_Cutscene);
//writer->Write((uint32_t)cs->commands.size() + 2 + 2);
writer->Write((uint32_t)0);
@@ -5,7 +5,7 @@
#include <Utils/BitConverter.h>
#include "StrHash64/StrHash64.h"
#include "spdlog/spdlog.h"
#include "PR/ultra64/gbi.h"
#include <libultraship/libultra/gbi.h>
#include <Globals.h>
#include <iostream>
#include <string>
+1 -1
View File
@@ -3,7 +3,7 @@
#include "ZArray.h"
//#include "OTRExporter.h"
#include <Utils/BinaryWriter.h>
#include <Resource.h>
#include <libultraship/bridge.h>
#include "VersionInfo.h"
class OTRExporter : public ZResourceExporter
+2 -1
View File
@@ -1,4 +1,4 @@
#include <Archive.h>
#include "Main.h"
#include "BackgroundExporter.h"
#include "TextureExporter.h"
#include "RoomExporter.h"
@@ -22,6 +22,7 @@
#include <Utils/MemoryStream.h>
#include <Utils/BinaryWriter.h>
#include <bit>
#include <mutex>
std::string otrFileName = "oot.otr";
std::shared_ptr<Ship::Archive> otrArchive;
+1 -1
View File
@@ -1,6 +1,6 @@
#pragma once
#include <Archive.h>
#include <libultraship/bridge.h>
extern std::shared_ptr<Ship::Archive> otrArchive;
extern std::map<std::string, std::vector<char>> files;
+1 -1
View File
@@ -5,7 +5,7 @@ void OTRExporter_Path::Save(ZResource* res, const fs::path& outPath, BinaryWrite
{
ZPath* path = (ZPath*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::Path);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Path);
writer->Write((uint32_t)path->pathways.size());
@@ -1,11 +1,11 @@
#include "PlayerAnimationExporter.h"
#include <Resource.h>
#include <libultraship/bridge.h>
void OTRExporter_PlayerAnimationExporter::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
{
ZPlayerAnimationData* anim = (ZPlayerAnimationData*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::PlayerAnimation);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_PlayerAnimation);
auto start = std::chrono::steady_clock::now();
+2 -2
View File
@@ -23,7 +23,7 @@
#include <ZRoom/Commands/SetAlternateHeaders.h>
#include "CollisionExporter.h"
#include "DisplayListExporter.h"
#include "Resource.h"
#include <libultraship/bridge.h>
#include <Globals.h>
#include <ZRoom/Commands/SetExitList.h>
#include <ZRoom/Commands/SetPathways.h>
@@ -39,7 +39,7 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
{
ZRoom* room = (ZRoom*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::Room);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Room);
writer->Write((uint32_t)room->commands.size());
+2 -2
View File
@@ -1,5 +1,5 @@
#include "SkeletonExporter.h"
#include <Resource.h>
#include <libultraship/bridge.h>
#include <Globals.h>
#include "DisplayListExporter.h"
@@ -7,7 +7,7 @@ void OTRExporter_Skeleton::Save(ZResource* res, const fs::path& outPath, BinaryW
{
ZSkeleton* skel = (ZSkeleton*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::Skeleton);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Skeleton);
writer->Write((uint8_t)skel->type);
writer->Write((uint8_t)skel->limbType);
@@ -1,13 +1,13 @@
#include "SkeletonLimbExporter.h"
#include "DisplayListExporter.h"
#include <Resource.h>
#include <libultraship/bridge.h>
#include <Globals.h>
void OTRExporter_SkeletonLimb::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
{
ZLimb* limb = (ZLimb*)res;
WriteHeader(res, outPath, writer, Ship::ResourceType::SkeletonLimb);
WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_SkeletonLimb);
writer->Write((uint8_t)limb->type);
writer->Write((uint8_t)limb->skinSegmentType);
+1 -1
View File
@@ -5,7 +5,7 @@ void OTRExporter_Text::Save(ZResource* res, const fs::path& outPath, BinaryWrite
{
ZText* txt = (ZText*)res;
WriteHeader(txt, outPath, writer, Ship::ResourceType::Text);
WriteHeader(txt, outPath, writer, Ship::ResourceType::SOH_Text);
writer->Write((uint32_t)txt->messages.size());
+10 -12
View File
@@ -1,27 +1,25 @@
#include "VersionInfo.h"
#include <Resource.h>
#include <libultraship/bridge.h>
std::map<Ship::ResourceType, uint32_t> resourceVersions;
void InitVersionInfo()
{
resourceVersions = std::map<Ship::ResourceType, uint32_t> {
{ Ship::ResourceType::Animation, 0 },
{ Ship::ResourceType::Model, 0 },
{ Ship::ResourceType::SOH_Animation, 0 },
{ Ship::ResourceType::Texture, 0 },
{ Ship::ResourceType::Material, 0 },
{ Ship::ResourceType::PlayerAnimation, 0 },
{ Ship::ResourceType::SOH_PlayerAnimation, 0 },
{ Ship::ResourceType::DisplayList, 0 },
{ Ship::ResourceType::Room, 0 },
{ Ship::ResourceType::CollisionHeader, 0 },
{ Ship::ResourceType::Skeleton, 0 },
{ Ship::ResourceType::SkeletonLimb, 0 },
{ Ship::ResourceType::SOH_Room, 0 },
{ Ship::ResourceType::SOH_CollisionHeader, 0 },
{ Ship::ResourceType::SOH_Skeleton, 0 },
{ Ship::ResourceType::SOH_SkeletonLimb, 0 },
{ Ship::ResourceType::Matrix, 0 },
{ Ship::ResourceType::Path, 0 },
{ Ship::ResourceType::SOH_Path, 0 },
{ Ship::ResourceType::Vertex, 0 },
{ Ship::ResourceType::Cutscene, 0 },
{ Ship::ResourceType::SOH_Cutscene, 0 },
{ Ship::ResourceType::Array, 0 },
{ Ship::ResourceType::Text, 0 },
{ Ship::ResourceType::SOH_Text, 0 },
{ Ship::ResourceType::Blob, 0 },
};
}
+1 -1
View File
@@ -1,5 +1,5 @@
#include "VtxExporter.h"
#include "Resource.h"
#include <libultraship/bridge.h>
#include "VersionInfo.h"
+1 -1
View File
@@ -2,7 +2,7 @@
#define Z64CUTSCENE_H
#if 0
#include "ultra64.h"
#include <libultraship/libultra.h>
typedef struct {
/* 0x00 */ u16 entrance; // entrance index upon which the cutscene should trigger
+4 -5
View File
@@ -32,17 +32,16 @@ def main():
parser.add_argument("-z", "--zapd", help="Path to ZAPD executable", dest="zapd_exe", type=str)
parser.add_argument("rom", help="Path to the rom", type=str, nargs="?")
parser.add_argument("--non-interactive", help="Runs the script non-interactively for use in build scripts.", dest="non_interactive", action="store_true")
parser.add_argument("-v", "--verbose", help="Display rom's header checksums and their corresponding xml folder", dest="verbose", action="store_true")
args = parser.parse_args()
rom_paths = [ args.rom ] if args.rom else rom_chooser.chooseROM(args.non_interactive)
for rom_path in rom_paths:
rom = Z64Rom(rom_path)
roms = [ Z64Rom(args.rom) ] if args.rom else rom_chooser.chooseROM(args.verbose, args.non_interactive)
for rom in roms:
if (os.path.exists("Extract")):
shutil.rmtree("Extract")
BuildOTR("../soh/assets/xml/" + rom.version.xml_ver + "/", rom_path, zapd_exe=args.zapd_exe)
BuildOTR("../soh/assets/xml/" + rom.version.xml_ver + "/", rom.file_path, zapd_exe=args.zapd_exe)
if __name__ == "__main__":
main()
+14 -8
View File
@@ -2,12 +2,13 @@ import os, sys, glob
from rom_info import Z64Rom
def chooseROM(non_interactive=False):
def chooseROM(verbose=False, non_interactive=False):
roms = []
for file in glob.glob("*.z64"):
if Z64Rom.isValidRom(file):
roms.append(file)
rom = Z64Rom(file)
if rom.is_valid:
roms.append(rom)
if not (roms):
print("Error: No roms located, place one in the OTRExporter directory", file=os.sys.stderr)
@@ -21,23 +22,28 @@ def chooseROM(non_interactive=False):
foundMq = False
foundOot = False
for rom in roms:
isMq = Z64Rom.isMqRom(rom)
if isMq and not foundMq:
if rom.isMq and not foundMq:
romsToExtract.append(rom)
foundMq = True
elif not isMq and not foundOot:
elif not rom.isMq and not foundOot:
romsToExtract.append(rom)
foundOot = True
return romsToExtract
print(str(len(roms))+ " roms found, please select one by pressing 1-"+str(len(roms)))
print(f"{len(roms)} roms found, please select one by pressing 1-{len(roms)}")
print()
for i in range(len(roms)):
print(str(i+1)+ ". " + roms[i])
print(f"[{i+1:>2d}] {roms[i].file_path}")
if verbose:
print(f" Checksum: {roms[i].checksum.value}, Version XML: {roms[i].version.xml_ver}")
print()
while(1):
try:
selection = int(input())
except KeyboardInterrupt:
sys.exit(1)
except:
print("Bad input. Try again with the number keys.")
continue
+1 -1
View File
@@ -59,7 +59,7 @@ target_include_directories(${PROJECT_NAME} PRIVATE
.
)
INSTALL(TARGETS OTRGui DESTINATION . COMPONENT ship)
INSTALL(TARGETS OTRGui DESTINATION . COMPONENT ship OPTIONAL)
install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/assets
DESTINATION .
COMPONENT ship
+11 -20
View File
@@ -4,6 +4,10 @@ A PC port of OoT allowing you to enjoy the game with modern controls, widescreen
The Ship does not include assets and as such requires a prior copy of the game to play.
## Discord
Official Discord: https://discord.com/invite/BtBmd55HVH
## Quick Start (Windows)
1) Download The Ship of Harkinian from [Discord](https://discord.com/invite/BtBmd55HVH).
@@ -128,32 +132,19 @@ Once you have prepared your sequences folder:
Assuming you have done everything correctly, boot up SoH and open up the SFX Editor (In the Enhancements dropdown). You should now be able to swap out any of the in game sequences/fanfares for the sequences added in your newly generated OTR file. If you have any trouble with this process please reach out in the support section of the Discord
## Take The Survey
Want to use cartridge readers in tandem with the OTRGui?
Take [this survey](https://retroarchopenhardware.com/survey.php) to increase chances of this becoming reality.
## Discord
Official Discord: https://discord.com/invite/BtBmd55HVH
## Building The Ship of Harkinian
Refer to the [building instructions](BUILDING.md) to compile SoH.
## Getting CI to work on your fork
The CI works via [Github Actions](https://github.com/features/actions) where we mostly make use of machines hosted by Github; except for the very first step of the CI process called "Extract assets". This steps extracts assets from the game file and generates an "assets" folder in `soh/`.
To get this step working on your fork, you'll need to add a machine to your own repository as a self-hosted runner via "Settings > Actions > Runners" in your repository settings. If you're on macOS or Linux take a look at `macports-deps.txt` or `apt-deps.txt` to see the dependencies expected to be on your machine. For Windows, deps get installed as part of the CI process. To setup your runner as a service read the docs [here](https://docs.github.com/en/actions/hosting-your-own-runners/configuring-the-self-hosted-runner-application-as-a-service?platform=linux).
## Troubleshooting The Exporter
- Confirm that you have an `/assets` folder filled with XMLs in the same directory as OTRGui.exe
- Confirm that `zapd.exe` exists in the `/assets/extractor` folder
## Nightly Builds
Nightly builds of Ship of Harkinian are available here: [Windows](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-windows.zip), [macOS](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-mac.zip), [Linux](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-linux.zip), [Switch](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-switch.zip), [Wii U](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-wiiu.zip)
Nightly builds of Ship of Harkinian are available here: [Windows](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-windows.zip), [macOS](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-mac.zip), [Linux (compatibility*)](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-linux-compatiblity.zip), [Linux (performance*)](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-linux-performance.zip), [Switch](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-switch.zip), [Wii U](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-wiiu.zip)
_*compatibility: compatible with most Linux distributions, but may not be as performant as the perf build._\
_*performance: requires glibc 2.35 or newer, but will be more performant than the compat build._
## Take The Survey
Want to use cartridge readers in tandem with the OTRGui?
Take [this survey](https://retroarchopenhardware.com/survey.php) to increase chances of this becoming reality.
## The Harbour Masters Are...
+3 -3
View File
@@ -6,7 +6,7 @@
[subrepo]
remote = https://github.com/HarbourMasters/ZAPDTR.git
branch = master
commit = a53a53ea4216b926253dde2c942ae0ca6e2f2ccd
parent = f52a2a6406eb1bbd2b631c65923d879a83983ccb
commit = e23b125d89bd973998d2eb00896bcbaf1b53a329
parent = 17b1a8e7fd5517f9232e531da0fed6ef80a87f04
method = rebase
cmdver = 0.4.1
cmdver = 0.4.3
+2
View File
@@ -336,6 +336,8 @@ find_package(PNG REQUIRED)
target_include_directories(${PROJECT_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/ZAPDUtils
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src/resource
${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/include
${CMAKE_CURRENT_SOURCE_DIR}/../../ZAPDTR/lib/tinyxml2
${CMAKE_CURRENT_SOURCE_DIR}/../../ZAPDTR/lib/libgfxd
${PNG_PNG_INCLUDE_DIR}/
+3 -3
View File
@@ -221,7 +221,7 @@ void ZFile::ParseXML(tinyxml2::XMLElement* reader, const std::string& filename)
// Check for repeated attributes.
if (offsetXml != nullptr)
{
rawDataIndex = strtol(StringHelper::Split(offsetXml, "0x")[1].c_str(), NULL, 16);
rawDataIndex = strtol(StringHelper::Split(std::string(offsetXml), "0x")[1].c_str(), NULL, 16);
if (offsetSet.find(offsetXml) != offsetSet.end())
{
@@ -831,7 +831,7 @@ void ZFile::GenerateSourceHeaderFiles()
xmlPath = StringHelper::Replace(xmlPath, "\\", "/");
auto pathList = StringHelper::Split(xmlPath, "/");
std::string outPath = "";
for (int i = 0; i < 3; i++)
outPath += pathList[i] + "/";
@@ -1192,7 +1192,7 @@ std::string ZFile::ProcessTextureIntersections([[maybe_unused]] const std::strin
if (declarations.find(currentOffset) != declarations.end())
declarations.at(currentOffset)->size = currentTex->GetRawDataSize();
currentTex->DeclareVar(GetName(), "");
}
else
+2 -2
View File
@@ -7,8 +7,8 @@
#include <string>
#include <vector>
#include "Declaration.h"
#include "Utils/BinaryWriter.h"
#include "Utils/Directory.h"
#include <Utils/BinaryWriter.h>
#include <Utils/Directory.h>
#include "tinyxml2.h"
#define SEGMENT_SCENE 2
+116 -1546
View File
File diff suppressed because it is too large Load Diff
-1
View File
@@ -1,7 +1,6 @@
*.bin
*.c
!text/*.c
*.h
*.cfg
*.vtx.inc
*.dlist.inc
@@ -0,0 +1,37 @@
#pragma once
#define dsTransCircleNormalTex "__OTR__code/z_fbdemo_circle/sTransCircleNormalTex"
#ifdef _WIN32
static const __declspec(align(2)) char sTransCircleNormalTex[] = dsTransCircleNormalTex;
#else
static const char sTransCircleNormalTex[] __attribute__((aligned (2))) = dsTransCircleNormalTex;
#endif
#define dsTransCircleWaveTex "__OTR__code/z_fbdemo_circle/sTransCircleWaveTex"
#ifdef _WIN32
static const __declspec(align(2)) char sTransCircleWaveTex[] = dsTransCircleWaveTex;
#else
static const char sTransCircleWaveTex[] __attribute__((aligned (2))) = dsTransCircleWaveTex;
#endif
#define dsTransCircleRippleTex "__OTR__code/z_fbdemo_circle/sTransCircleRippleTex"
#ifdef _WIN32
static const __declspec(align(2)) char sTransCircleRippleTex[] = dsTransCircleRippleTex;
#else
static const char sTransCircleRippleTex[] __attribute__((aligned (2))) = dsTransCircleRippleTex;
#endif
#define dsTransCircleStarburstTex "__OTR__code/z_fbdemo_circle/sTransCircleStarburstTex"
#ifdef _WIN32
static const __declspec(align(2)) char sTransCircleStarburstTex[] = dsTransCircleStarburstTex;
#else
static const char sTransCircleStarburstTex[] __attribute__((aligned (2))) = dsTransCircleStarburstTex;
#endif
#define dsCircleWipeVtx "__OTR__code/z_fbdemo_circle/sCircleWipeVtx"
#ifdef _WIN32
static const __declspec(align(2)) char sCircleWipeVtx[] = dsCircleWipeVtx;
#else
static const char sCircleWipeVtx[] __attribute__((aligned (2))) = dsCircleWipeVtx;
#endif
@@ -0,0 +1,16 @@
#pragma once
#define dsTriforceWipeDL "__OTR__code/z_fbdemo_triforce/sTriforceWipeDL"
#ifdef _WIN32
static const __declspec(align(2)) char sTriforceWipeDL[] = dsTriforceWipeDL;
#else
static const char sTriforceWipeDL[] __attribute__((aligned (2))) = dsTriforceWipeDL;
#endif
#define dsTriforceWipeVtx "__OTR__code/z_fbdemo_triforce/sTriforceWipeVtx"
#ifdef _WIN32
static const __declspec(align(2)) char sTriforceWipeVtx[] = dsTriforceWipeVtx;
#else
static const char sTriforceWipeVtx[] __attribute__((aligned (2))) = dsTriforceWipeVtx;
#endif
@@ -0,0 +1,16 @@
#pragma once
#define dsWipe1Vtx "__OTR__code/z_fbdemo_wipe1/sWipe1Vtx"
#ifdef _WIN32
static const __declspec(align(2)) char sWipe1Vtx[] = dsWipe1Vtx;
#else
static const char sWipe1Vtx[] __attribute__((aligned (2))) = dsWipe1Vtx;
#endif
#define dsWipe1Tex "__OTR__code/z_fbdemo_wipe1/sWipe1Tex"
#ifdef _WIN32
static const __declspec(align(2)) char sWipe1Tex[] = dsWipe1Tex;
#else
static const char sWipe1Tex[] __attribute__((aligned (2))) = dsWipe1Tex;
#endif
@@ -0,0 +1,2 @@
#pragma once
@@ -0,0 +1,499 @@
#pragma once
#define dgUnusedCandleDL "__OTR__objects/gameplay_dangeon_keep/gUnusedCandleDL"
#ifdef _WIN32
static const __declspec(align(2)) char gUnusedCandleDL[] = dgUnusedCandleDL;
#else
static const char gUnusedCandleDL[] __attribute__((aligned (2))) = dgUnusedCandleDL;
#endif
#define dgBrownFragmentDL "__OTR__objects/gameplay_dangeon_keep/gBrownFragmentDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBrownFragmentDL[] = dgBrownFragmentDL;
#else
static const char gBrownFragmentDL[] __attribute__((aligned (2))) = dgBrownFragmentDL;
#endif
#define dgUnusedStoneTex "__OTR__objects/gameplay_dangeon_keep/gUnusedStoneTex"
#ifdef _WIN32
static const __declspec(align(2)) char gUnusedStoneTex[] = dgUnusedStoneTex;
#else
static const char gUnusedStoneTex[] __attribute__((aligned (2))) = dgUnusedStoneTex;
#endif
#define dgDoorLockDL "__OTR__objects/gameplay_dangeon_keep/gDoorLockDL"
#ifdef _WIN32
static const __declspec(align(2)) char gDoorLockDL[] = dgDoorLockDL;
#else
static const char gDoorLockDL[] __attribute__((aligned (2))) = dgDoorLockDL;
#endif
#define dgDoorChainsDL "__OTR__objects/gameplay_dangeon_keep/gDoorChainsDL"
#ifdef _WIN32
static const __declspec(align(2)) char gDoorChainsDL[] = dgDoorChainsDL;
#else
static const char gDoorChainsDL[] __attribute__((aligned (2))) = dgDoorChainsDL;
#endif
#define dgUnusedGoldLockTex "__OTR__objects/gameplay_dangeon_keep/gUnusedGoldLockTex"
#ifdef _WIN32
static const __declspec(align(2)) char gUnusedGoldLockTex[] = dgUnusedGoldLockTex;
#else
static const char gUnusedGoldLockTex[] __attribute__((aligned (2))) = dgUnusedGoldLockTex;
#endif
#define dgDoorChainTex "__OTR__objects/gameplay_dangeon_keep/gDoorChainTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDoorChainTex[] = dgDoorChainTex;
#else
static const char gDoorChainTex[] __attribute__((aligned (2))) = dgDoorChainTex;
#endif
#define dgUnusedBombBagDL "__OTR__objects/gameplay_dangeon_keep/gUnusedBombBagDL"
#ifdef _WIN32
static const __declspec(align(2)) char gUnusedBombBagDL[] = dgUnusedBombBagDL;
#else
static const char gUnusedBombBagDL[] __attribute__((aligned (2))) = dgUnusedBombBagDL;
#endif
#define dgPushBlockSilverTex "__OTR__objects/gameplay_dangeon_keep/gPushBlockSilverTex"
#ifdef _WIN32
static const __declspec(align(2)) char gPushBlockSilverTex[] = dgPushBlockSilverTex;
#else
static const char gPushBlockSilverTex[] __attribute__((aligned (2))) = dgPushBlockSilverTex;
#endif
#define dgPushBlockBaseTex "__OTR__objects/gameplay_dangeon_keep/gPushBlockBaseTex"
#ifdef _WIN32
static const __declspec(align(2)) char gPushBlockBaseTex[] = dgPushBlockBaseTex;
#else
static const char gPushBlockBaseTex[] __attribute__((aligned (2))) = dgPushBlockBaseTex;
#endif
#define dgPushBlockGrayTex "__OTR__objects/gameplay_dangeon_keep/gPushBlockGrayTex"
#ifdef _WIN32
static const __declspec(align(2)) char gPushBlockGrayTex[] = dgPushBlockGrayTex;
#else
static const char gPushBlockGrayTex[] __attribute__((aligned (2))) = dgPushBlockGrayTex;
#endif
#define dgPushBlockDL "__OTR__objects/gameplay_dangeon_keep/gPushBlockDL"
#ifdef _WIN32
static const __declspec(align(2)) char gPushBlockDL[] = dgPushBlockDL;
#else
static const char gPushBlockDL[] __attribute__((aligned (2))) = dgPushBlockDL;
#endif
#define dgPushBlockCol "__OTR__objects/gameplay_dangeon_keep/gPushBlockCol"
#ifdef _WIN32
static const __declspec(align(2)) char gPushBlockCol[] = dgPushBlockCol;
#else
static const char gPushBlockCol[] __attribute__((aligned (2))) = dgPushBlockCol;
#endif
#define dgWoodenPlatofrmDL "__OTR__objects/gameplay_dangeon_keep/gWoodenPlatofrmDL"
#ifdef _WIN32
static const __declspec(align(2)) char gWoodenPlatofrmDL[] = dgWoodenPlatofrmDL;
#else
static const char gWoodenPlatofrmDL[] __attribute__((aligned (2))) = dgWoodenPlatofrmDL;
#endif
#define dgSmallWoodenBoxDL "__OTR__objects/gameplay_dangeon_keep/gSmallWoodenBoxDL"
#ifdef _WIN32
static const __declspec(align(2)) char gSmallWoodenBoxDL[] = dgSmallWoodenBoxDL;
#else
static const char gSmallWoodenBoxDL[] __attribute__((aligned (2))) = dgSmallWoodenBoxDL;
#endif
#define dgSmallWoodenBoxFragmentDL "__OTR__objects/gameplay_dangeon_keep/gSmallWoodenBoxFragmentDL"
#ifdef _WIN32
static const __declspec(align(2)) char gSmallWoodenBoxFragmentDL[] = dgSmallWoodenBoxFragmentDL;
#else
static const char gSmallWoodenBoxFragmentDL[] __attribute__((aligned (2))) = dgSmallWoodenBoxFragmentDL;
#endif
#define dgBetaKokiriSwordSpriteDL "__OTR__objects/gameplay_dangeon_keep/gBetaKokiriSwordSpriteDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBetaKokiriSwordSpriteDL[] = dgBetaKokiriSwordSpriteDL;
#else
static const char gBetaKokiriSwordSpriteDL[] __attribute__((aligned (2))) = dgBetaKokiriSwordSpriteDL;
#endif
#define dgMagicJarSpriteDL "__OTR__objects/gameplay_dangeon_keep/gMagicJarSpriteDL"
#ifdef _WIN32
static const __declspec(align(2)) char gMagicJarSpriteDL[] = dgMagicJarSpriteDL;
#else
static const char gMagicJarSpriteDL[] __attribute__((aligned (2))) = dgMagicJarSpriteDL;
#endif
#define dgBetaSlingshotSpriteDL "__OTR__objects/gameplay_dangeon_keep/gBetaSlingshotSpriteDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBetaSlingshotSpriteDL[] = dgBetaSlingshotSpriteDL;
#else
static const char gBetaSlingshotSpriteDL[] __attribute__((aligned (2))) = dgBetaSlingshotSpriteDL;
#endif
#define dgFloorSwitch1DL "__OTR__objects/gameplay_dangeon_keep/gFloorSwitch1DL"
#ifdef _WIN32
static const __declspec(align(2)) char gFloorSwitch1DL[] = dgFloorSwitch1DL;
#else
static const char gFloorSwitch1DL[] __attribute__((aligned (2))) = dgFloorSwitch1DL;
#endif
#define dgRustyFloorSwitchDL "__OTR__objects/gameplay_dangeon_keep/gRustyFloorSwitchDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRustyFloorSwitchDL[] = dgRustyFloorSwitchDL;
#else
static const char gRustyFloorSwitchDL[] __attribute__((aligned (2))) = dgRustyFloorSwitchDL;
#endif
#define dgFloorSwitch2DL "__OTR__objects/gameplay_dangeon_keep/gFloorSwitch2DL"
#ifdef _WIN32
static const __declspec(align(2)) char gFloorSwitch2DL[] = dgFloorSwitch2DL;
#else
static const char gFloorSwitch2DL[] __attribute__((aligned (2))) = dgFloorSwitch2DL;
#endif
#define dgFloorSwitchCol "__OTR__objects/gameplay_dangeon_keep/gFloorSwitchCol"
#ifdef _WIN32
static const __declspec(align(2)) char gFloorSwitchCol[] = dgFloorSwitchCol;
#else
static const char gFloorSwitchCol[] __attribute__((aligned (2))) = dgFloorSwitchCol;
#endif
#define dgFloorSwitch3DL "__OTR__objects/gameplay_dangeon_keep/gFloorSwitch3DL"
#ifdef _WIN32
static const __declspec(align(2)) char gFloorSwitch3DL[] = dgFloorSwitch3DL;
#else
static const char gFloorSwitch3DL[] __attribute__((aligned (2))) = dgFloorSwitch3DL;
#endif
#define dgBetaFloorSwitchDL "__OTR__objects/gameplay_dangeon_keep/gBetaFloorSwitchDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBetaFloorSwitchDL[] = dgBetaFloorSwitchDL;
#else
static const char gBetaFloorSwitchDL[] __attribute__((aligned (2))) = dgBetaFloorSwitchDL;
#endif
#define dgEyeSwitch1DL "__OTR__objects/gameplay_dangeon_keep/gEyeSwitch1DL"
#ifdef _WIN32
static const __declspec(align(2)) char gEyeSwitch1DL[] = dgEyeSwitch1DL;
#else
static const char gEyeSwitch1DL[] __attribute__((aligned (2))) = dgEyeSwitch1DL;
#endif
#define dgEyeSwitch2DL "__OTR__objects/gameplay_dangeon_keep/gEyeSwitch2DL"
#ifdef _WIN32
static const __declspec(align(2)) char gEyeSwitch2DL[] = dgEyeSwitch2DL;
#else
static const char gEyeSwitch2DL[] __attribute__((aligned (2))) = dgEyeSwitch2DL;
#endif
#define dgCrystalSwitchCoreOpaDL "__OTR__objects/gameplay_dangeon_keep/gCrystalSwitchCoreOpaDL"
#ifdef _WIN32
static const __declspec(align(2)) char gCrystalSwitchCoreOpaDL[] = dgCrystalSwitchCoreOpaDL;
#else
static const char gCrystalSwitchCoreOpaDL[] __attribute__((aligned (2))) = dgCrystalSwitchCoreOpaDL;
#endif
#define dgCrystalSwitchCoreXluDL "__OTR__objects/gameplay_dangeon_keep/gCrystalSwitchCoreXluDL"
#ifdef _WIN32
static const __declspec(align(2)) char gCrystalSwitchCoreXluDL[] = dgCrystalSwitchCoreXluDL;
#else
static const char gCrystalSwitchCoreXluDL[] __attribute__((aligned (2))) = dgCrystalSwitchCoreXluDL;
#endif
#define dgCrystalSwitchDiamondOpaDL "__OTR__objects/gameplay_dangeon_keep/gCrystalSwitchDiamondOpaDL"
#ifdef _WIN32
static const __declspec(align(2)) char gCrystalSwitchDiamondOpaDL[] = dgCrystalSwitchDiamondOpaDL;
#else
static const char gCrystalSwitchDiamondOpaDL[] __attribute__((aligned (2))) = dgCrystalSwitchDiamondOpaDL;
#endif
#define dgCrystalSwitchDiamondXluDL "__OTR__objects/gameplay_dangeon_keep/gCrystalSwitchDiamondXluDL"
#ifdef _WIN32
static const __declspec(align(2)) char gCrystalSwitchDiamondXluDL[] = dgCrystalSwitchDiamondXluDL;
#else
static const char gCrystalSwitchDiamondXluDL[] __attribute__((aligned (2))) = dgCrystalSwitchDiamondXluDL;
#endif
#define dgBetaCrystalSwitchDL "__OTR__objects/gameplay_dangeon_keep/gBetaCrystalSwitchDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBetaCrystalSwitchDL[] = dgBetaCrystalSwitchDL;
#else
static const char gBetaCrystalSwitchDL[] __attribute__((aligned (2))) = dgBetaCrystalSwitchDL;
#endif
#define dgEyeSwitchGoldClosedTex "__OTR__objects/gameplay_dangeon_keep/gEyeSwitchGoldClosedTex"
#ifdef _WIN32
static const __declspec(align(2)) char gEyeSwitchGoldClosedTex[] = dgEyeSwitchGoldClosedTex;
#else
static const char gEyeSwitchGoldClosedTex[] __attribute__((aligned (2))) = dgEyeSwitchGoldClosedTex;
#endif
#define dgEyeSwitchGoldOpeningTex "__OTR__objects/gameplay_dangeon_keep/gEyeSwitchGoldOpeningTex"
#ifdef _WIN32
static const __declspec(align(2)) char gEyeSwitchGoldOpeningTex[] = dgEyeSwitchGoldOpeningTex;
#else
static const char gEyeSwitchGoldOpeningTex[] __attribute__((aligned (2))) = dgEyeSwitchGoldOpeningTex;
#endif
#define dgEyeSwitchGoldClosingTex "__OTR__objects/gameplay_dangeon_keep/gEyeSwitchGoldClosingTex"
#ifdef _WIN32
static const __declspec(align(2)) char gEyeSwitchGoldClosingTex[] = dgEyeSwitchGoldClosingTex;
#else
static const char gEyeSwitchGoldClosingTex[] __attribute__((aligned (2))) = dgEyeSwitchGoldClosingTex;
#endif
#define dgEyeSwitchGoldOpenTex "__OTR__objects/gameplay_dangeon_keep/gEyeSwitchGoldOpenTex"
#ifdef _WIN32
static const __declspec(align(2)) char gEyeSwitchGoldOpenTex[] = dgEyeSwitchGoldOpenTex;
#else
static const char gEyeSwitchGoldOpenTex[] __attribute__((aligned (2))) = dgEyeSwitchGoldOpenTex;
#endif
#define dgEyeSwitchSilverOpenTex "__OTR__objects/gameplay_dangeon_keep/gEyeSwitchSilverOpenTex"
#ifdef _WIN32
static const __declspec(align(2)) char gEyeSwitchSilverOpenTex[] = dgEyeSwitchSilverOpenTex;
#else
static const char gEyeSwitchSilverOpenTex[] __attribute__((aligned (2))) = dgEyeSwitchSilverOpenTex;
#endif
#define dgEyeSwitchSilverHalfTex "__OTR__objects/gameplay_dangeon_keep/gEyeSwitchSilverHalfTex"
#ifdef _WIN32
static const __declspec(align(2)) char gEyeSwitchSilverHalfTex[] = dgEyeSwitchSilverHalfTex;
#else
static const char gEyeSwitchSilverHalfTex[] __attribute__((aligned (2))) = dgEyeSwitchSilverHalfTex;
#endif
#define dgEyeSwitchSilverClosedTex "__OTR__objects/gameplay_dangeon_keep/gEyeSwitchSilverClosedTex"
#ifdef _WIN32
static const __declspec(align(2)) char gEyeSwitchSilverClosedTex[] = dgEyeSwitchSilverClosedTex;
#else
static const char gEyeSwitchSilverClosedTex[] __attribute__((aligned (2))) = dgEyeSwitchSilverClosedTex;
#endif
#define dgDungeonKeepTex_00C8A0 "__OTR__objects/gameplay_dangeon_keep/gDungeonKeepTex_00C8A0"
#ifdef _WIN32
static const __declspec(align(2)) char gDungeonKeepTex_00C8A0[] = dgDungeonKeepTex_00C8A0;
#else
static const char gDungeonKeepTex_00C8A0[] __attribute__((aligned (2))) = dgDungeonKeepTex_00C8A0;
#endif
#define dgDungeonkeepTex_00D0A0 "__OTR__objects/gameplay_dangeon_keep/gDungeonkeepTex_00D0A0"
#ifdef _WIN32
static const __declspec(align(2)) char gDungeonkeepTex_00D0A0[] = dgDungeonkeepTex_00D0A0;
#else
static const char gDungeonkeepTex_00D0A0[] __attribute__((aligned (2))) = dgDungeonkeepTex_00D0A0;
#endif
#define dgDungeonKeepTex_00E8A0 "__OTR__objects/gameplay_dangeon_keep/gDungeonKeepTex_00E8A0"
#ifdef _WIN32
static const __declspec(align(2)) char gDungeonKeepTex_00E8A0[] = dgDungeonKeepTex_00E8A0;
#else
static const char gDungeonKeepTex_00E8A0[] __attribute__((aligned (2))) = dgDungeonKeepTex_00E8A0;
#endif
#define dgDungeonKeepTex_00ECA0 "__OTR__objects/gameplay_dangeon_keep/gDungeonKeepTex_00ECA0"
#ifdef _WIN32
static const __declspec(align(2)) char gDungeonKeepTex_00ECA0[] = dgDungeonKeepTex_00ECA0;
#else
static const char gDungeonKeepTex_00ECA0[] __attribute__((aligned (2))) = dgDungeonKeepTex_00ECA0;
#endif
#define dgDungeonKeepTex_00F0A0 "__OTR__objects/gameplay_dangeon_keep/gDungeonKeepTex_00F0A0"
#ifdef _WIN32
static const __declspec(align(2)) char gDungeonKeepTex_00F0A0[] = dgDungeonKeepTex_00F0A0;
#else
static const char gDungeonKeepTex_00F0A0[] __attribute__((aligned (2))) = dgDungeonKeepTex_00F0A0;
#endif
#define dgCrstalSwitchRedTex "__OTR__objects/gameplay_dangeon_keep/gCrstalSwitchRedTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCrstalSwitchRedTex[] = dgCrstalSwitchRedTex;
#else
static const char gCrstalSwitchRedTex[] __attribute__((aligned (2))) = dgCrstalSwitchRedTex;
#endif
#define dgCrstalSwitchBlueTex "__OTR__objects/gameplay_dangeon_keep/gCrstalSwitchBlueTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCrstalSwitchBlueTex[] = dgCrstalSwitchBlueTex;
#else
static const char gCrstalSwitchBlueTex[] __attribute__((aligned (2))) = dgCrstalSwitchBlueTex;
#endif
#define dgPotDL "__OTR__objects/gameplay_dangeon_keep/gPotDL"
#ifdef _WIN32
static const __declspec(align(2)) char gPotDL[] = dgPotDL;
#else
static const char gPotDL[] __attribute__((aligned (2))) = dgPotDL;
#endif
#define dgPotFragmentDL "__OTR__objects/gameplay_dangeon_keep/gPotFragmentDL"
#ifdef _WIN32
static const __declspec(align(2)) char gPotFragmentDL[] = dgPotFragmentDL;
#else
static const char gPotFragmentDL[] __attribute__((aligned (2))) = dgPotFragmentDL;
#endif
#define dgameplay_dangeon_keepTex_000000 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_000000"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_000000[] = dgameplay_dangeon_keepTex_000000;
#else
static const char gameplay_dangeon_keepTex_000000[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_000000;
#endif
#define dgameplay_dangeon_keepTex_000200 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_000200"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_000200[] = dgameplay_dangeon_keepTex_000200;
#else
static const char gameplay_dangeon_keepTex_000200[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_000200;
#endif
#define dgameplay_dangeon_keepTex_0005C0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_0005C0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_0005C0[] = dgameplay_dangeon_keepTex_0005C0;
#else
static const char gameplay_dangeon_keepTex_0005C0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_0005C0;
#endif
#define dgameplay_dangeon_keepTex_001280 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_001280"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_001280[] = dgameplay_dangeon_keepTex_001280;
#else
static const char gameplay_dangeon_keepTex_001280[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_001280;
#endif
#define dgameplay_dangeon_keepTex_0164B0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_0164B0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_0164B0[] = dgameplay_dangeon_keepTex_0164B0;
#else
static const char gameplay_dangeon_keepTex_0164B0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_0164B0;
#endif
#define dgameplay_dangeon_keepTex_00F8A0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_00F8A0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_00F8A0[] = dgameplay_dangeon_keepTex_00F8A0;
#else
static const char gameplay_dangeon_keepTex_00F8A0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_00F8A0;
#endif
#define dgameplay_dangeon_keepTex_011CA0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_011CA0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_011CA0[] = dgameplay_dangeon_keepTex_011CA0;
#else
static const char gameplay_dangeon_keepTex_011CA0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_011CA0;
#endif
#define dgameplay_dangeon_keepTex_012CA0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_012CA0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_012CA0[] = dgameplay_dangeon_keepTex_012CA0;
#else
static const char gameplay_dangeon_keepTex_012CA0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_012CA0;
#endif
#define dgameplay_dangeon_keepTex_0154B0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_0154B0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_0154B0[] = dgameplay_dangeon_keepTex_0154B0;
#else
static const char gameplay_dangeon_keepTex_0154B0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_0154B0;
#endif
#define dgameplay_dangeon_keepTex_015CB0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_015CB0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_015CB0[] = dgameplay_dangeon_keepTex_015CB0;
#else
static const char gameplay_dangeon_keepTex_015CB0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_015CB0;
#endif
#define dgameplay_dangeon_keepTex_016CB0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_016CB0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_016CB0[] = dgameplay_dangeon_keepTex_016CB0;
#else
static const char gameplay_dangeon_keepTex_016CB0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_016CB0;
#endif
#define dgameplay_dangeon_keepTex_007CA0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_007CA0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_007CA0[] = dgameplay_dangeon_keepTex_007CA0;
#else
static const char gameplay_dangeon_keepTex_007CA0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_007CA0;
#endif
#define dgameplay_dangeon_keepTex_0078A0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_0078A0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_0078A0[] = dgameplay_dangeon_keepTex_0078A0;
#else
static const char gameplay_dangeon_keepTex_0078A0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_0078A0;
#endif
#define dgameplay_dangeon_keepTex_00D8A0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_00D8A0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_00D8A0[] = dgameplay_dangeon_keepTex_00D8A0;
#else
static const char gameplay_dangeon_keepTex_00D8A0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_00D8A0;
#endif
#define dgameplay_dangeon_keepTex_00E0A0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_00E0A0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_00E0A0[] = dgameplay_dangeon_keepTex_00E0A0;
#else
static const char gameplay_dangeon_keepTex_00E0A0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_00E0A0;
#endif
#define dgameplay_dangeon_keepTex_0080A0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_0080A0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_0080A0[] = dgameplay_dangeon_keepTex_0080A0;
#else
static const char gameplay_dangeon_keepTex_0080A0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_0080A0;
#endif
#define dgameplay_dangeon_keepTex_0088A0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_0088A0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_0088A0[] = dgameplay_dangeon_keepTex_0088A0;
#else
static const char gameplay_dangeon_keepTex_0088A0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_0088A0;
#endif
#define dgameplay_dangeon_keepTex_013CB0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_013CB0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_013CB0[] = dgameplay_dangeon_keepTex_013CB0;
#else
static const char gameplay_dangeon_keepTex_013CB0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_013CB0;
#endif
#define dgameplay_dangeon_keepTex_0134A0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_0134A0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_0134A0[] = dgameplay_dangeon_keepTex_0134A0;
#else
static const char gameplay_dangeon_keepTex_0134A0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_0134A0;
#endif
#define dgameplay_dangeon_keepTex_013CA0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_013CA0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_013CA0[] = dgameplay_dangeon_keepTex_013CA0;
#else
static const char gameplay_dangeon_keepTex_013CA0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_013CA0;
#endif
#define dgameplay_dangeon_keepTex_0108A0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_0108A0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_0108A0[] = dgameplay_dangeon_keepTex_0108A0;
#else
static const char gameplay_dangeon_keepTex_0108A0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_0108A0;
#endif
#define dgameplay_dangeon_keepTex_0118A0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_0118A0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_0118A0[] = dgameplay_dangeon_keepTex_0118A0;
#else
static const char gameplay_dangeon_keepTex_0118A0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_0118A0;
#endif
#define dgameplay_dangeon_keepTex_011AA0 "__OTR__objects/gameplay_dangeon_keep/gameplay_dangeon_keepTex_011AA0"
#ifdef _WIN32
static const __declspec(align(2)) char gameplay_dangeon_keepTex_011AA0[] = dgameplay_dangeon_keepTex_011AA0;
#else
static const char gameplay_dangeon_keepTex_011AA0[] __attribute__((aligned (2))) = dgameplay_dangeon_keepTex_011AA0;
#endif
@@ -0,0 +1,429 @@
#pragma once
#define dgHanaFlower1DL "__OTR__objects/gameplay_field_keep/gHanaFlower1DL"
#ifdef _WIN32
static const __declspec(align(2)) char gHanaFlower1DL[] = dgHanaFlower1DL;
#else
static const char gHanaFlower1DL[] __attribute__((aligned (2))) = dgHanaFlower1DL;
#endif
#define dgHanaFlower2DL "__OTR__objects/gameplay_field_keep/gHanaFlower2DL"
#ifdef _WIN32
static const __declspec(align(2)) char gHanaFlower2DL[] = dgHanaFlower2DL;
#else
static const char gHanaFlower2DL[] __attribute__((aligned (2))) = dgHanaFlower2DL;
#endif
#define dgHanaFlower3DL "__OTR__objects/gameplay_field_keep/gHanaFlower3DL"
#ifdef _WIN32
static const __declspec(align(2)) char gHanaFlower3DL[] = dgHanaFlower3DL;
#else
static const char gHanaFlower3DL[] __attribute__((aligned (2))) = dgHanaFlower3DL;
#endif
#define dgHanaLeaf1DL "__OTR__objects/gameplay_field_keep/gHanaLeaf1DL"
#ifdef _WIN32
static const __declspec(align(2)) char gHanaLeaf1DL[] = dgHanaLeaf1DL;
#else
static const char gHanaLeaf1DL[] __attribute__((aligned (2))) = dgHanaLeaf1DL;
#endif
#define dgHanaLeaf2DL "__OTR__objects/gameplay_field_keep/gHanaLeaf2DL"
#ifdef _WIN32
static const __declspec(align(2)) char gHanaLeaf2DL[] = dgHanaLeaf2DL;
#else
static const char gHanaLeaf2DL[] __attribute__((aligned (2))) = dgHanaLeaf2DL;
#endif
#define dgHanaLeaf3DL "__OTR__objects/gameplay_field_keep/gHanaLeaf3DL"
#ifdef _WIN32
static const __declspec(align(2)) char gHanaLeaf3DL[] = dgHanaLeaf3DL;
#else
static const char gHanaLeaf3DL[] __attribute__((aligned (2))) = dgHanaLeaf3DL;
#endif
#define dgHanaLeaf4DL "__OTR__objects/gameplay_field_keep/gHanaLeaf4DL"
#ifdef _WIN32
static const __declspec(align(2)) char gHanaLeaf4DL[] = dgHanaLeaf4DL;
#else
static const char gHanaLeaf4DL[] __attribute__((aligned (2))) = dgHanaLeaf4DL;
#endif
#define dgHanaLeaf5DL "__OTR__objects/gameplay_field_keep/gHanaLeaf5DL"
#ifdef _WIN32
static const __declspec(align(2)) char gHanaLeaf5DL[] = dgHanaLeaf5DL;
#else
static const char gHanaLeaf5DL[] __attribute__((aligned (2))) = dgHanaLeaf5DL;
#endif
#define dgHanaFlowerTex "__OTR__objects/gameplay_field_keep/gHanaFlowerTex"
#ifdef _WIN32
static const __declspec(align(2)) char gHanaFlowerTex[] = dgHanaFlowerTex;
#else
static const char gHanaFlowerTex[] __attribute__((aligned (2))) = dgHanaFlowerTex;
#endif
#define dgHanaLeafTex "__OTR__objects/gameplay_field_keep/gHanaLeafTex"
#ifdef _WIN32
static const __declspec(align(2)) char gHanaLeafTex[] = dgHanaLeafTex;
#else
static const char gHanaLeafTex[] __attribute__((aligned (2))) = dgHanaLeafTex;
#endif
#define dgHanaDL "__OTR__objects/gameplay_field_keep/gHanaDL"
#ifdef _WIN32
static const __declspec(align(2)) char gHanaDL[] = dgHanaDL;
#else
static const char gHanaDL[] __attribute__((aligned (2))) = dgHanaDL;
#endif
#define dgBgBombwallCol "__OTR__objects/gameplay_field_keep/gBgBombwallCol"
#ifdef _WIN32
static const __declspec(align(2)) char gBgBombwallCol[] = dgBgBombwallCol;
#else
static const char gBgBombwallCol[] __attribute__((aligned (2))) = dgBgBombwallCol;
#endif
#define dgBgBombwallNormalDL "__OTR__objects/gameplay_field_keep/gBgBombwallNormalDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBgBombwallNormalDL[] = dgBgBombwallNormalDL;
#else
static const char gBgBombwallNormalDL[] __attribute__((aligned (2))) = dgBgBombwallNormalDL;
#endif
#define dgBgBombwallBrokenDL "__OTR__objects/gameplay_field_keep/gBgBombwallBrokenDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBgBombwallBrokenDL[] = dgBgBombwallBrokenDL;
#else
static const char gBgBombwallBrokenDL[] __attribute__((aligned (2))) = dgBgBombwallBrokenDL;
#endif
#define dgGrottoDL "__OTR__objects/gameplay_field_keep/gGrottoDL"
#ifdef _WIN32
static const __declspec(align(2)) char gGrottoDL[] = dgGrottoDL;
#else
static const char gGrottoDL[] __attribute__((aligned (2))) = dgGrottoDL;
#endif
#define dgGrottoTex "__OTR__objects/gameplay_field_keep/gGrottoTex"
#ifdef _WIN32
static const __declspec(align(2)) char gGrottoTex[] = dgGrottoTex;
#else
static const char gGrottoTex[] __attribute__((aligned (2))) = dgGrottoTex;
#endif
#define dgButterflyDL_002480 "__OTR__objects/gameplay_field_keep/gButterflyDL_002480"
#ifdef _WIN32
static const __declspec(align(2)) char gButterflyDL_002480[] = dgButterflyDL_002480;
#else
static const char gButterflyDL_002480[] __attribute__((aligned (2))) = dgButterflyDL_002480;
#endif
#define dgButterflyDL_002520 "__OTR__objects/gameplay_field_keep/gButterflyDL_002520"
#ifdef _WIN32
static const __declspec(align(2)) char gButterflyDL_002520[] = dgButterflyDL_002520;
#else
static const char gButterflyDL_002520[] __attribute__((aligned (2))) = dgButterflyDL_002520;
#endif
#define dgButterflyDL_002580 "__OTR__objects/gameplay_field_keep/gButterflyDL_002580"
#ifdef _WIN32
static const __declspec(align(2)) char gButterflyDL_002580[] = dgButterflyDL_002580;
#else
static const char gButterflyDL_002580[] __attribute__((aligned (2))) = dgButterflyDL_002580;
#endif
#define dgButterflyDL_002620 "__OTR__objects/gameplay_field_keep/gButterflyDL_002620"
#ifdef _WIN32
static const __declspec(align(2)) char gButterflyDL_002620[] = dgButterflyDL_002620;
#else
static const char gButterflyDL_002620[] __attribute__((aligned (2))) = dgButterflyDL_002620;
#endif
#define dgButterflyWingTex "__OTR__objects/gameplay_field_keep/gButterflyWingTex"
#ifdef _WIN32
static const __declspec(align(2)) char gButterflyWingTex[] = dgButterflyWingTex;
#else
static const char gButterflyWingTex[] __attribute__((aligned (2))) = dgButterflyWingTex;
#endif
#define dgButterflySkel "__OTR__objects/gameplay_field_keep/gButterflySkel"
#ifdef _WIN32
static const __declspec(align(2)) char gButterflySkel[] = dgButterflySkel;
#else
static const char gButterflySkel[] __attribute__((aligned (2))) = dgButterflySkel;
#endif
#define dgButterflyAnim "__OTR__objects/gameplay_field_keep/gButterflyAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gButterflyAnim[] = dgButterflyAnim;
#else
static const char gButterflyAnim[] __attribute__((aligned (2))) = dgButterflyAnim;
#endif
#define dgBgBombwallTLUT "__OTR__objects/gameplay_field_keep/gBgBombwallTLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gBgBombwallTLUT[] = dgBgBombwallTLUT;
#else
static const char gBgBombwallTLUT[] __attribute__((aligned (2))) = dgBgBombwallTLUT;
#endif
#define dgBgBombwallNormalTex "__OTR__objects/gameplay_field_keep/gBgBombwallNormalTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBgBombwallNormalTex[] = dgBgBombwallNormalTex;
#else
static const char gBgBombwallNormalTex[] __attribute__((aligned (2))) = dgBgBombwallNormalTex;
#endif
#define dgBgBombWallBrokenTex "__OTR__objects/gameplay_field_keep/gBgBombWallBrokenTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBgBombWallBrokenTex[] = dgBgBombWallBrokenTex;
#else
static const char gBgBombWallBrokenTex[] __attribute__((aligned (2))) = dgBgBombWallBrokenTex;
#endif
#define dgFieldDoorDL_004720 "__OTR__objects/gameplay_field_keep/gFieldDoorDL_004720"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldDoorDL_004720[] = dgFieldDoorDL_004720;
#else
static const char gFieldDoorDL_004720[] __attribute__((aligned (2))) = dgFieldDoorDL_004720;
#endif
#define dgFieldDoorLeftDL "__OTR__objects/gameplay_field_keep/gFieldDoorLeftDL"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldDoorLeftDL[] = dgFieldDoorLeftDL;
#else
static const char gFieldDoorLeftDL[] __attribute__((aligned (2))) = dgFieldDoorLeftDL;
#endif
#define dgFieldDoorRightDL "__OTR__objects/gameplay_field_keep/gFieldDoorRightDL"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldDoorRightDL[] = dgFieldDoorRightDL;
#else
static const char gFieldDoorRightDL[] __attribute__((aligned (2))) = dgFieldDoorRightDL;
#endif
#define dgFieldDoor1Tex "__OTR__objects/gameplay_field_keep/gFieldDoor1Tex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldDoor1Tex[] = dgFieldDoor1Tex;
#else
static const char gFieldDoor1Tex[] __attribute__((aligned (2))) = dgFieldDoor1Tex;
#endif
#define dgFieldDoorKnobTopHalfTex "__OTR__objects/gameplay_field_keep/gFieldDoorKnobTopHalfTex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldDoorKnobTopHalfTex[] = dgFieldDoorKnobTopHalfTex;
#else
static const char gFieldDoorKnobTopHalfTex[] __attribute__((aligned (2))) = dgFieldDoorKnobTopHalfTex;
#endif
#define dgFieldDoorKnobTex "__OTR__objects/gameplay_field_keep/gFieldDoorKnobTex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldDoorKnobTex[] = dgFieldDoorKnobTex;
#else
static const char gFieldDoorKnobTex[] __attribute__((aligned (2))) = dgFieldDoorKnobTex;
#endif
#define dgFieldUnusedFishSkel "__OTR__objects/gameplay_field_keep/gFieldUnusedFishSkel"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldUnusedFishSkel[] = dgFieldUnusedFishSkel;
#else
static const char gFieldUnusedFishSkel[] __attribute__((aligned (2))) = dgFieldUnusedFishSkel;
#endif
#define dgFieldUnusedFishAnim "__OTR__objects/gameplay_field_keep/gFieldUnusedFishAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldUnusedFishAnim[] = dgFieldUnusedFishAnim;
#else
static const char gFieldUnusedFishAnim[] __attribute__((aligned (2))) = dgFieldUnusedFishAnim;
#endif
#define dgFieldUnusedFishDL "__OTR__objects/gameplay_field_keep/gFieldUnusedFishDL"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldUnusedFishDL[] = dgFieldUnusedFishDL;
#else
static const char gFieldUnusedFishDL[] __attribute__((aligned (2))) = dgFieldUnusedFishDL;
#endif
#define dgFieldSkelUnusedFishDL_0061E8 "__OTR__objects/gameplay_field_keep/gFieldSkelUnusedFishDL_0061E8"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldSkelUnusedFishDL_0061E8[] = dgFieldSkelUnusedFishDL_0061E8;
#else
static const char gFieldSkelUnusedFishDL_0061E8[] __attribute__((aligned (2))) = dgFieldSkelUnusedFishDL_0061E8;
#endif
#define dgFieldSkelUnusedFishDL_0063A8 "__OTR__objects/gameplay_field_keep/gFieldSkelUnusedFishDL_0063A8"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldSkelUnusedFishDL_0063A8[] = dgFieldSkelUnusedFishDL_0063A8;
#else
static const char gFieldSkelUnusedFishDL_0063A8[] __attribute__((aligned (2))) = dgFieldSkelUnusedFishDL_0063A8;
#endif
#define dgFieldSkelUnusedFishDL_006448 "__OTR__objects/gameplay_field_keep/gFieldSkelUnusedFishDL_006448"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldSkelUnusedFishDL_006448[] = dgFieldSkelUnusedFishDL_006448;
#else
static const char gFieldSkelUnusedFishDL_006448[] __attribute__((aligned (2))) = dgFieldSkelUnusedFishDL_006448;
#endif
#define dgFieldUnusedFishTex "__OTR__objects/gameplay_field_keep/gFieldUnusedFishTex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldUnusedFishTex[] = dgFieldUnusedFishTex;
#else
static const char gFieldUnusedFishTex[] __attribute__((aligned (2))) = dgFieldUnusedFishTex;
#endif
#define dgFieldUnusedFishBottomTex "__OTR__objects/gameplay_field_keep/gFieldUnusedFishBottomTex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldUnusedFishBottomTex[] = dgFieldUnusedFishBottomTex;
#else
static const char gFieldUnusedFishBottomTex[] __attribute__((aligned (2))) = dgFieldUnusedFishBottomTex;
#endif
#define dgFieldUnusedFishFinTex "__OTR__objects/gameplay_field_keep/gFieldUnusedFishFinTex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldUnusedFishFinTex[] = dgFieldUnusedFishFinTex;
#else
static const char gFieldUnusedFishFinTex[] __attribute__((aligned (2))) = dgFieldUnusedFishFinTex;
#endif
#define dgSilverRockDL "__OTR__objects/gameplay_field_keep/gSilverRockDL"
#ifdef _WIN32
static const __declspec(align(2)) char gSilverRockDL[] = dgSilverRockDL;
#else
static const char gSilverRockDL[] __attribute__((aligned (2))) = dgSilverRockDL;
#endif
#define dgFieldKakeraDL "__OTR__objects/gameplay_field_keep/gFieldKakeraDL"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldKakeraDL[] = dgFieldKakeraDL;
#else
static const char gFieldKakeraDL[] __attribute__((aligned (2))) = dgFieldKakeraDL;
#endif
#define dgFieldKakeraTex "__OTR__objects/gameplay_field_keep/gFieldKakeraTex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldKakeraTex[] = dgFieldKakeraTex;
#else
static const char gFieldKakeraTex[] __attribute__((aligned (2))) = dgFieldKakeraTex;
#endif
#define dgSilverRockFragmentsDL "__OTR__objects/gameplay_field_keep/gSilverRockFragmentsDL"
#ifdef _WIN32
static const __declspec(align(2)) char gSilverRockFragmentsDL[] = dgSilverRockFragmentsDL;
#else
static const char gSilverRockFragmentsDL[] __attribute__((aligned (2))) = dgSilverRockFragmentsDL;
#endif
#define dgFieldBushDL "__OTR__objects/gameplay_field_keep/gFieldBushDL"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldBushDL[] = dgFieldBushDL;
#else
static const char gFieldBushDL[] __attribute__((aligned (2))) = dgFieldBushDL;
#endif
#define dgFieldBushTex "__OTR__objects/gameplay_field_keep/gFieldBushTex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldBushTex[] = dgFieldBushTex;
#else
static const char gFieldBushTex[] __attribute__((aligned (2))) = dgFieldBushTex;
#endif
#define dgFieldBeehiveDL "__OTR__objects/gameplay_field_keep/gFieldBeehiveDL"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldBeehiveDL[] = dgFieldBeehiveDL;
#else
static const char gFieldBeehiveDL[] __attribute__((aligned (2))) = dgFieldBeehiveDL;
#endif
#define dgFieldBeehiveFragmentDL "__OTR__objects/gameplay_field_keep/gFieldBeehiveFragmentDL"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldBeehiveFragmentDL[] = dgFieldBeehiveFragmentDL;
#else
static const char gFieldBeehiveFragmentDL[] __attribute__((aligned (2))) = dgFieldBeehiveFragmentDL;
#endif
#define dgFieldBeehiveTex "__OTR__objects/gameplay_field_keep/gFieldBeehiveTex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldBeehiveTex[] = dgFieldBeehiveTex;
#else
static const char gFieldBeehiveTex[] __attribute__((aligned (2))) = dgFieldBeehiveTex;
#endif
#define dgFieldBeehiveFragmentTex "__OTR__objects/gameplay_field_keep/gFieldBeehiveFragmentTex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldBeehiveFragmentTex[] = dgFieldBeehiveFragmentTex;
#else
static const char gFieldBeehiveFragmentTex[] __attribute__((aligned (2))) = dgFieldBeehiveFragmentTex;
#endif
#define dgFieldSilverRockTex "__OTR__objects/gameplay_field_keep/gFieldSilverRockTex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldSilverRockTex[] = dgFieldSilverRockTex;
#else
static const char gFieldSilverRockTex[] __attribute__((aligned (2))) = dgFieldSilverRockTex;
#endif
#define dgFieldSilverRockTLUT "__OTR__objects/gameplay_field_keep/gFieldSilverRockTLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldSilverRockTLUT[] = dgFieldSilverRockTLUT;
#else
static const char gFieldSilverRockTLUT[] __attribute__((aligned (2))) = dgFieldSilverRockTLUT;
#endif
#define dgFieldSandstorm1Tex "__OTR__objects/gameplay_field_keep/gFieldSandstorm1Tex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldSandstorm1Tex[] = dgFieldSandstorm1Tex;
#else
static const char gFieldSandstorm1Tex[] __attribute__((aligned (2))) = dgFieldSandstorm1Tex;
#endif
#define dgFieldSandstorm2Tex "__OTR__objects/gameplay_field_keep/gFieldSandstorm2Tex"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldSandstorm2Tex[] = dgFieldSandstorm2Tex;
#else
static const char gFieldSandstorm2Tex[] __attribute__((aligned (2))) = dgFieldSandstorm2Tex;
#endif
#define dgFieldSandstormDL "__OTR__objects/gameplay_field_keep/gFieldSandstormDL"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldSandstormDL[] = dgFieldSandstormDL;
#else
static const char gFieldSandstormDL[] __attribute__((aligned (2))) = dgFieldSandstormDL;
#endif
#define dgFieldKeepTex_00CB30 "__OTR__objects/gameplay_field_keep/gFieldKeepTex_00CB30"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldKeepTex_00CB30[] = dgFieldKeepTex_00CB30;
#else
static const char gFieldKeepTex_00CB30[] __attribute__((aligned (2))) = dgFieldKeepTex_00CB30;
#endif
#define dgButterflySkelLimbsLimb_0036A4DL_002530 "__OTR__objects/gameplay_field_keep/gButterflySkelLimbsLimb_0036A4DL_002530"
#ifdef _WIN32
static const __declspec(align(2)) char gButterflySkelLimbsLimb_0036A4DL_002530[] = dgButterflySkelLimbsLimb_0036A4DL_002530;
#else
static const char gButterflySkelLimbsLimb_0036A4DL_002530[] __attribute__((aligned (2))) = dgButterflySkelLimbsLimb_0036A4DL_002530;
#endif
#define dgButterflySkelLimbsLimb_0036C8DL_002630 "__OTR__objects/gameplay_field_keep/gButterflySkelLimbsLimb_0036C8DL_002630"
#ifdef _WIN32
static const __declspec(align(2)) char gButterflySkelLimbsLimb_0036C8DL_002630[] = dgButterflySkelLimbsLimb_0036C8DL_002630;
#else
static const char gButterflySkelLimbsLimb_0036C8DL_002630[] __attribute__((aligned (2))) = dgButterflySkelLimbsLimb_0036C8DL_002630;
#endif
#define dgFieldUnusedFishSkelLimbsLimb_0088CCDL_006458 "__OTR__objects/gameplay_field_keep/gFieldUnusedFishSkelLimbsLimb_0088CCDL_006458"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldUnusedFishSkelLimbsLimb_0088CCDL_006458[] = dgFieldUnusedFishSkelLimbsLimb_0088CCDL_006458;
#else
static const char gFieldUnusedFishSkelLimbsLimb_0088CCDL_006458[] __attribute__((aligned (2))) = dgFieldUnusedFishSkelLimbsLimb_0088CCDL_006458;
#endif
#define dgFieldUnusedFishSkelLimbsLimb_0088D8DL_0061F8 "__OTR__objects/gameplay_field_keep/gFieldUnusedFishSkelLimbsLimb_0088D8DL_0061F8"
#ifdef _WIN32
static const __declspec(align(2)) char gFieldUnusedFishSkelLimbsLimb_0088D8DL_0061F8[] = dgFieldUnusedFishSkelLimbsLimb_0088D8DL_0061F8;
#else
static const char gFieldUnusedFishSkelLimbsLimb_0088D8DL_0061F8[] __attribute__((aligned (2))) = dgFieldUnusedFishSkelLimbsLimb_0088D8DL_0061F8;
#endif
File diff suppressed because it is too large Load Diff
+128
View File
@@ -0,0 +1,128 @@
#pragma once
#define dobject_Bb_Anim_000184 "__OTR__objects/object_Bb/object_Bb_Anim_000184"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Anim_000184[] = dobject_Bb_Anim_000184;
#else
static const char object_Bb_Anim_000184[] __attribute__((aligned (2))) = dobject_Bb_Anim_000184;
#endif
#define dobject_Bb_Anim_0002AC "__OTR__objects/object_Bb/object_Bb_Anim_0002AC"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Anim_0002AC[] = dobject_Bb_Anim_0002AC;
#else
static const char object_Bb_Anim_0002AC[] __attribute__((aligned (2))) = dobject_Bb_Anim_0002AC;
#endif
#define dobject_Bb_Anim_000444 "__OTR__objects/object_Bb/object_Bb_Anim_000444"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Anim_000444[] = dobject_Bb_Anim_000444;
#else
static const char object_Bb_Anim_000444[] __attribute__((aligned (2))) = dobject_Bb_Anim_000444;
#endif
#define dobject_Bb_DL_000C20 "__OTR__objects/object_Bb/object_Bb_DL_000C20"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_DL_000C20[] = dobject_Bb_DL_000C20;
#else
static const char object_Bb_DL_000C20[] __attribute__((aligned (2))) = dobject_Bb_DL_000C20;
#endif
#define dobject_Bb_DL_000CB0 "__OTR__objects/object_Bb/object_Bb_DL_000CB0"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_DL_000CB0[] = dobject_Bb_DL_000CB0;
#else
static const char object_Bb_DL_000CB0[] __attribute__((aligned (2))) = dobject_Bb_DL_000CB0;
#endif
#define dobject_Bb_DL_000D40 "__OTR__objects/object_Bb/object_Bb_DL_000D40"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_DL_000D40[] = dobject_Bb_DL_000D40;
#else
static const char object_Bb_DL_000D40[] __attribute__((aligned (2))) = dobject_Bb_DL_000D40;
#endif
#define dobject_Bb_DL_000E08 "__OTR__objects/object_Bb/object_Bb_DL_000E08"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_DL_000E08[] = dobject_Bb_DL_000E08;
#else
static const char object_Bb_DL_000E08[] __attribute__((aligned (2))) = dobject_Bb_DL_000E08;
#endif
#define dobject_Bb_DL_001100 "__OTR__objects/object_Bb/object_Bb_DL_001100"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_DL_001100[] = dobject_Bb_DL_001100;
#else
static const char object_Bb_DL_001100[] __attribute__((aligned (2))) = dobject_Bb_DL_001100;
#endif
#define dobject_Bb_DL_001190 "__OTR__objects/object_Bb/object_Bb_DL_001190"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_DL_001190[] = dobject_Bb_DL_001190;
#else
static const char object_Bb_DL_001190[] __attribute__((aligned (2))) = dobject_Bb_DL_001190;
#endif
#define dobject_Bb_Tex_001220 "__OTR__objects/object_Bb/object_Bb_Tex_001220"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Tex_001220[] = dobject_Bb_Tex_001220;
#else
static const char object_Bb_Tex_001220[] __attribute__((aligned (2))) = dobject_Bb_Tex_001220;
#endif
#define dobject_Bb_Tex_001420 "__OTR__objects/object_Bb/object_Bb_Tex_001420"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Tex_001420[] = dobject_Bb_Tex_001420;
#else
static const char object_Bb_Tex_001420[] __attribute__((aligned (2))) = dobject_Bb_Tex_001420;
#endif
#define dobject_Bb_Tex_0014A0 "__OTR__objects/object_Bb/object_Bb_Tex_0014A0"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Tex_0014A0[] = dobject_Bb_Tex_0014A0;
#else
static const char object_Bb_Tex_0014A0[] __attribute__((aligned (2))) = dobject_Bb_Tex_0014A0;
#endif
#define dobject_Bb_Tex_0014C0 "__OTR__objects/object_Bb/object_Bb_Tex_0014C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Tex_0014C0[] = dobject_Bb_Tex_0014C0;
#else
static const char object_Bb_Tex_0014C0[] __attribute__((aligned (2))) = dobject_Bb_Tex_0014C0;
#endif
#define dobject_Bb_Tex_001540 "__OTR__objects/object_Bb/object_Bb_Tex_001540"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Tex_001540[] = dobject_Bb_Tex_001540;
#else
static const char object_Bb_Tex_001540[] __attribute__((aligned (2))) = dobject_Bb_Tex_001540;
#endif
#define dobject_Bb_Tex_0015C0 "__OTR__objects/object_Bb/object_Bb_Tex_0015C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Tex_0015C0[] = dobject_Bb_Tex_0015C0;
#else
static const char object_Bb_Tex_0015C0[] __attribute__((aligned (2))) = dobject_Bb_Tex_0015C0;
#endif
#define dobject_Bb_Tex_001640 "__OTR__objects/object_Bb/object_Bb_Tex_001640"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Tex_001640[] = dobject_Bb_Tex_001640;
#else
static const char object_Bb_Tex_001640[] __attribute__((aligned (2))) = dobject_Bb_Tex_001640;
#endif
#define dobject_Bb_Tex_001740 "__OTR__objects/object_Bb/object_Bb_Tex_001740"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Tex_001740[] = dobject_Bb_Tex_001740;
#else
static const char object_Bb_Tex_001740[] __attribute__((aligned (2))) = dobject_Bb_Tex_001740;
#endif
#define dobject_Bb_Skel_001A30 "__OTR__objects/object_Bb/object_Bb_Skel_001A30"
#ifdef _WIN32
static const __declspec(align(2)) char object_Bb_Skel_001A30[] = dobject_Bb_Skel_001A30;
#else
static const char object_Bb_Skel_001A30[] __attribute__((aligned (2))) = dobject_Bb_Skel_001A30;
#endif
+254
View File
@@ -0,0 +1,254 @@
#pragma once
#define dobject_ahg_Skel_0000F0 "__OTR__objects/object_ahg/object_ahg_Skel_0000F0"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Skel_0000F0[] = dobject_ahg_Skel_0000F0;
#else
static const char object_ahg_Skel_0000F0[] __attribute__((aligned (2))) = dobject_ahg_Skel_0000F0;
#endif
#define dobject_ahg_TLUT_0000FC "__OTR__objects/object_ahg/object_ahg_TLUT_0000FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_TLUT_0000FC[] = dobject_ahg_TLUT_0000FC;
#else
static const char object_ahg_TLUT_0000FC[] __attribute__((aligned (2))) = dobject_ahg_TLUT_0000FC;
#endif
#define dobject_ahg_Tex_0002FC "__OTR__objects/object_ahg/object_ahg_Tex_0002FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_0002FC[] = dobject_ahg_Tex_0002FC;
#else
static const char object_ahg_Tex_0002FC[] __attribute__((aligned (2))) = dobject_ahg_Tex_0002FC;
#endif
#define dobject_ahg_Tex_0003FC "__OTR__objects/object_ahg/object_ahg_Tex_0003FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_0003FC[] = dobject_ahg_Tex_0003FC;
#else
static const char object_ahg_Tex_0003FC[] __attribute__((aligned (2))) = dobject_ahg_Tex_0003FC;
#endif
#define dobject_ahg_Tex_0004FC "__OTR__objects/object_ahg/object_ahg_Tex_0004FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_0004FC[] = dobject_ahg_Tex_0004FC;
#else
static const char object_ahg_Tex_0004FC[] __attribute__((aligned (2))) = dobject_ahg_Tex_0004FC;
#endif
#define dobject_ahg_Tex_00053C "__OTR__objects/object_ahg/object_ahg_Tex_00053C"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_00053C[] = dobject_ahg_Tex_00053C;
#else
static const char object_ahg_Tex_00053C[] __attribute__((aligned (2))) = dobject_ahg_Tex_00053C;
#endif
#define dobject_ahg_Tex_00057C "__OTR__objects/object_ahg/object_ahg_Tex_00057C"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_00057C[] = dobject_ahg_Tex_00057C;
#else
static const char object_ahg_Tex_00057C[] __attribute__((aligned (2))) = dobject_ahg_Tex_00057C;
#endif
#define dobject_ahg_Tex_00067C "__OTR__objects/object_ahg/object_ahg_Tex_00067C"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_00067C[] = dobject_ahg_Tex_00067C;
#else
static const char object_ahg_Tex_00067C[] __attribute__((aligned (2))) = dobject_ahg_Tex_00067C;
#endif
#define dobject_ahg_Tex_00077C "__OTR__objects/object_ahg/object_ahg_Tex_00077C"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_00077C[] = dobject_ahg_Tex_00077C;
#else
static const char object_ahg_Tex_00077C[] __attribute__((aligned (2))) = dobject_ahg_Tex_00077C;
#endif
#define dobject_ahg_Tex_00087C "__OTR__objects/object_ahg/object_ahg_Tex_00087C"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_00087C[] = dobject_ahg_Tex_00087C;
#else
static const char object_ahg_Tex_00087C[] __attribute__((aligned (2))) = dobject_ahg_Tex_00087C;
#endif
#define dobject_ahg_Tex_00097C "__OTR__objects/object_ahg/object_ahg_Tex_00097C"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_00097C[] = dobject_ahg_Tex_00097C;
#else
static const char object_ahg_Tex_00097C[] __attribute__((aligned (2))) = dobject_ahg_Tex_00097C;
#endif
#define dobject_ahg_Tex_0009BC "__OTR__objects/object_ahg/object_ahg_Tex_0009BC"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_0009BC[] = dobject_ahg_Tex_0009BC;
#else
static const char object_ahg_Tex_0009BC[] __attribute__((aligned (2))) = dobject_ahg_Tex_0009BC;
#endif
#define dobject_ahg_Tex_0009FC "__OTR__objects/object_ahg/object_ahg_Tex_0009FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_0009FC[] = dobject_ahg_Tex_0009FC;
#else
static const char object_ahg_Tex_0009FC[] __attribute__((aligned (2))) = dobject_ahg_Tex_0009FC;
#endif
#define dobject_ahg_Tex_000BFC "__OTR__objects/object_ahg/object_ahg_Tex_000BFC"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_000BFC[] = dobject_ahg_Tex_000BFC;
#else
static const char object_ahg_Tex_000BFC[] __attribute__((aligned (2))) = dobject_ahg_Tex_000BFC;
#endif
#define dobject_ahg_DL_0030F0 "__OTR__objects/object_ahg/object_ahg_DL_0030F0"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_0030F0[] = dobject_ahg_DL_0030F0;
#else
static const char object_ahg_DL_0030F0[] __attribute__((aligned (2))) = dobject_ahg_DL_0030F0;
#endif
#define dobject_ahg_DL_003500 "__OTR__objects/object_ahg/object_ahg_DL_003500"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_003500[] = dobject_ahg_DL_003500;
#else
static const char object_ahg_DL_003500[] __attribute__((aligned (2))) = dobject_ahg_DL_003500;
#endif
#define dobject_ahg_DL_003670 "__OTR__objects/object_ahg/object_ahg_DL_003670"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_003670[] = dobject_ahg_DL_003670;
#else
static const char object_ahg_DL_003670[] __attribute__((aligned (2))) = dobject_ahg_DL_003670;
#endif
#define dobject_ahg_DL_0037A0 "__OTR__objects/object_ahg/object_ahg_DL_0037A0"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_0037A0[] = dobject_ahg_DL_0037A0;
#else
static const char object_ahg_DL_0037A0[] __attribute__((aligned (2))) = dobject_ahg_DL_0037A0;
#endif
#define dobject_ahg_DL_0038D8 "__OTR__objects/object_ahg/object_ahg_DL_0038D8"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_0038D8[] = dobject_ahg_DL_0038D8;
#else
static const char object_ahg_DL_0038D8[] __attribute__((aligned (2))) = dobject_ahg_DL_0038D8;
#endif
#define dobject_ahg_DL_003A48 "__OTR__objects/object_ahg/object_ahg_DL_003A48"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_003A48[] = dobject_ahg_DL_003A48;
#else
static const char object_ahg_DL_003A48[] __attribute__((aligned (2))) = dobject_ahg_DL_003A48;
#endif
#define dobject_ahg_DL_003B78 "__OTR__objects/object_ahg/object_ahg_DL_003B78"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_003B78[] = dobject_ahg_DL_003B78;
#else
static const char object_ahg_DL_003B78[] __attribute__((aligned (2))) = dobject_ahg_DL_003B78;
#endif
#define dobject_ahg_DL_003CB0 "__OTR__objects/object_ahg/object_ahg_DL_003CB0"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_003CB0[] = dobject_ahg_DL_003CB0;
#else
static const char object_ahg_DL_003CB0[] __attribute__((aligned (2))) = dobject_ahg_DL_003CB0;
#endif
#define dobject_ahg_DL_003ED8 "__OTR__objects/object_ahg/object_ahg_DL_003ED8"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_003ED8[] = dobject_ahg_DL_003ED8;
#else
static const char object_ahg_DL_003ED8[] __attribute__((aligned (2))) = dobject_ahg_DL_003ED8;
#endif
#define dobject_ahg_DL_004018 "__OTR__objects/object_ahg/object_ahg_DL_004018"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_004018[] = dobject_ahg_DL_004018;
#else
static const char object_ahg_DL_004018[] __attribute__((aligned (2))) = dobject_ahg_DL_004018;
#endif
#define dobject_ahg_DL_004148 "__OTR__objects/object_ahg/object_ahg_DL_004148"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_004148[] = dobject_ahg_DL_004148;
#else
static const char object_ahg_DL_004148[] __attribute__((aligned (2))) = dobject_ahg_DL_004148;
#endif
#define dobject_ahg_DL_004280 "__OTR__objects/object_ahg/object_ahg_DL_004280"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_004280[] = dobject_ahg_DL_004280;
#else
static const char object_ahg_DL_004280[] __attribute__((aligned (2))) = dobject_ahg_DL_004280;
#endif
#define dobject_ahg_DL_0043C0 "__OTR__objects/object_ahg/object_ahg_DL_0043C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_0043C0[] = dobject_ahg_DL_0043C0;
#else
static const char object_ahg_DL_0043C0[] __attribute__((aligned (2))) = dobject_ahg_DL_0043C0;
#endif
#define dobject_ahg_DL_0044F0 "__OTR__objects/object_ahg/object_ahg_DL_0044F0"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_0044F0[] = dobject_ahg_DL_0044F0;
#else
static const char object_ahg_DL_0044F0[] __attribute__((aligned (2))) = dobject_ahg_DL_0044F0;
#endif
#define dobject_ahg_DL_004628 "__OTR__objects/object_ahg/object_ahg_DL_004628"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_004628[] = dobject_ahg_DL_004628;
#else
static const char object_ahg_DL_004628[] __attribute__((aligned (2))) = dobject_ahg_DL_004628;
#endif
#define dobject_ahg_TLUT_0047C8 "__OTR__objects/object_ahg/object_ahg_TLUT_0047C8"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_TLUT_0047C8[] = dobject_ahg_TLUT_0047C8;
#else
static const char object_ahg_TLUT_0047C8[] __attribute__((aligned (2))) = dobject_ahg_TLUT_0047C8;
#endif
#define dobject_ahg_Tex_004948 "__OTR__objects/object_ahg/object_ahg_Tex_004948"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_004948[] = dobject_ahg_Tex_004948;
#else
static const char object_ahg_Tex_004948[] __attribute__((aligned (2))) = dobject_ahg_Tex_004948;
#endif
#define dobject_ahg_Tex_004988 "__OTR__objects/object_ahg/object_ahg_Tex_004988"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_004988[] = dobject_ahg_Tex_004988;
#else
static const char object_ahg_Tex_004988[] __attribute__((aligned (2))) = dobject_ahg_Tex_004988;
#endif
#define dobject_ahg_Tex_004B88 "__OTR__objects/object_ahg/object_ahg_Tex_004B88"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_004B88[] = dobject_ahg_Tex_004B88;
#else
static const char object_ahg_Tex_004B88[] __attribute__((aligned (2))) = dobject_ahg_Tex_004B88;
#endif
#define dobject_ahg_Tex_004C88 "__OTR__objects/object_ahg/object_ahg_Tex_004C88"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_Tex_004C88[] = dobject_ahg_Tex_004C88;
#else
static const char object_ahg_Tex_004C88[] __attribute__((aligned (2))) = dobject_ahg_Tex_004C88;
#endif
#define dobject_ahg_DL_005508 "__OTR__objects/object_ahg/object_ahg_DL_005508"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_005508[] = dobject_ahg_DL_005508;
#else
static const char object_ahg_DL_005508[] __attribute__((aligned (2))) = dobject_ahg_DL_005508;
#endif
#define dobject_ahg_DL_005728 "__OTR__objects/object_ahg/object_ahg_DL_005728"
#ifdef _WIN32
static const __declspec(align(2)) char object_ahg_DL_005728[] = dobject_ahg_DL_005728;
#else
static const char object_ahg_DL_005728[] __attribute__((aligned (2))) = dobject_ahg_DL_005728;
#endif
+156
View File
@@ -0,0 +1,156 @@
#pragma once
#define dgArmosSkel "__OTR__objects/object_am/gArmosSkel"
#ifdef _WIN32
static const __declspec(align(2)) char gArmosSkel[] = dgArmosSkel;
#else
static const char gArmosSkel[] __attribute__((aligned (2))) = dgArmosSkel;
#endif
#define dgArmosRicochetAnim "__OTR__objects/object_am/gArmosRicochetAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gArmosRicochetAnim[] = dgArmosRicochetAnim;
#else
static const char gArmosRicochetAnim[] __attribute__((aligned (2))) = dgArmosRicochetAnim;
#endif
#define dgArmosHopAnim "__OTR__objects/object_am/gArmosHopAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gArmosHopAnim[] = dgArmosHopAnim;
#else
static const char gArmosHopAnim[] __attribute__((aligned (2))) = dgArmosHopAnim;
#endif
#define dgArmosDamagedAnim "__OTR__objects/object_am/gArmosDamagedAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gArmosDamagedAnim[] = dgArmosDamagedAnim;
#else
static const char gArmosDamagedAnim[] __attribute__((aligned (2))) = dgArmosDamagedAnim;
#endif
#define dgArmosCol "__OTR__objects/object_am/gArmosCol"
#ifdef _WIN32
static const __declspec(align(2)) char gArmosCol[] = dgArmosCol;
#else
static const char gArmosCol[] __attribute__((aligned (2))) = dgArmosCol;
#endif
#define dgArmosSkelLimbsLimb_00589CDL_0016C8 "__OTR__objects/object_am/gArmosSkelLimbsLimb_00589CDL_0016C8"
#ifdef _WIN32
static const __declspec(align(2)) char gArmosSkelLimbsLimb_00589CDL_0016C8[] = dgArmosSkelLimbsLimb_00589CDL_0016C8;
#else
static const char gArmosSkelLimbsLimb_00589CDL_0016C8[] __attribute__((aligned (2))) = dgArmosSkelLimbsLimb_00589CDL_0016C8;
#endif
#define dgArmosSkelLimbsLimb_0058C0DL_002550 "__OTR__objects/object_am/gArmosSkelLimbsLimb_0058C0DL_002550"
#ifdef _WIN32
static const __declspec(align(2)) char gArmosSkelLimbsLimb_0058C0DL_002550[] = dgArmosSkelLimbsLimb_0058C0DL_002550;
#else
static const char gArmosSkelLimbsLimb_0058C0DL_002550[] __attribute__((aligned (2))) = dgArmosSkelLimbsLimb_0058C0DL_002550;
#endif
#define dgArmosSkelLimbsLimb_0058E4DL_002278 "__OTR__objects/object_am/gArmosSkelLimbsLimb_0058E4DL_002278"
#ifdef _WIN32
static const __declspec(align(2)) char gArmosSkelLimbsLimb_0058E4DL_002278[] = dgArmosSkelLimbsLimb_0058E4DL_002278;
#else
static const char gArmosSkelLimbsLimb_0058E4DL_002278[] __attribute__((aligned (2))) = dgArmosSkelLimbsLimb_0058E4DL_002278;
#endif
#define dgArmosSkelLimbsLimb_005908DL_0005D0 "__OTR__objects/object_am/gArmosSkelLimbsLimb_005908DL_0005D0"
#ifdef _WIN32
static const __declspec(align(2)) char gArmosSkelLimbsLimb_005908DL_0005D0[] = dgArmosSkelLimbsLimb_005908DL_0005D0;
#else
static const char gArmosSkelLimbsLimb_005908DL_0005D0[] __attribute__((aligned (2))) = dgArmosSkelLimbsLimb_005908DL_0005D0;
#endif
#define dobject_amTex_002638 "__OTR__objects/object_am/object_amTex_002638"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_002638[] = dobject_amTex_002638;
#else
static const char object_amTex_002638[] __attribute__((aligned (2))) = dobject_amTex_002638;
#endif
#define dobject_amTex_003C38 "__OTR__objects/object_am/object_amTex_003C38"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_003C38[] = dobject_amTex_003C38;
#else
static const char object_amTex_003C38[] __attribute__((aligned (2))) = dobject_amTex_003C38;
#endif
#define dobject_amTex_003238 "__OTR__objects/object_am/object_amTex_003238"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_003238[] = dobject_amTex_003238;
#else
static const char object_amTex_003238[] __attribute__((aligned (2))) = dobject_amTex_003238;
#endif
#define dobject_amTex_002838 "__OTR__objects/object_am/object_amTex_002838"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_002838[] = dobject_amTex_002838;
#else
static const char object_amTex_002838[] __attribute__((aligned (2))) = dobject_amTex_002838;
#endif
#define dobject_amTex_004C38 "__OTR__objects/object_am/object_amTex_004C38"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_004C38[] = dobject_amTex_004C38;
#else
static const char object_amTex_004C38[] __attribute__((aligned (2))) = dobject_amTex_004C38;
#endif
#define dobject_amTex_003A38 "__OTR__objects/object_am/object_amTex_003A38"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_003A38[] = dobject_amTex_003A38;
#else
static const char object_amTex_003A38[] __attribute__((aligned (2))) = dobject_amTex_003A38;
#endif
#define dobject_amTex_003038 "__OTR__objects/object_am/object_amTex_003038"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_003038[] = dobject_amTex_003038;
#else
static const char object_amTex_003038[] __attribute__((aligned (2))) = dobject_amTex_003038;
#endif
#define dobject_amTex_004438 "__OTR__objects/object_am/object_amTex_004438"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_004438[] = dobject_amTex_004438;
#else
static const char object_amTex_004438[] __attribute__((aligned (2))) = dobject_amTex_004438;
#endif
#define dobject_amTex_002938 "__OTR__objects/object_am/object_amTex_002938"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_002938[] = dobject_amTex_002938;
#else
static const char object_amTex_002938[] __attribute__((aligned (2))) = dobject_amTex_002938;
#endif
#define dobject_amTex_002D38 "__OTR__objects/object_am/object_amTex_002D38"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_002D38[] = dobject_amTex_002D38;
#else
static const char object_amTex_002D38[] __attribute__((aligned (2))) = dobject_amTex_002D38;
#endif
#define dobject_amTex_002E38 "__OTR__objects/object_am/object_amTex_002E38"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_002E38[] = dobject_amTex_002E38;
#else
static const char object_amTex_002E38[] __attribute__((aligned (2))) = dobject_amTex_002E38;
#endif
#define dobject_amTex_005478 "__OTR__objects/object_am/object_amTex_005478"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_005478[] = dobject_amTex_005478;
#else
static const char object_amTex_005478[] __attribute__((aligned (2))) = dobject_amTex_005478;
#endif
#define dobject_amTex_005438 "__OTR__objects/object_am/object_amTex_005438"
#ifdef _WIN32
static const __declspec(align(2)) char object_amTex_005438[] = dobject_amTex_005438;
#else
static const char object_amTex_005438[] __attribute__((aligned (2))) = dobject_amTex_005438;
#endif
+205
View File
@@ -0,0 +1,205 @@
#pragma once
#define dgCuccoLadySkel "__OTR__objects/object_ane/gCuccoLadySkel"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadySkel[] = dgCuccoLadySkel;
#else
static const char gCuccoLadySkel[] __attribute__((aligned (2))) = dgCuccoLadySkel;
#endif
#define dgCuccoLadyDressDL "__OTR__objects/object_ane/gCuccoLadyDressDL"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyDressDL[] = dgCuccoLadyDressDL;
#else
static const char gCuccoLadyDressDL[] __attribute__((aligned (2))) = dgCuccoLadyDressDL;
#endif
#define dgCuccoLadyDL_6D20 "__OTR__objects/object_ane/gCuccoLadyDL_6D20"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyDL_6D20[] = dgCuccoLadyDL_6D20;
#else
static const char gCuccoLadyDL_6D20[] __attribute__((aligned (2))) = dgCuccoLadyDL_6D20;
#endif
#define dgCuccoLadyDL_6C38 "__OTR__objects/object_ane/gCuccoLadyDL_6C38"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyDL_6C38[] = dgCuccoLadyDL_6C38;
#else
static const char gCuccoLadyDL_6C38[] __attribute__((aligned (2))) = dgCuccoLadyDL_6C38;
#endif
#define dgCuccoLadyShoe1DL "__OTR__objects/object_ane/gCuccoLadyShoe1DL"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyShoe1DL[] = dgCuccoLadyShoe1DL;
#else
static const char gCuccoLadyShoe1DL[] __attribute__((aligned (2))) = dgCuccoLadyShoe1DL;
#endif
#define dgCuccoLadyDL_68E0 "__OTR__objects/object_ane/gCuccoLadyDL_68E0"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyDL_68E0[] = dgCuccoLadyDL_68E0;
#else
static const char gCuccoLadyDL_68E0[] __attribute__((aligned (2))) = dgCuccoLadyDL_68E0;
#endif
#define dgCuccoLadyDL_67F8 "__OTR__objects/object_ane/gCuccoLadyDL_67F8"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyDL_67F8[] = dgCuccoLadyDL_67F8;
#else
static const char gCuccoLadyDL_67F8[] __attribute__((aligned (2))) = dgCuccoLadyDL_67F8;
#endif
#define dgCuccoLadyShoe2DL "__OTR__objects/object_ane/gCuccoLadyShoe2DL"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyShoe2DL[] = dgCuccoLadyShoe2DL;
#else
static const char gCuccoLadyShoe2DL[] __attribute__((aligned (2))) = dgCuccoLadyShoe2DL;
#endif
#define dgCuccoLadyTorsoDL "__OTR__objects/object_ane/gCuccoLadyTorsoDL"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyTorsoDL[] = dgCuccoLadyTorsoDL;
#else
static const char gCuccoLadyTorsoDL[] __attribute__((aligned (2))) = dgCuccoLadyTorsoDL;
#endif
#define dgCuccoLadyDL_6148 "__OTR__objects/object_ane/gCuccoLadyDL_6148"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyDL_6148[] = dgCuccoLadyDL_6148;
#else
static const char gCuccoLadyDL_6148[] __attribute__((aligned (2))) = dgCuccoLadyDL_6148;
#endif
#define dgCuccoLadyDL_6018 "__OTR__objects/object_ane/gCuccoLadyDL_6018"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyDL_6018[] = dgCuccoLadyDL_6018;
#else
static const char gCuccoLadyDL_6018[] __attribute__((aligned (2))) = dgCuccoLadyDL_6018;
#endif
#define dgCuccoLadyDL_5E28 "__OTR__objects/object_ane/gCuccoLadyDL_5E28"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyDL_5E28[] = dgCuccoLadyDL_5E28;
#else
static const char gCuccoLadyDL_5E28[] __attribute__((aligned (2))) = dgCuccoLadyDL_5E28;
#endif
#define dgCuccoLadyDL_5CF0 "__OTR__objects/object_ane/gCuccoLadyDL_5CF0"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyDL_5CF0[] = dgCuccoLadyDL_5CF0;
#else
static const char gCuccoLadyDL_5CF0[] __attribute__((aligned (2))) = dgCuccoLadyDL_5CF0;
#endif
#define dgCuccoLadyDL_5BC0 "__OTR__objects/object_ane/gCuccoLadyDL_5BC0"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyDL_5BC0[] = dgCuccoLadyDL_5BC0;
#else
static const char gCuccoLadyDL_5BC0[] __attribute__((aligned (2))) = dgCuccoLadyDL_5BC0;
#endif
#define dgCuccoLadyDL_59D0 "__OTR__objects/object_ane/gCuccoLadyDL_59D0"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyDL_59D0[] = dgCuccoLadyDL_59D0;
#else
static const char gCuccoLadyDL_59D0[] __attribute__((aligned (2))) = dgCuccoLadyDL_59D0;
#endif
#define dgCuccoLadyHeadDL "__OTR__objects/object_ane/gCuccoLadyHeadDL"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyHeadDL[] = dgCuccoLadyHeadDL;
#else
static const char gCuccoLadyHeadDL[] __attribute__((aligned (2))) = dgCuccoLadyHeadDL;
#endif
#define dgCuccoLadyTLUT "__OTR__objects/object_ane/gCuccoLadyTLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyTLUT[] = dgCuccoLadyTLUT;
#else
static const char gCuccoLadyTLUT[] __attribute__((aligned (2))) = dgCuccoLadyTLUT;
#endif
#define dgCuccoLadyHairTex "__OTR__objects/object_ane/gCuccoLadyHairTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyHairTex[] = dgCuccoLadyHairTex;
#else
static const char gCuccoLadyHairTex[] __attribute__((aligned (2))) = dgCuccoLadyHairTex;
#endif
#define dgCuccoLadyTex_0388 "__OTR__objects/object_ane/gCuccoLadyTex_0388"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyTex_0388[] = dgCuccoLadyTex_0388;
#else
static const char gCuccoLadyTex_0388[] __attribute__((aligned (2))) = dgCuccoLadyTex_0388;
#endif
#define dgCuccoLadyEarTex "__OTR__objects/object_ane/gCuccoLadyEarTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyEarTex[] = dgCuccoLadyEarTex;
#else
static const char gCuccoLadyEarTex[] __attribute__((aligned (2))) = dgCuccoLadyEarTex;
#endif
#define dgCuccoLadyMouthTex "__OTR__objects/object_ane/gCuccoLadyMouthTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyMouthTex[] = dgCuccoLadyMouthTex;
#else
static const char gCuccoLadyMouthTex[] __attribute__((aligned (2))) = dgCuccoLadyMouthTex;
#endif
#define dgCuccoLadyBackOfHandTex "__OTR__objects/object_ane/gCuccoLadyBackOfHandTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyBackOfHandTex[] = dgCuccoLadyBackOfHandTex;
#else
static const char gCuccoLadyBackOfHandTex[] __attribute__((aligned (2))) = dgCuccoLadyBackOfHandTex;
#endif
#define dgCuccoLadySleeveTex "__OTR__objects/object_ane/gCuccoLadySleeveTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadySleeveTex[] = dgCuccoLadySleeveTex;
#else
static const char gCuccoLadySleeveTex[] __attribute__((aligned (2))) = dgCuccoLadySleeveTex;
#endif
#define dgCuccoLadyShirtButtonTex "__OTR__objects/object_ane/gCuccoLadyShirtButtonTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyShirtButtonTex[] = dgCuccoLadyShirtButtonTex;
#else
static const char gCuccoLadyShirtButtonTex[] __attribute__((aligned (2))) = dgCuccoLadyShirtButtonTex;
#endif
#define dgCuccoLadyWaistTex "__OTR__objects/object_ane/gCuccoLadyWaistTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyWaistTex[] = dgCuccoLadyWaistTex;
#else
static const char gCuccoLadyWaistTex[] __attribute__((aligned (2))) = dgCuccoLadyWaistTex;
#endif
#define dgCuccoLadySkirtTex "__OTR__objects/object_ane/gCuccoLadySkirtTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadySkirtTex[] = dgCuccoLadySkirtTex;
#else
static const char gCuccoLadySkirtTex[] __attribute__((aligned (2))) = dgCuccoLadySkirtTex;
#endif
#define dgCuccoLadyEyeOpenTex "__OTR__objects/object_ane/gCuccoLadyEyeOpenTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyEyeOpenTex[] = dgCuccoLadyEyeOpenTex;
#else
static const char gCuccoLadyEyeOpenTex[] __attribute__((aligned (2))) = dgCuccoLadyEyeOpenTex;
#endif
#define dgCuccoLadyEyeHalfTex "__OTR__objects/object_ane/gCuccoLadyEyeHalfTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyEyeHalfTex[] = dgCuccoLadyEyeHalfTex;
#else
static const char gCuccoLadyEyeHalfTex[] __attribute__((aligned (2))) = dgCuccoLadyEyeHalfTex;
#endif
#define dgCuccoLadyEyeClosedTex "__OTR__objects/object_ane/gCuccoLadyEyeClosedTex"
#ifdef _WIN32
static const __declspec(align(2)) char gCuccoLadyEyeClosedTex[] = dgCuccoLadyEyeClosedTex;
#else
static const char gCuccoLadyEyeClosedTex[] __attribute__((aligned (2))) = dgCuccoLadyEyeClosedTex;
#endif
+233
View File
@@ -0,0 +1,233 @@
#pragma once
#define dgRoofManSkel "__OTR__objects/object_ani/gRoofManSkel"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManSkel[] = dgRoofManSkel;
#else
static const char gRoofManSkel[] __attribute__((aligned (2))) = dgRoofManSkel;
#endif
#define dgRoofManWaistDL "__OTR__objects/object_ani/gRoofManWaistDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManWaistDL[] = dgRoofManWaistDL;
#else
static const char gRoofManWaistDL[] __attribute__((aligned (2))) = dgRoofManWaistDL;
#endif
#define dgRoofManLeftThighDL "__OTR__objects/object_ani/gRoofManLeftThighDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManLeftThighDL[] = dgRoofManLeftThighDL;
#else
static const char gRoofManLeftThighDL[] __attribute__((aligned (2))) = dgRoofManLeftThighDL;
#endif
#define dgRoofManLeftLegDL "__OTR__objects/object_ani/gRoofManLeftLegDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManLeftLegDL[] = dgRoofManLeftLegDL;
#else
static const char gRoofManLeftLegDL[] __attribute__((aligned (2))) = dgRoofManLeftLegDL;
#endif
#define dgRoofManLeftFootDL "__OTR__objects/object_ani/gRoofManLeftFootDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManLeftFootDL[] = dgRoofManLeftFootDL;
#else
static const char gRoofManLeftFootDL[] __attribute__((aligned (2))) = dgRoofManLeftFootDL;
#endif
#define dgRoofManRightThighDL "__OTR__objects/object_ani/gRoofManRightThighDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManRightThighDL[] = dgRoofManRightThighDL;
#else
static const char gRoofManRightThighDL[] __attribute__((aligned (2))) = dgRoofManRightThighDL;
#endif
#define dgRoofManRightLegDL "__OTR__objects/object_ani/gRoofManRightLegDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManRightLegDL[] = dgRoofManRightLegDL;
#else
static const char gRoofManRightLegDL[] __attribute__((aligned (2))) = dgRoofManRightLegDL;
#endif
#define dgRoofManRightFootDL "__OTR__objects/object_ani/gRoofManRightFootDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManRightFootDL[] = dgRoofManRightFootDL;
#else
static const char gRoofManRightFootDL[] __attribute__((aligned (2))) = dgRoofManRightFootDL;
#endif
#define dgRoofManTorsoDL "__OTR__objects/object_ani/gRoofManTorsoDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManTorsoDL[] = dgRoofManTorsoDL;
#else
static const char gRoofManTorsoDL[] __attribute__((aligned (2))) = dgRoofManTorsoDL;
#endif
#define dgRoofManLeftUpperArmDL "__OTR__objects/object_ani/gRoofManLeftUpperArmDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManLeftUpperArmDL[] = dgRoofManLeftUpperArmDL;
#else
static const char gRoofManLeftUpperArmDL[] __attribute__((aligned (2))) = dgRoofManLeftUpperArmDL;
#endif
#define dgRoofManLeftForearmDL "__OTR__objects/object_ani/gRoofManLeftForearmDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManLeftForearmDL[] = dgRoofManLeftForearmDL;
#else
static const char gRoofManLeftForearmDL[] __attribute__((aligned (2))) = dgRoofManLeftForearmDL;
#endif
#define dgRoofManLeftHandDL "__OTR__objects/object_ani/gRoofManLeftHandDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManLeftHandDL[] = dgRoofManLeftHandDL;
#else
static const char gRoofManLeftHandDL[] __attribute__((aligned (2))) = dgRoofManLeftHandDL;
#endif
#define dgRoofManRightUpperArmDL "__OTR__objects/object_ani/gRoofManRightUpperArmDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManRightUpperArmDL[] = dgRoofManRightUpperArmDL;
#else
static const char gRoofManRightUpperArmDL[] __attribute__((aligned (2))) = dgRoofManRightUpperArmDL;
#endif
#define dgRoofManRightForearmDL "__OTR__objects/object_ani/gRoofManRightForearmDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManRightForearmDL[] = dgRoofManRightForearmDL;
#else
static const char gRoofManRightForearmDL[] __attribute__((aligned (2))) = dgRoofManRightForearmDL;
#endif
#define dgRoofManRightHandDL "__OTR__objects/object_ani/gRoofManRightHandDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManRightHandDL[] = dgRoofManRightHandDL;
#else
static const char gRoofManRightHandDL[] __attribute__((aligned (2))) = dgRoofManRightHandDL;
#endif
#define dgRoofManHeadDL "__OTR__objects/object_ani/gRoofManHeadDL"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManHeadDL[] = dgRoofManHeadDL;
#else
static const char gRoofManHeadDL[] __attribute__((aligned (2))) = dgRoofManHeadDL;
#endif
#define dgRoofMan1TLUT "__OTR__objects/object_ani/gRoofMan1TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofMan1TLUT[] = dgRoofMan1TLUT;
#else
static const char gRoofMan1TLUT[] __attribute__((aligned (2))) = dgRoofMan1TLUT;
#endif
#define dgRoofMan2TLUT "__OTR__objects/object_ani/gRoofMan2TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofMan2TLUT[] = dgRoofMan2TLUT;
#else
static const char gRoofMan2TLUT[] __attribute__((aligned (2))) = dgRoofMan2TLUT;
#endif
#define dgRoofManHandBackTex "__OTR__objects/object_ani/gRoofManHandBackTex"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManHandBackTex[] = dgRoofManHandBackTex;
#else
static const char gRoofManHandBackTex[] __attribute__((aligned (2))) = dgRoofManHandBackTex;
#endif
#define dgRoofManForearmGradientTex "__OTR__objects/object_ani/gRoofManForearmGradientTex"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManForearmGradientTex[] = dgRoofManForearmGradientTex;
#else
static const char gRoofManForearmGradientTex[] __attribute__((aligned (2))) = dgRoofManForearmGradientTex;
#endif
#define dgRoofManThighGradientTex "__OTR__objects/object_ani/gRoofManThighGradientTex"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManThighGradientTex[] = dgRoofManThighGradientTex;
#else
static const char gRoofManThighGradientTex[] __attribute__((aligned (2))) = dgRoofManThighGradientTex;
#endif
#define dgRoofManSandalBuckleTex "__OTR__objects/object_ani/gRoofManSandalBuckleTex"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManSandalBuckleTex[] = dgRoofManSandalBuckleTex;
#else
static const char gRoofManSandalBuckleTex[] __attribute__((aligned (2))) = dgRoofManSandalBuckleTex;
#endif
#define dgRoofManTrouserPatternTex "__OTR__objects/object_ani/gRoofManTrouserPatternTex"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManTrouserPatternTex[] = dgRoofManTrouserPatternTex;
#else
static const char gRoofManTrouserPatternTex[] __attribute__((aligned (2))) = dgRoofManTrouserPatternTex;
#endif
#define dgRoofManSkinGradientTex "__OTR__objects/object_ani/gRoofManSkinGradientTex"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManSkinGradientTex[] = dgRoofManSkinGradientTex;
#else
static const char gRoofManSkinGradientTex[] __attribute__((aligned (2))) = dgRoofManSkinGradientTex;
#endif
#define dgRoofManEarTex "__OTR__objects/object_ani/gRoofManEarTex"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManEarTex[] = dgRoofManEarTex;
#else
static const char gRoofManEarTex[] __attribute__((aligned (2))) = dgRoofManEarTex;
#endif
#define dgRoofManHairTex "__OTR__objects/object_ani/gRoofManHairTex"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManHairTex[] = dgRoofManHairTex;
#else
static const char gRoofManHairTex[] __attribute__((aligned (2))) = dgRoofManHairTex;
#endif
#define dgRoofManEyeOpenTex "__OTR__objects/object_ani/gRoofManEyeOpenTex"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManEyeOpenTex[] = dgRoofManEyeOpenTex;
#else
static const char gRoofManEyeOpenTex[] __attribute__((aligned (2))) = dgRoofManEyeOpenTex;
#endif
#define dgRoofManEyeHalfTex "__OTR__objects/object_ani/gRoofManEyeHalfTex"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManEyeHalfTex[] = dgRoofManEyeHalfTex;
#else
static const char gRoofManEyeHalfTex[] __attribute__((aligned (2))) = dgRoofManEyeHalfTex;
#endif
#define dgRoofManEyeClosedTex "__OTR__objects/object_ani/gRoofManEyeClosedTex"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManEyeClosedTex[] = dgRoofManEyeClosedTex;
#else
static const char gRoofManEyeClosedTex[] __attribute__((aligned (2))) = dgRoofManEyeClosedTex;
#endif
#define dgRoofManKnockbackAnim "__OTR__objects/object_ani/gRoofManKnockbackAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManKnockbackAnim[] = dgRoofManKnockbackAnim;
#else
static const char gRoofManKnockbackAnim[] __attribute__((aligned (2))) = dgRoofManKnockbackAnim;
#endif
#define dgRoofManGettingUpAfterKnockbackAnim "__OTR__objects/object_ani/gRoofManGettingUpAfterKnockbackAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManGettingUpAfterKnockbackAnim[] = dgRoofManGettingUpAfterKnockbackAnim;
#else
static const char gRoofManGettingUpAfterKnockbackAnim[] __attribute__((aligned (2))) = dgRoofManGettingUpAfterKnockbackAnim;
#endif
#define dgRoofManIdleAnim "__OTR__objects/object_ani/gRoofManIdleAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gRoofManIdleAnim[] = dgRoofManIdleAnim;
#else
static const char gRoofManIdleAnim[] __attribute__((aligned (2))) = dgRoofManIdleAnim;
#endif
#define dobject_aniTex_0011D8 "__OTR__objects/object_ani/object_aniTex_0011D8"
#ifdef _WIN32
static const __declspec(align(2)) char object_aniTex_0011D8[] = dobject_aniTex_0011D8;
#else
static const char object_aniTex_0011D8[] __attribute__((aligned (2))) = dobject_aniTex_0011D8;
#endif
@@ -0,0 +1,205 @@
#pragma once
#define dgAnubiceSkel "__OTR__objects/object_anubice/gAnubiceSkel"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceSkel[] = dgAnubiceSkel;
#else
static const char gAnubiceSkel[] __attribute__((aligned (2))) = dgAnubiceSkel;
#endif
#define dgAnubiceFallDownAnim "__OTR__objects/object_anubice/gAnubiceFallDownAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceFallDownAnim[] = dgAnubiceFallDownAnim;
#else
static const char gAnubiceFallDownAnim[] __attribute__((aligned (2))) = dgAnubiceFallDownAnim;
#endif
#define dgAnubiceAttackingAnim "__OTR__objects/object_anubice/gAnubiceAttackingAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceAttackingAnim[] = dgAnubiceAttackingAnim;
#else
static const char gAnubiceAttackingAnim[] __attribute__((aligned (2))) = dgAnubiceAttackingAnim;
#endif
#define dgAnubiceIdleAnim "__OTR__objects/object_anubice/gAnubiceIdleAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceIdleAnim[] = dgAnubiceIdleAnim;
#else
static const char gAnubiceIdleAnim[] __attribute__((aligned (2))) = dgAnubiceIdleAnim;
#endif
#define dgAnubiceEyesDL "__OTR__objects/object_anubice/gAnubiceEyesDL"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceEyesDL[] = dgAnubiceEyesDL;
#else
static const char gAnubiceEyesDL[] __attribute__((aligned (2))) = dgAnubiceEyesDL;
#endif
#define dgAnubiceFireAttackDL "__OTR__objects/object_anubice/gAnubiceFireAttackDL"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceFireAttackDL[] = dgAnubiceFireAttackDL;
#else
static const char gAnubiceFireAttackDL[] __attribute__((aligned (2))) = dgAnubiceFireAttackDL;
#endif
#define dgAnubiceLaughingAnim "__OTR__objects/object_anubice/gAnubiceLaughingAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceLaughingAnim[] = dgAnubiceLaughingAnim;
#else
static const char gAnubiceLaughingAnim[] __attribute__((aligned (2))) = dgAnubiceLaughingAnim;
#endif
#define dgAnubiceStandUpAnim "__OTR__objects/object_anubice/gAnubiceStandUpAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceStandUpAnim[] = dgAnubiceStandUpAnim;
#else
static const char gAnubiceStandUpAnim[] __attribute__((aligned (2))) = dgAnubiceStandUpAnim;
#endif
#define dgAnubiceUnusedParticleMaterialDL "__OTR__objects/object_anubice/gAnubiceUnusedParticleMaterialDL"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceUnusedParticleMaterialDL[] = dgAnubiceUnusedParticleMaterialDL;
#else
static const char gAnubiceUnusedParticleMaterialDL[] __attribute__((aligned (2))) = dgAnubiceUnusedParticleMaterialDL;
#endif
#define dgAnubiceUnusedParticleModelDL "__OTR__objects/object_anubice/gAnubiceUnusedParticleModelDL"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceUnusedParticleModelDL[] = dgAnubiceUnusedParticleModelDL;
#else
static const char gAnubiceUnusedParticleModelDL[] __attribute__((aligned (2))) = dgAnubiceUnusedParticleModelDL;
#endif
#define dgAnubiceAnim_000A48 "__OTR__objects/object_anubice/gAnubiceAnim_000A48"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceAnim_000A48[] = dgAnubiceAnim_000A48;
#else
static const char gAnubiceAnim_000A48[] __attribute__((aligned (2))) = dgAnubiceAnim_000A48;
#endif
#define dgAnubiceAnim_000BAC "__OTR__objects/object_anubice/gAnubiceAnim_000BAC"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceAnim_000BAC[] = dgAnubiceAnim_000BAC;
#else
static const char gAnubiceAnim_000BAC[] __attribute__((aligned (2))) = dgAnubiceAnim_000BAC;
#endif
#define dgAnubiceSkelLimbsLimb_0038B8DL_002CE0 "__OTR__objects/object_anubice/gAnubiceSkelLimbsLimb_0038B8DL_002CE0"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceSkelLimbsLimb_0038B8DL_002CE0[] = dgAnubiceSkelLimbsLimb_0038B8DL_002CE0;
#else
static const char gAnubiceSkelLimbsLimb_0038B8DL_002CE0[] __attribute__((aligned (2))) = dgAnubiceSkelLimbsLimb_0038B8DL_002CE0;
#endif
#define dgAnubiceSkelLimbsLimb_0038D0DL_002E30 "__OTR__objects/object_anubice/gAnubiceSkelLimbsLimb_0038D0DL_002E30"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceSkelLimbsLimb_0038D0DL_002E30[] = dgAnubiceSkelLimbsLimb_0038D0DL_002E30;
#else
static const char gAnubiceSkelLimbsLimb_0038D0DL_002E30[] __attribute__((aligned (2))) = dgAnubiceSkelLimbsLimb_0038D0DL_002E30;
#endif
#define dgAnubiceSkelLimbsLimb_0038DCDL_002EE0 "__OTR__objects/object_anubice/gAnubiceSkelLimbsLimb_0038DCDL_002EE0"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceSkelLimbsLimb_0038DCDL_002EE0[] = dgAnubiceSkelLimbsLimb_0038DCDL_002EE0;
#else
static const char gAnubiceSkelLimbsLimb_0038DCDL_002EE0[] __attribute__((aligned (2))) = dgAnubiceSkelLimbsLimb_0038DCDL_002EE0;
#endif
#define dgAnubiceSkelLimbsLimb_0038F4DL_002F90 "__OTR__objects/object_anubice/gAnubiceSkelLimbsLimb_0038F4DL_002F90"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceSkelLimbsLimb_0038F4DL_002F90[] = dgAnubiceSkelLimbsLimb_0038F4DL_002F90;
#else
static const char gAnubiceSkelLimbsLimb_0038F4DL_002F90[] __attribute__((aligned (2))) = dgAnubiceSkelLimbsLimb_0038F4DL_002F90;
#endif
#define dgAnubiceSkelLimbsLimb_003900DL_003040 "__OTR__objects/object_anubice/gAnubiceSkelLimbsLimb_003900DL_003040"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceSkelLimbsLimb_003900DL_003040[] = dgAnubiceSkelLimbsLimb_003900DL_003040;
#else
static const char gAnubiceSkelLimbsLimb_003900DL_003040[] __attribute__((aligned (2))) = dgAnubiceSkelLimbsLimb_003900DL_003040;
#endif
#define dgAnubiceSkelLimbsLimb_003918DL_003108 "__OTR__objects/object_anubice/gAnubiceSkelLimbsLimb_003918DL_003108"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceSkelLimbsLimb_003918DL_003108[] = dgAnubiceSkelLimbsLimb_003918DL_003108;
#else
static const char gAnubiceSkelLimbsLimb_003918DL_003108[] __attribute__((aligned (2))) = dgAnubiceSkelLimbsLimb_003918DL_003108;
#endif
#define dgAnubiceSkelLimbsLimb_003930DL_003288 "__OTR__objects/object_anubice/gAnubiceSkelLimbsLimb_003930DL_003288"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceSkelLimbsLimb_003930DL_003288[] = dgAnubiceSkelLimbsLimb_003930DL_003288;
#else
static const char gAnubiceSkelLimbsLimb_003930DL_003288[] __attribute__((aligned (2))) = dgAnubiceSkelLimbsLimb_003930DL_003288;
#endif
#define dgAnubiceSkelLimbsLimb_003948DL_0031A0 "__OTR__objects/object_anubice/gAnubiceSkelLimbsLimb_003948DL_0031A0"
#ifdef _WIN32
static const __declspec(align(2)) char gAnubiceSkelLimbsLimb_003948DL_0031A0[] = dgAnubiceSkelLimbsLimb_003948DL_0031A0;
#else
static const char gAnubiceSkelLimbsLimb_003948DL_0031A0[] __attribute__((aligned (2))) = dgAnubiceSkelLimbsLimb_003948DL_0031A0;
#endif
#define dobject_anubiceTex_001690 "__OTR__objects/object_anubice/object_anubiceTex_001690"
#ifdef _WIN32
static const __declspec(align(2)) char object_anubiceTex_001690[] = dobject_anubiceTex_001690;
#else
static const char object_anubiceTex_001690[] __attribute__((aligned (2))) = dobject_anubiceTex_001690;
#endif
#define dobject_anubiceTex_0036A0 "__OTR__objects/object_anubice/object_anubiceTex_0036A0"
#ifdef _WIN32
static const __declspec(align(2)) char object_anubiceTex_0036A0[] = dobject_anubiceTex_0036A0;
#else
static const char object_anubiceTex_0036A0[] __attribute__((aligned (2))) = dobject_anubiceTex_0036A0;
#endif
#define dobject_anubiceTex_001090 "__OTR__objects/object_anubice/object_anubiceTex_001090"
#ifdef _WIN32
static const __declspec(align(2)) char object_anubiceTex_001090[] = dobject_anubiceTex_001090;
#else
static const char object_anubiceTex_001090[] __attribute__((aligned (2))) = dobject_anubiceTex_001090;
#endif
#define dobject_anubiceTex_000F90 "__OTR__objects/object_anubice/object_anubiceTex_000F90"
#ifdef _WIN32
static const __declspec(align(2)) char object_anubiceTex_000F90[] = dobject_anubiceTex_000F90;
#else
static const char object_anubiceTex_000F90[] __attribute__((aligned (2))) = dobject_anubiceTex_000F90;
#endif
#define dobject_anubiceTex_001110 "__OTR__objects/object_anubice/object_anubiceTex_001110"
#ifdef _WIN32
static const __declspec(align(2)) char object_anubiceTex_001110[] = dobject_anubiceTex_001110;
#else
static const char object_anubiceTex_001110[] __attribute__((aligned (2))) = dobject_anubiceTex_001110;
#endif
#define dobject_anubiceTex_001510 "__OTR__objects/object_anubice/object_anubiceTex_001510"
#ifdef _WIN32
static const __declspec(align(2)) char object_anubiceTex_001510[] = dobject_anubiceTex_001510;
#else
static const char object_anubiceTex_001510[] __attribute__((aligned (2))) = dobject_anubiceTex_001510;
#endif
#define dobject_anubiceTex_001590 "__OTR__objects/object_anubice/object_anubiceTex_001590"
#ifdef _WIN32
static const __declspec(align(2)) char object_anubiceTex_001590[] = dobject_anubiceTex_001590;
#else
static const char object_anubiceTex_001590[] __attribute__((aligned (2))) = dobject_anubiceTex_001590;
#endif
#define dobject_anubiceTex_001610 "__OTR__objects/object_anubice/object_anubiceTex_001610"
#ifdef _WIN32
static const __declspec(align(2)) char object_anubiceTex_001610[] = dobject_anubiceTex_001610;
#else
static const char object_anubiceTex_001610[] __attribute__((aligned (2))) = dobject_anubiceTex_001610;
#endif
#define dobject_anubiceTex_001A90 "__OTR__objects/object_anubice/object_anubiceTex_001A90"
#ifdef _WIN32
static const __declspec(align(2)) char object_anubiceTex_001A90[] = dobject_anubiceTex_001A90;
#else
static const char object_anubiceTex_001A90[] __attribute__((aligned (2))) = dobject_anubiceTex_001A90;
#endif
+198
View File
@@ -0,0 +1,198 @@
#pragma once
#define dgDogLadySkel "__OTR__objects/object_aob/gDogLadySkel"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadySkel[] = dgDogLadySkel;
#else
static const char gDogLadySkel[] __attribute__((aligned (2))) = dgDogLadySkel;
#endif
#define dgDogLadyDressDL "__OTR__objects/object_aob/gDogLadyDressDL"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDressDL[] = dgDogLadyDressDL;
#else
static const char gDogLadyDressDL[] __attribute__((aligned (2))) = dgDogLadyDressDL;
#endif
#define dgDogLadyDL_54B8 "__OTR__objects/object_aob/gDogLadyDL_54B8"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_54B8[] = dgDogLadyDL_54B8;
#else
static const char gDogLadyDL_54B8[] __attribute__((aligned (2))) = dgDogLadyDL_54B8;
#endif
#define dgDogLadyDL_53E8 "__OTR__objects/object_aob/gDogLadyDL_53E8"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_53E8[] = dgDogLadyDL_53E8;
#else
static const char gDogLadyDL_53E8[] __attribute__((aligned (2))) = dgDogLadyDL_53E8;
#endif
#define dgDogLadyDL_5318 "__OTR__objects/object_aob/gDogLadyDL_5318"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_5318[] = dgDogLadyDL_5318;
#else
static const char gDogLadyDL_5318[] __attribute__((aligned (2))) = dgDogLadyDL_5318;
#endif
#define dgDogLadyDL_5248 "__OTR__objects/object_aob/gDogLadyDL_5248"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_5248[] = dgDogLadyDL_5248;
#else
static const char gDogLadyDL_5248[] __attribute__((aligned (2))) = dgDogLadyDL_5248;
#endif
#define dgDogLadyDL_5178 "__OTR__objects/object_aob/gDogLadyDL_5178"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_5178[] = dgDogLadyDL_5178;
#else
static const char gDogLadyDL_5178[] __attribute__((aligned (2))) = dgDogLadyDL_5178;
#endif
#define dgDogLadyDL_50A8 "__OTR__objects/object_aob/gDogLadyDL_50A8"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_50A8[] = dgDogLadyDL_50A8;
#else
static const char gDogLadyDL_50A8[] __attribute__((aligned (2))) = dgDogLadyDL_50A8;
#endif
#define dgDogLadyTorsoDL "__OTR__objects/object_aob/gDogLadyTorsoDL"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyTorsoDL[] = dgDogLadyTorsoDL;
#else
static const char gDogLadyTorsoDL[] __attribute__((aligned (2))) = dgDogLadyTorsoDL;
#endif
#define dgDogLadyDL_4C60 "__OTR__objects/object_aob/gDogLadyDL_4C60"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_4C60[] = dgDogLadyDL_4C60;
#else
static const char gDogLadyDL_4C60[] __attribute__((aligned (2))) = dgDogLadyDL_4C60;
#endif
#define dgDogLadyDL_4B30 "__OTR__objects/object_aob/gDogLadyDL_4B30"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_4B30[] = dgDogLadyDL_4B30;
#else
static const char gDogLadyDL_4B30[] __attribute__((aligned (2))) = dgDogLadyDL_4B30;
#endif
#define dgDogLadyDL_4928 "__OTR__objects/object_aob/gDogLadyDL_4928"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_4928[] = dgDogLadyDL_4928;
#else
static const char gDogLadyDL_4928[] __attribute__((aligned (2))) = dgDogLadyDL_4928;
#endif
#define dgDogLadyDL_4780 "__OTR__objects/object_aob/gDogLadyDL_4780"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_4780[] = dgDogLadyDL_4780;
#else
static const char gDogLadyDL_4780[] __attribute__((aligned (2))) = dgDogLadyDL_4780;
#endif
#define dgDogLadyDL_4650 "__OTR__objects/object_aob/gDogLadyDL_4650"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_4650[] = dgDogLadyDL_4650;
#else
static const char gDogLadyDL_4650[] __attribute__((aligned (2))) = dgDogLadyDL_4650;
#endif
#define dgDogLadyDL_4448 "__OTR__objects/object_aob/gDogLadyDL_4448"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDL_4448[] = dgDogLadyDL_4448;
#else
static const char gDogLadyDL_4448[] __attribute__((aligned (2))) = dgDogLadyDL_4448;
#endif
#define dgDogLadyHeadDL "__OTR__objects/object_aob/gDogLadyHeadDL"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyHeadDL[] = dgDogLadyHeadDL;
#else
static const char gDogLadyHeadDL[] __attribute__((aligned (2))) = dgDogLadyHeadDL;
#endif
#define dgDogLadyTLUT "__OTR__objects/object_aob/gDogLadyTLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyTLUT[] = dgDogLadyTLUT;
#else
static const char gDogLadyTLUT[] __attribute__((aligned (2))) = dgDogLadyTLUT;
#endif
#define dgDogLadyHairTex "__OTR__objects/object_aob/gDogLadyHairTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyHairTex[] = dgDogLadyHairTex;
#else
static const char gDogLadyHairTex[] __attribute__((aligned (2))) = dgDogLadyHairTex;
#endif
#define dgDogLadySkinGradientTex "__OTR__objects/object_aob/gDogLadySkinGradientTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadySkinGradientTex[] = dgDogLadySkinGradientTex;
#else
static const char gDogLadySkinGradientTex[] __attribute__((aligned (2))) = dgDogLadySkinGradientTex;
#endif
#define dgDogLadyEarTex "__OTR__objects/object_aob/gDogLadyEarTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyEarTex[] = dgDogLadyEarTex;
#else
static const char gDogLadyEarTex[] __attribute__((aligned (2))) = dgDogLadyEarTex;
#endif
#define dgDogLadyLipGradientTex "__OTR__objects/object_aob/gDogLadyLipGradientTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyLipGradientTex[] = dgDogLadyLipGradientTex;
#else
static const char gDogLadyLipGradientTex[] __attribute__((aligned (2))) = dgDogLadyLipGradientTex;
#endif
#define dgDogLadyNostrilTex "__OTR__objects/object_aob/gDogLadyNostrilTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyNostrilTex[] = dgDogLadyNostrilTex;
#else
static const char gDogLadyNostrilTex[] __attribute__((aligned (2))) = dgDogLadyNostrilTex;
#endif
#define dgDogLadyBackOfHandTex "__OTR__objects/object_aob/gDogLadyBackOfHandTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyBackOfHandTex[] = dgDogLadyBackOfHandTex;
#else
static const char gDogLadyBackOfHandTex[] __attribute__((aligned (2))) = dgDogLadyBackOfHandTex;
#endif
#define dgDogLadyDressShoulderPatternTex "__OTR__objects/object_aob/gDogLadyDressShoulderPatternTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDressShoulderPatternTex[] = dgDogLadyDressShoulderPatternTex;
#else
static const char gDogLadyDressShoulderPatternTex[] __attribute__((aligned (2))) = dgDogLadyDressShoulderPatternTex;
#endif
#define dgDogLadyDressTex "__OTR__objects/object_aob/gDogLadyDressTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyDressTex[] = dgDogLadyDressTex;
#else
static const char gDogLadyDressTex[] __attribute__((aligned (2))) = dgDogLadyDressTex;
#endif
#define dgDogLadyEyeOpenTex "__OTR__objects/object_aob/gDogLadyEyeOpenTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyEyeOpenTex[] = dgDogLadyEyeOpenTex;
#else
static const char gDogLadyEyeOpenTex[] __attribute__((aligned (2))) = dgDogLadyEyeOpenTex;
#endif
#define dgDogLadyEyeHalfTex "__OTR__objects/object_aob/gDogLadyEyeHalfTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyEyeHalfTex[] = dgDogLadyEyeHalfTex;
#else
static const char gDogLadyEyeHalfTex[] __attribute__((aligned (2))) = dgDogLadyEyeHalfTex;
#endif
#define dgDogLadyEyeClosedTex "__OTR__objects/object_aob/gDogLadyEyeClosedTex"
#ifdef _WIN32
static const __declspec(align(2)) char gDogLadyEyeClosedTex[] = dgDogLadyEyeClosedTex;
#else
static const char gDogLadyEyeClosedTex[] __attribute__((aligned (2))) = dgDogLadyEyeClosedTex;
#endif
@@ -0,0 +1,30 @@
#pragma once
#define dobject_b_heart_DL_000240 "__OTR__objects/object_b_heart/object_b_heart_DL_000240"
#ifdef _WIN32
static const __declspec(align(2)) char object_b_heart_DL_000240[] = dobject_b_heart_DL_000240;
#else
static const char object_b_heart_DL_000240[] __attribute__((aligned (2))) = dobject_b_heart_DL_000240;
#endif
#define dobject_b_heart_DL_000348 "__OTR__objects/object_b_heart/object_b_heart_DL_000348"
#ifdef _WIN32
static const __declspec(align(2)) char object_b_heart_DL_000348[] = dobject_b_heart_DL_000348;
#else
static const char object_b_heart_DL_000348[] __attribute__((aligned (2))) = dobject_b_heart_DL_000348;
#endif
#define dobject_b_heart_Tex_0003C0 "__OTR__objects/object_b_heart/object_b_heart_Tex_0003C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_b_heart_Tex_0003C0[] = dobject_b_heart_Tex_0003C0;
#else
static const char object_b_heart_Tex_0003C0[] __attribute__((aligned (2))) = dobject_b_heart_Tex_0003C0;
#endif
#define dobject_b_heart_Tex_0005C0 "__OTR__objects/object_b_heart/object_b_heart_Tex_0005C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_b_heart_Tex_0005C0[] = dobject_b_heart_Tex_0005C0;
#else
static const char object_b_heart_Tex_0005C0[] __attribute__((aligned (2))) = dobject_b_heart_Tex_0005C0;
#endif
+184
View File
@@ -0,0 +1,184 @@
#pragma once
#define dobject_bba_Skel_0000F0 "__OTR__objects/object_bba/object_bba_Skel_0000F0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_Skel_0000F0[] = dobject_bba_Skel_0000F0;
#else
static const char object_bba_Skel_0000F0[] __attribute__((aligned (2))) = dobject_bba_Skel_0000F0;
#endif
#define dobject_bba_TLUT_000108 "__OTR__objects/object_bba/object_bba_TLUT_000108"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_TLUT_000108[] = dobject_bba_TLUT_000108;
#else
static const char object_bba_TLUT_000108[] __attribute__((aligned (2))) = dobject_bba_TLUT_000108;
#endif
#define dobject_bba_Tex_000308 "__OTR__objects/object_bba/object_bba_Tex_000308"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_Tex_000308[] = dobject_bba_Tex_000308;
#else
static const char object_bba_Tex_000308[] __attribute__((aligned (2))) = dobject_bba_Tex_000308;
#endif
#define dobject_bba_Tex_000348 "__OTR__objects/object_bba/object_bba_Tex_000348"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_Tex_000348[] = dobject_bba_Tex_000348;
#else
static const char object_bba_Tex_000348[] __attribute__((aligned (2))) = dobject_bba_Tex_000348;
#endif
#define dobject_bba_Tex_000388 "__OTR__objects/object_bba/object_bba_Tex_000388"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_Tex_000388[] = dobject_bba_Tex_000388;
#else
static const char object_bba_Tex_000388[] __attribute__((aligned (2))) = dobject_bba_Tex_000388;
#endif
#define dobject_bba_Tex_000488 "__OTR__objects/object_bba/object_bba_Tex_000488"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_Tex_000488[] = dobject_bba_Tex_000488;
#else
static const char object_bba_Tex_000488[] __attribute__((aligned (2))) = dobject_bba_Tex_000488;
#endif
#define dobject_bba_Tex_0004C8 "__OTR__objects/object_bba/object_bba_Tex_0004C8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_Tex_0004C8[] = dobject_bba_Tex_0004C8;
#else
static const char object_bba_Tex_0004C8[] __attribute__((aligned (2))) = dobject_bba_Tex_0004C8;
#endif
#define dobject_bba_Tex_000CC8 "__OTR__objects/object_bba/object_bba_Tex_000CC8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_Tex_000CC8[] = dobject_bba_Tex_000CC8;
#else
static const char object_bba_Tex_000CC8[] __attribute__((aligned (2))) = dobject_bba_Tex_000CC8;
#endif
#define dobject_bba_Tex_000DC8 "__OTR__objects/object_bba/object_bba_Tex_000DC8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_Tex_000DC8[] = dobject_bba_Tex_000DC8;
#else
static const char object_bba_Tex_000DC8[] __attribute__((aligned (2))) = dobject_bba_Tex_000DC8;
#endif
#define dobject_bba_Tex_000E08 "__OTR__objects/object_bba/object_bba_Tex_000E08"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_Tex_000E08[] = dobject_bba_Tex_000E08;
#else
static const char object_bba_Tex_000E08[] __attribute__((aligned (2))) = dobject_bba_Tex_000E08;
#endif
#define dobject_bba_Tex_000F08 "__OTR__objects/object_bba/object_bba_Tex_000F08"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_Tex_000F08[] = dobject_bba_Tex_000F08;
#else
static const char object_bba_Tex_000F08[] __attribute__((aligned (2))) = dobject_bba_Tex_000F08;
#endif
#define dobject_bba_DL_002948 "__OTR__objects/object_bba/object_bba_DL_002948"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_002948[] = dobject_bba_DL_002948;
#else
static const char object_bba_DL_002948[] __attribute__((aligned (2))) = dobject_bba_DL_002948;
#endif
#define dobject_bba_DL_003298 "__OTR__objects/object_bba/object_bba_DL_003298"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_003298[] = dobject_bba_DL_003298;
#else
static const char object_bba_DL_003298[] __attribute__((aligned (2))) = dobject_bba_DL_003298;
#endif
#define dobject_bba_DL_0033A8 "__OTR__objects/object_bba/object_bba_DL_0033A8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_0033A8[] = dobject_bba_DL_0033A8;
#else
static const char object_bba_DL_0033A8[] __attribute__((aligned (2))) = dobject_bba_DL_0033A8;
#endif
#define dobject_bba_DL_0034C8 "__OTR__objects/object_bba/object_bba_DL_0034C8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_0034C8[] = dobject_bba_DL_0034C8;
#else
static const char object_bba_DL_0034C8[] __attribute__((aligned (2))) = dobject_bba_DL_0034C8;
#endif
#define dobject_bba_DL_0035F0 "__OTR__objects/object_bba/object_bba_DL_0035F0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_0035F0[] = dobject_bba_DL_0035F0;
#else
static const char object_bba_DL_0035F0[] __attribute__((aligned (2))) = dobject_bba_DL_0035F0;
#endif
#define dobject_bba_DL_003700 "__OTR__objects/object_bba/object_bba_DL_003700"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_003700[] = dobject_bba_DL_003700;
#else
static const char object_bba_DL_003700[] __attribute__((aligned (2))) = dobject_bba_DL_003700;
#endif
#define dobject_bba_DL_003820 "__OTR__objects/object_bba/object_bba_DL_003820"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_003820[] = dobject_bba_DL_003820;
#else
static const char object_bba_DL_003820[] __attribute__((aligned (2))) = dobject_bba_DL_003820;
#endif
#define dobject_bba_DL_003948 "__OTR__objects/object_bba/object_bba_DL_003948"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_003948[] = dobject_bba_DL_003948;
#else
static const char object_bba_DL_003948[] __attribute__((aligned (2))) = dobject_bba_DL_003948;
#endif
#define dobject_bba_DL_003C80 "__OTR__objects/object_bba/object_bba_DL_003C80"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_003C80[] = dobject_bba_DL_003C80;
#else
static const char object_bba_DL_003C80[] __attribute__((aligned (2))) = dobject_bba_DL_003C80;
#endif
#define dobject_bba_DL_003D50 "__OTR__objects/object_bba/object_bba_DL_003D50"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_003D50[] = dobject_bba_DL_003D50;
#else
static const char object_bba_DL_003D50[] __attribute__((aligned (2))) = dobject_bba_DL_003D50;
#endif
#define dobject_bba_DL_003E20 "__OTR__objects/object_bba/object_bba_DL_003E20"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_003E20[] = dobject_bba_DL_003E20;
#else
static const char object_bba_DL_003E20[] __attribute__((aligned (2))) = dobject_bba_DL_003E20;
#endif
#define dobject_bba_DL_003EF0 "__OTR__objects/object_bba/object_bba_DL_003EF0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_003EF0[] = dobject_bba_DL_003EF0;
#else
static const char object_bba_DL_003EF0[] __attribute__((aligned (2))) = dobject_bba_DL_003EF0;
#endif
#define dobject_bba_DL_003FC0 "__OTR__objects/object_bba/object_bba_DL_003FC0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_003FC0[] = dobject_bba_DL_003FC0;
#else
static const char object_bba_DL_003FC0[] __attribute__((aligned (2))) = dobject_bba_DL_003FC0;
#endif
#define dobject_bba_DL_004090 "__OTR__objects/object_bba/object_bba_DL_004090"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_004090[] = dobject_bba_DL_004090;
#else
static const char object_bba_DL_004090[] __attribute__((aligned (2))) = dobject_bba_DL_004090;
#endif
#define dobject_bba_DL_004160 "__OTR__objects/object_bba/object_bba_DL_004160"
#ifdef _WIN32
static const __declspec(align(2)) char object_bba_DL_004160[] = dobject_bba_DL_004160;
#else
static const char object_bba_DL_004160[] __attribute__((aligned (2))) = dobject_bba_DL_004160;
#endif
@@ -0,0 +1,352 @@
#pragma once
#define dgJabuObjectsTex_00140 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_00140"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_00140[] = dgJabuObjectsTex_00140;
#else
static const char gJabuObjectsTex_00140[] __attribute__((aligned (2))) = dgJabuObjectsTex_00140;
#endif
#define dgJabuObjectsTex_007A0 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_007A0"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_007A0[] = dgJabuObjectsTex_007A0;
#else
static const char gJabuObjectsTex_007A0[] __attribute__((aligned (2))) = dgJabuObjectsTex_007A0;
#endif
#define dgJabuObjectsTex_00E00 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_00E00"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_00E00[] = dgJabuObjectsTex_00E00;
#else
static const char gJabuObjectsTex_00E00[] __attribute__((aligned (2))) = dgJabuObjectsTex_00E00;
#endif
#define dgJabuObjectsTex_01460 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_01460"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_01460[] = dgJabuObjectsTex_01460;
#else
static const char gJabuObjectsTex_01460[] __attribute__((aligned (2))) = dgJabuObjectsTex_01460;
#endif
#define dgJabuObjectsTex_01AC0 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_01AC0"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_01AC0[] = dgJabuObjectsTex_01AC0;
#else
static const char gJabuObjectsTex_01AC0[] __attribute__((aligned (2))) = dgJabuObjectsTex_01AC0;
#endif
#define dgJabuObjectsTex_02120 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_02120"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_02120[] = dgJabuObjectsTex_02120;
#else
static const char gJabuObjectsTex_02120[] __attribute__((aligned (2))) = dgJabuObjectsTex_02120;
#endif
#define dgJabuObjectsTex_02780 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_02780"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_02780[] = dgJabuObjectsTex_02780;
#else
static const char gJabuObjectsTex_02780[] __attribute__((aligned (2))) = dgJabuObjectsTex_02780;
#endif
#define dgJabuObjectsTex_02DE0 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_02DE0"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_02DE0[] = dgJabuObjectsTex_02DE0;
#else
static const char gJabuObjectsTex_02DE0[] __attribute__((aligned (2))) = dgJabuObjectsTex_02DE0;
#endif
#define dgJabuObjectsTex_03498 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_03498"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_03498[] = dgJabuObjectsTex_03498;
#else
static const char gJabuObjectsTex_03498[] __attribute__((aligned (2))) = dgJabuObjectsTex_03498;
#endif
#define dgJabuObjectsTex_03BB8 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_03BB8"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_03BB8[] = dgJabuObjectsTex_03BB8;
#else
static const char gJabuObjectsTex_03BB8[] __attribute__((aligned (2))) = dgJabuObjectsTex_03BB8;
#endif
#define dgJabuObjectsTex_043B8 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_043B8"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_043B8[] = dgJabuObjectsTex_043B8;
#else
static const char gJabuObjectsTex_043B8[] __attribute__((aligned (2))) = dgJabuObjectsTex_043B8;
#endif
#define dgJabuObjectsTex_06748 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_06748"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_06748[] = dgJabuObjectsTex_06748;
#else
static const char gJabuObjectsTex_06748[] __attribute__((aligned (2))) = dgJabuObjectsTex_06748;
#endif
#define dgJabuObjectsTex_06B48 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_06B48"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_06B48[] = dgJabuObjectsTex_06B48;
#else
static const char gJabuObjectsTex_06B48[] __attribute__((aligned (2))) = dgJabuObjectsTex_06B48;
#endif
#define dgJabuObjectsTex_07348 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_07348"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_07348[] = dgJabuObjectsTex_07348;
#else
static const char gJabuObjectsTex_07348[] __attribute__((aligned (2))) = dgJabuObjectsTex_07348;
#endif
#define dgJabuObjectsTex_08D10 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_08D10"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_08D10[] = dgJabuObjectsTex_08D10;
#else
static const char gJabuObjectsTex_08D10[] __attribute__((aligned (2))) = dgJabuObjectsTex_08D10;
#endif
#define dgJabuObjectsTex_09D10 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_09D10"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_09D10[] = dgJabuObjectsTex_09D10;
#else
static const char gJabuObjectsTex_09D10[] __attribute__((aligned (2))) = dgJabuObjectsTex_09D10;
#endif
#define dgJabuObjectsTex_0A510 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_0A510"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_0A510[] = dgJabuObjectsTex_0A510;
#else
static const char gJabuObjectsTex_0A510[] __attribute__((aligned (2))) = dgJabuObjectsTex_0A510;
#endif
#define dgJabuObjectsTex_0B510 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_0B510"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_0B510[] = dgJabuObjectsTex_0B510;
#else
static const char gJabuObjectsTex_0B510[] __attribute__((aligned (2))) = dgJabuObjectsTex_0B510;
#endif
#define dgJabuObjectsTex_0BD10 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_0BD10"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_0BD10[] = dgJabuObjectsTex_0BD10;
#else
static const char gJabuObjectsTex_0BD10[] __attribute__((aligned (2))) = dgJabuObjectsTex_0BD10;
#endif
#define dgJabuObjectsTex_0C510 "__OTR__objects/object_bdan_objects/gJabuObjectsTex_0C510"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsTex_0C510[] = dgJabuObjectsTex_0C510;
#else
static const char gJabuObjectsTex_0C510[] __attribute__((aligned (2))) = dgJabuObjectsTex_0C510;
#endif
#define dgJabuObjects1TLUT "__OTR__objects/object_bdan_objects/gJabuObjects1TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjects1TLUT[] = dgJabuObjects1TLUT;
#else
static const char gJabuObjects1TLUT[] __attribute__((aligned (2))) = dgJabuObjects1TLUT;
#endif
#define dgJabuObjects2TLUT "__OTR__objects/object_bdan_objects/gJabuObjects2TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjects2TLUT[] = dgJabuObjects2TLUT;
#else
static const char gJabuObjects2TLUT[] __attribute__((aligned (2))) = dgJabuObjects2TLUT;
#endif
#define dgJabuObjects3TLUT "__OTR__objects/object_bdan_objects/gJabuObjects3TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjects3TLUT[] = dgJabuObjects3TLUT;
#else
static const char gJabuObjects3TLUT[] __attribute__((aligned (2))) = dgJabuObjects3TLUT;
#endif
#define dgJabuObjects4TLUT "__OTR__objects/object_bdan_objects/gJabuObjects4TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjects4TLUT[] = dgJabuObjects4TLUT;
#else
static const char gJabuObjects4TLUT[] __attribute__((aligned (2))) = dgJabuObjects4TLUT;
#endif
#define dgJabuObjects5TLUT "__OTR__objects/object_bdan_objects/gJabuObjects5TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjects5TLUT[] = dgJabuObjects5TLUT;
#else
static const char gJabuObjects5TLUT[] __attribute__((aligned (2))) = dgJabuObjects5TLUT;
#endif
#define dgJabuObjects6TLUT "__OTR__objects/object_bdan_objects/gJabuObjects6TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjects6TLUT[] = dgJabuObjects6TLUT;
#else
static const char gJabuObjects6TLUT[] __attribute__((aligned (2))) = dgJabuObjects6TLUT;
#endif
#define dgJabuObjects7TLUT "__OTR__objects/object_bdan_objects/gJabuObjects7TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjects7TLUT[] = dgJabuObjects7TLUT;
#else
static const char gJabuObjects7TLUT[] __attribute__((aligned (2))) = dgJabuObjects7TLUT;
#endif
#define dgJabuObjects8TLUT "__OTR__objects/object_bdan_objects/gJabuObjects8TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjects8TLUT[] = dgJabuObjects8TLUT;
#else
static const char gJabuObjects8TLUT[] __attribute__((aligned (2))) = dgJabuObjects8TLUT;
#endif
#define dgJabuObjects9TLUT "__OTR__objects/object_bdan_objects/gJabuObjects9TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjects9TLUT[] = dgJabuObjects9TLUT;
#else
static const char gJabuObjects9TLUT[] __attribute__((aligned (2))) = dgJabuObjects9TLUT;
#endif
#define dgJabuObjects10TLUT "__OTR__objects/object_bdan_objects/gJabuObjects10TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjects10TLUT[] = dgJabuObjects10TLUT;
#else
static const char gJabuObjects10TLUT[] __attribute__((aligned (2))) = dgJabuObjects10TLUT;
#endif
#define dgJabuObjects11TLUT "__OTR__objects/object_bdan_objects/gJabuObjects11TLUT"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjects11TLUT[] = dgJabuObjects11TLUT;
#else
static const char gJabuObjects11TLUT[] __attribute__((aligned (2))) = dgJabuObjects11TLUT;
#endif
#define dgJabuDoorSection1DL "__OTR__objects/object_bdan_objects/gJabuDoorSection1DL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuDoorSection1DL[] = dgJabuDoorSection1DL;
#else
static const char gJabuDoorSection1DL[] __attribute__((aligned (2))) = dgJabuDoorSection1DL;
#endif
#define dgJabuDoorSection2DL "__OTR__objects/object_bdan_objects/gJabuDoorSection2DL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuDoorSection2DL[] = dgJabuDoorSection2DL;
#else
static const char gJabuDoorSection2DL[] __attribute__((aligned (2))) = dgJabuDoorSection2DL;
#endif
#define dgJabuDoorSection3DL "__OTR__objects/object_bdan_objects/gJabuDoorSection3DL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuDoorSection3DL[] = dgJabuDoorSection3DL;
#else
static const char gJabuDoorSection3DL[] __attribute__((aligned (2))) = dgJabuDoorSection3DL;
#endif
#define dgJabuDoorSection4DL "__OTR__objects/object_bdan_objects/gJabuDoorSection4DL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuDoorSection4DL[] = dgJabuDoorSection4DL;
#else
static const char gJabuDoorSection4DL[] __attribute__((aligned (2))) = dgJabuDoorSection4DL;
#endif
#define dgJabuDoorSection5DL "__OTR__objects/object_bdan_objects/gJabuDoorSection5DL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuDoorSection5DL[] = dgJabuDoorSection5DL;
#else
static const char gJabuDoorSection5DL[] __attribute__((aligned (2))) = dgJabuDoorSection5DL;
#endif
#define dgJabuDoorSection6DL "__OTR__objects/object_bdan_objects/gJabuDoorSection6DL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuDoorSection6DL[] = dgJabuDoorSection6DL;
#else
static const char gJabuDoorSection6DL[] __attribute__((aligned (2))) = dgJabuDoorSection6DL;
#endif
#define dgJabuDoorSection7DL "__OTR__objects/object_bdan_objects/gJabuDoorSection7DL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuDoorSection7DL[] = dgJabuDoorSection7DL;
#else
static const char gJabuDoorSection7DL[] __attribute__((aligned (2))) = dgJabuDoorSection7DL;
#endif
#define dgJabuDoorSection8DL "__OTR__objects/object_bdan_objects/gJabuDoorSection8DL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuDoorSection8DL[] = dgJabuDoorSection8DL;
#else
static const char gJabuDoorSection8DL[] __attribute__((aligned (2))) = dgJabuDoorSection8DL;
#endif
#define dgJabuWaterDL "__OTR__objects/object_bdan_objects/gJabuWaterDL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuWaterDL[] = dgJabuWaterDL;
#else
static const char gJabuWaterDL[] __attribute__((aligned (2))) = dgJabuWaterDL;
#endif
#define dgJabuElevatorPlatformDL "__OTR__objects/object_bdan_objects/gJabuElevatorPlatformDL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuElevatorPlatformDL[] = dgJabuElevatorPlatformDL;
#else
static const char gJabuElevatorPlatformDL[] __attribute__((aligned (2))) = dgJabuElevatorPlatformDL;
#endif
#define dgJabuFallingPlatformDL "__OTR__objects/object_bdan_objects/gJabuFallingPlatformDL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuFallingPlatformDL[] = dgJabuFallingPlatformDL;
#else
static const char gJabuFallingPlatformDL[] __attribute__((aligned (2))) = dgJabuFallingPlatformDL;
#endif
#define dgJabuBlueFloorSwitchDL "__OTR__objects/object_bdan_objects/gJabuBlueFloorSwitchDL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuBlueFloorSwitchDL[] = dgJabuBlueFloorSwitchDL;
#else
static const char gJabuBlueFloorSwitchDL[] __attribute__((aligned (2))) = dgJabuBlueFloorSwitchDL;
#endif
#define dgJabuYellowFloorSwitchDL "__OTR__objects/object_bdan_objects/gJabuYellowFloorSwitchDL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuYellowFloorSwitchDL[] = dgJabuYellowFloorSwitchDL;
#else
static const char gJabuYellowFloorSwitchDL[] __attribute__((aligned (2))) = dgJabuYellowFloorSwitchDL;
#endif
#define dgJabuWebDoorDL "__OTR__objects/object_bdan_objects/gJabuWebDoorDL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuWebDoorDL[] = dgJabuWebDoorDL;
#else
static const char gJabuWebDoorDL[] __attribute__((aligned (2))) = dgJabuWebDoorDL;
#endif
#define dgJabuObjectsLargeRotatingSpikePlatformDL "__OTR__objects/object_bdan_objects/gJabuObjectsLargeRotatingSpikePlatformDL"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuObjectsLargeRotatingSpikePlatformDL[] = dgJabuObjectsLargeRotatingSpikePlatformDL;
#else
static const char gJabuObjectsLargeRotatingSpikePlatformDL[] __attribute__((aligned (2))) = dgJabuObjectsLargeRotatingSpikePlatformDL;
#endif
#define dgJabuElevatorCol "__OTR__objects/object_bdan_objects/gJabuElevatorCol"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuElevatorCol[] = dgJabuElevatorCol;
#else
static const char gJabuElevatorCol[] __attribute__((aligned (2))) = dgJabuElevatorCol;
#endif
#define dgJabuLoweringPlatformCol "__OTR__objects/object_bdan_objects/gJabuLoweringPlatformCol"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuLoweringPlatformCol[] = dgJabuLoweringPlatformCol;
#else
static const char gJabuLoweringPlatformCol[] __attribute__((aligned (2))) = dgJabuLoweringPlatformCol;
#endif
#define dgJabuFloorSwitchCol "__OTR__objects/object_bdan_objects/gJabuFloorSwitchCol"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuFloorSwitchCol[] = dgJabuFloorSwitchCol;
#else
static const char gJabuFloorSwitchCol[] __attribute__((aligned (2))) = dgJabuFloorSwitchCol;
#endif
#define dgJabuBigOctoPlatformCol "__OTR__objects/object_bdan_objects/gJabuBigOctoPlatformCol"
#ifdef _WIN32
static const __declspec(align(2)) char gJabuBigOctoPlatformCol[] = dgJabuBigOctoPlatformCol;
#else
static const char gJabuBigOctoPlatformCol[] __attribute__((aligned (2))) = dgJabuBigOctoPlatformCol;
#endif
@@ -0,0 +1,72 @@
#pragma once
#define dobject_bdoor_Tex_000000 "__OTR__objects/object_bdoor/object_bdoor_Tex_000000"
#ifdef _WIN32
static const __declspec(align(2)) char object_bdoor_Tex_000000[] = dobject_bdoor_Tex_000000;
#else
static const char object_bdoor_Tex_000000[] __attribute__((aligned (2))) = dobject_bdoor_Tex_000000;
#endif
#define dobject_bdoor_DL_0010C0 "__OTR__objects/object_bdoor/object_bdoor_DL_0010C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bdoor_DL_0010C0[] = dobject_bdoor_DL_0010C0;
#else
static const char object_bdoor_DL_0010C0[] __attribute__((aligned (2))) = dobject_bdoor_DL_0010C0;
#endif
#define dobject_bdoor_DL_001400 "__OTR__objects/object_bdoor/object_bdoor_DL_001400"
#ifdef _WIN32
static const __declspec(align(2)) char object_bdoor_DL_001400[] = dobject_bdoor_DL_001400;
#else
static const char object_bdoor_DL_001400[] __attribute__((aligned (2))) = dobject_bdoor_DL_001400;
#endif
#define dobject_bdoor_DL_001530 "__OTR__objects/object_bdoor/object_bdoor_DL_001530"
#ifdef _WIN32
static const __declspec(align(2)) char object_bdoor_DL_001530[] = dobject_bdoor_DL_001530;
#else
static const char object_bdoor_DL_001530[] __attribute__((aligned (2))) = dobject_bdoor_DL_001530;
#endif
#define dobject_bdoor_Tex_0015C0 "__OTR__objects/object_bdoor/object_bdoor_Tex_0015C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bdoor_Tex_0015C0[] = dobject_bdoor_Tex_0015C0;
#else
static const char object_bdoor_Tex_0015C0[] __attribute__((aligned (2))) = dobject_bdoor_Tex_0015C0;
#endif
#define dobject_bdoor_Tex_0025C0 "__OTR__objects/object_bdoor/object_bdoor_Tex_0025C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bdoor_Tex_0025C0[] = dobject_bdoor_Tex_0025C0;
#else
static const char object_bdoor_Tex_0025C0[] __attribute__((aligned (2))) = dobject_bdoor_Tex_0025C0;
#endif
#define dobject_bdoor_Tex_0035C0 "__OTR__objects/object_bdoor/object_bdoor_Tex_0035C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bdoor_Tex_0035C0[] = dobject_bdoor_Tex_0035C0;
#else
static const char object_bdoor_Tex_0035C0[] __attribute__((aligned (2))) = dobject_bdoor_Tex_0035C0;
#endif
#define dobject_bdoor_Tex_0045C0 "__OTR__objects/object_bdoor/object_bdoor_Tex_0045C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bdoor_Tex_0045C0[] = dobject_bdoor_Tex_0045C0;
#else
static const char object_bdoor_Tex_0045C0[] __attribute__((aligned (2))) = dobject_bdoor_Tex_0045C0;
#endif
#define dobject_bdoor_Tex_0055C0 "__OTR__objects/object_bdoor/object_bdoor_Tex_0055C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bdoor_Tex_0055C0[] = dobject_bdoor_Tex_0055C0;
#else
static const char object_bdoor_Tex_0055C0[] __attribute__((aligned (2))) = dobject_bdoor_Tex_0055C0;
#endif
#define dobject_bdoor_Tex_0065C0 "__OTR__objects/object_bdoor/object_bdoor_Tex_0065C0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bdoor_Tex_0065C0[] = dobject_bdoor_Tex_0065C0;
#else
static const char object_bdoor_Tex_0065C0[] __attribute__((aligned (2))) = dobject_bdoor_Tex_0065C0;
#endif
+156
View File
@@ -0,0 +1,156 @@
#pragma once
#define dgChuGirlSkel "__OTR__objects/object_bg/gChuGirlSkel"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlSkel[] = dgChuGirlSkel;
#else
static const char gChuGirlSkel[] __attribute__((aligned (2))) = dgChuGirlSkel;
#endif
#define dgChuGirlWakeUpAnim "__OTR__objects/object_bg/gChuGirlWakeUpAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlWakeUpAnim[] = dgChuGirlWakeUpAnim;
#else
static const char gChuGirlWakeUpAnim[] __attribute__((aligned (2))) = dgChuGirlWakeUpAnim;
#endif
#define dgChuGirlNoddingOffAnim "__OTR__objects/object_bg/gChuGirlNoddingOffAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlNoddingOffAnim[] = dgChuGirlNoddingOffAnim;
#else
static const char gChuGirlNoddingOffAnim[] __attribute__((aligned (2))) = dgChuGirlNoddingOffAnim;
#endif
#define dgChuGirlLeanOverCounterAnim "__OTR__objects/object_bg/gChuGirlLeanOverCounterAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlLeanOverCounterAnim[] = dgChuGirlLeanOverCounterAnim;
#else
static const char gChuGirlLeanOverCounterAnim[] __attribute__((aligned (2))) = dgChuGirlLeanOverCounterAnim;
#endif
#define dgChuGirlWaistDL "__OTR__objects/object_bg/gChuGirlWaistDL"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlWaistDL[] = dgChuGirlWaistDL;
#else
static const char gChuGirlWaistDL[] __attribute__((aligned (2))) = dgChuGirlWaistDL;
#endif
#define dgChuGirlTorsoDL "__OTR__objects/object_bg/gChuGirlTorsoDL"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlTorsoDL[] = dgChuGirlTorsoDL;
#else
static const char gChuGirlTorsoDL[] __attribute__((aligned (2))) = dgChuGirlTorsoDL;
#endif
#define dgChuGirlNeckDL "__OTR__objects/object_bg/gChuGirlNeckDL"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlNeckDL[] = dgChuGirlNeckDL;
#else
static const char gChuGirlNeckDL[] __attribute__((aligned (2))) = dgChuGirlNeckDL;
#endif
#define dgChuGirlHeadDL "__OTR__objects/object_bg/gChuGirlHeadDL"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlHeadDL[] = dgChuGirlHeadDL;
#else
static const char gChuGirlHeadDL[] __attribute__((aligned (2))) = dgChuGirlHeadDL;
#endif
#define dgChuGirlLeftUpperArmDL "__OTR__objects/object_bg/gChuGirlLeftUpperArmDL"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlLeftUpperArmDL[] = dgChuGirlLeftUpperArmDL;
#else
static const char gChuGirlLeftUpperArmDL[] __attribute__((aligned (2))) = dgChuGirlLeftUpperArmDL;
#endif
#define dgChuGirlLeftForearmDL "__OTR__objects/object_bg/gChuGirlLeftForearmDL"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlLeftForearmDL[] = dgChuGirlLeftForearmDL;
#else
static const char gChuGirlLeftForearmDL[] __attribute__((aligned (2))) = dgChuGirlLeftForearmDL;
#endif
#define dgChuGirlLeftHandDL "__OTR__objects/object_bg/gChuGirlLeftHandDL"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlLeftHandDL[] = dgChuGirlLeftHandDL;
#else
static const char gChuGirlLeftHandDL[] __attribute__((aligned (2))) = dgChuGirlLeftHandDL;
#endif
#define dgChuGirlRightUpperArmDL "__OTR__objects/object_bg/gChuGirlRightUpperArmDL"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlRightUpperArmDL[] = dgChuGirlRightUpperArmDL;
#else
static const char gChuGirlRightUpperArmDL[] __attribute__((aligned (2))) = dgChuGirlRightUpperArmDL;
#endif
#define dgChuGirlRightForearmDL "__OTR__objects/object_bg/gChuGirlRightForearmDL"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlRightForearmDL[] = dgChuGirlRightForearmDL;
#else
static const char gChuGirlRightForearmDL[] __attribute__((aligned (2))) = dgChuGirlRightForearmDL;
#endif
#define dgChuGirlRightHandDL "__OTR__objects/object_bg/gChuGirlRightHandDL"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlRightHandDL[] = dgChuGirlRightHandDL;
#else
static const char gChuGirlRightHandDL[] __attribute__((aligned (2))) = dgChuGirlRightHandDL;
#endif
#define dgChuGirlMouthTex "__OTR__objects/object_bg/gChuGirlMouthTex"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlMouthTex[] = dgChuGirlMouthTex;
#else
static const char gChuGirlMouthTex[] __attribute__((aligned (2))) = dgChuGirlMouthTex;
#endif
#define dgChuGirlSkinGradientTex "__OTR__objects/object_bg/gChuGirlSkinGradientTex"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlSkinGradientTex[] = dgChuGirlSkinGradientTex;
#else
static const char gChuGirlSkinGradientTex[] __attribute__((aligned (2))) = dgChuGirlSkinGradientTex;
#endif
#define dgChuGirlSweaterTex "__OTR__objects/object_bg/gChuGirlSweaterTex"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlSweaterTex[] = dgChuGirlSweaterTex;
#else
static const char gChuGirlSweaterTex[] __attribute__((aligned (2))) = dgChuGirlSweaterTex;
#endif
#define dgChuGirlUmbEarLicusTex "__OTR__objects/object_bg/gChuGirlUmbEarLicusTex"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlUmbEarLicusTex[] = dgChuGirlUmbEarLicusTex;
#else
static const char gChuGirlUmbEarLicusTex[] __attribute__((aligned (2))) = dgChuGirlUmbEarLicusTex;
#endif
#define dgChuGirlHairTex "__OTR__objects/object_bg/gChuGirlHairTex"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlHairTex[] = dgChuGirlHairTex;
#else
static const char gChuGirlHairTex[] __attribute__((aligned (2))) = dgChuGirlHairTex;
#endif
#define dgChuGirlEyeOpenTex "__OTR__objects/object_bg/gChuGirlEyeOpenTex"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlEyeOpenTex[] = dgChuGirlEyeOpenTex;
#else
static const char gChuGirlEyeOpenTex[] __attribute__((aligned (2))) = dgChuGirlEyeOpenTex;
#endif
#define dgChuGirlEyeHalfTex "__OTR__objects/object_bg/gChuGirlEyeHalfTex"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlEyeHalfTex[] = dgChuGirlEyeHalfTex;
#else
static const char gChuGirlEyeHalfTex[] __attribute__((aligned (2))) = dgChuGirlEyeHalfTex;
#endif
#define dgChuGirlEyeClosedTex "__OTR__objects/object_bg/gChuGirlEyeClosedTex"
#ifdef _WIN32
static const __declspec(align(2)) char gChuGirlEyeClosedTex[] = dgChuGirlEyeClosedTex;
#else
static const char gChuGirlEyeClosedTex[] __attribute__((aligned (2))) = dgChuGirlEyeClosedTex;
#endif
@@ -0,0 +1,247 @@
#pragma once
#define dobject_bigokuta_Anim_000444 "__OTR__objects/object_bigokuta/object_bigokuta_Anim_000444"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Anim_000444[] = dobject_bigokuta_Anim_000444;
#else
static const char object_bigokuta_Anim_000444[] __attribute__((aligned (2))) = dobject_bigokuta_Anim_000444;
#endif
#define dobject_bigokuta_Anim_000A74 "__OTR__objects/object_bigokuta/object_bigokuta_Anim_000A74"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Anim_000A74[] = dobject_bigokuta_Anim_000A74;
#else
static const char object_bigokuta_Anim_000A74[] __attribute__((aligned (2))) = dobject_bigokuta_Anim_000A74;
#endif
#define dobject_bigokuta_Anim_000D1C "__OTR__objects/object_bigokuta/object_bigokuta_Anim_000D1C"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Anim_000D1C[] = dobject_bigokuta_Anim_000D1C;
#else
static const char object_bigokuta_Anim_000D1C[] __attribute__((aligned (2))) = dobject_bigokuta_Anim_000D1C;
#endif
#define dobject_bigokuta_Anim_0014B8 "__OTR__objects/object_bigokuta/object_bigokuta_Anim_0014B8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Anim_0014B8[] = dobject_bigokuta_Anim_0014B8;
#else
static const char object_bigokuta_Anim_0014B8[] __attribute__((aligned (2))) = dobject_bigokuta_Anim_0014B8;
#endif
#define dobject_bigokuta_Anim_001CA4 "__OTR__objects/object_bigokuta/object_bigokuta_Anim_001CA4"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Anim_001CA4[] = dobject_bigokuta_Anim_001CA4;
#else
static const char object_bigokuta_Anim_001CA4[] __attribute__((aligned (2))) = dobject_bigokuta_Anim_001CA4;
#endif
#define dobject_bigokuta_DL_004090 "__OTR__objects/object_bigokuta/object_bigokuta_DL_004090"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_004090[] = dobject_bigokuta_DL_004090;
#else
static const char object_bigokuta_DL_004090[] __attribute__((aligned (2))) = dobject_bigokuta_DL_004090;
#endif
#define dobject_bigokuta_DL_004158 "__OTR__objects/object_bigokuta/object_bigokuta_DL_004158"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_004158[] = dobject_bigokuta_DL_004158;
#else
static const char object_bigokuta_DL_004158[] __attribute__((aligned (2))) = dobject_bigokuta_DL_004158;
#endif
#define dobject_bigokuta_DL_0042A8 "__OTR__objects/object_bigokuta/object_bigokuta_DL_0042A8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_0042A8[] = dobject_bigokuta_DL_0042A8;
#else
static const char object_bigokuta_DL_0042A8[] __attribute__((aligned (2))) = dobject_bigokuta_DL_0042A8;
#endif
#define dobject_bigokuta_DL_0043D0 "__OTR__objects/object_bigokuta/object_bigokuta_DL_0043D0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_0043D0[] = dobject_bigokuta_DL_0043D0;
#else
static const char object_bigokuta_DL_0043D0[] __attribute__((aligned (2))) = dobject_bigokuta_DL_0043D0;
#endif
#define dobject_bigokuta_DL_0044F8 "__OTR__objects/object_bigokuta/object_bigokuta_DL_0044F8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_0044F8[] = dobject_bigokuta_DL_0044F8;
#else
static const char object_bigokuta_DL_0044F8[] __attribute__((aligned (2))) = dobject_bigokuta_DL_0044F8;
#endif
#define dobject_bigokuta_DL_004AB8 "__OTR__objects/object_bigokuta/object_bigokuta_DL_004AB8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_004AB8[] = dobject_bigokuta_DL_004AB8;
#else
static const char object_bigokuta_DL_004AB8[] __attribute__((aligned (2))) = dobject_bigokuta_DL_004AB8;
#endif
#define dobject_bigokuta_DL_004CA0 "__OTR__objects/object_bigokuta/object_bigokuta_DL_004CA0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_004CA0[] = dobject_bigokuta_DL_004CA0;
#else
static const char object_bigokuta_DL_004CA0[] __attribute__((aligned (2))) = dobject_bigokuta_DL_004CA0;
#endif
#define dobject_bigokuta_DL_004E10 "__OTR__objects/object_bigokuta/object_bigokuta_DL_004E10"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_004E10[] = dobject_bigokuta_DL_004E10;
#else
static const char object_bigokuta_DL_004E10[] __attribute__((aligned (2))) = dobject_bigokuta_DL_004E10;
#endif
#define dobject_bigokuta_DL_004EB8 "__OTR__objects/object_bigokuta/object_bigokuta_DL_004EB8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_004EB8[] = dobject_bigokuta_DL_004EB8;
#else
static const char object_bigokuta_DL_004EB8[] __attribute__((aligned (2))) = dobject_bigokuta_DL_004EB8;
#endif
#define dobject_bigokuta_DL_004F90 "__OTR__objects/object_bigokuta/object_bigokuta_DL_004F90"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_004F90[] = dobject_bigokuta_DL_004F90;
#else
static const char object_bigokuta_DL_004F90[] __attribute__((aligned (2))) = dobject_bigokuta_DL_004F90;
#endif
#define dobject_bigokuta_DL_005038 "__OTR__objects/object_bigokuta/object_bigokuta_DL_005038"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_005038[] = dobject_bigokuta_DL_005038;
#else
static const char object_bigokuta_DL_005038[] __attribute__((aligned (2))) = dobject_bigokuta_DL_005038;
#endif
#define dobject_bigokuta_DL_005110 "__OTR__objects/object_bigokuta/object_bigokuta_DL_005110"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_005110[] = dobject_bigokuta_DL_005110;
#else
static const char object_bigokuta_DL_005110[] __attribute__((aligned (2))) = dobject_bigokuta_DL_005110;
#endif
#define dobject_bigokuta_DL_0051D0 "__OTR__objects/object_bigokuta/object_bigokuta_DL_0051D0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_0051D0[] = dobject_bigokuta_DL_0051D0;
#else
static const char object_bigokuta_DL_0051D0[] __attribute__((aligned (2))) = dobject_bigokuta_DL_0051D0;
#endif
#define dobject_bigokuta_DL_0053B0 "__OTR__objects/object_bigokuta/object_bigokuta_DL_0053B0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_0053B0[] = dobject_bigokuta_DL_0053B0;
#else
static const char object_bigokuta_DL_0053B0[] __attribute__((aligned (2))) = dobject_bigokuta_DL_0053B0;
#endif
#define dobject_bigokuta_DL_005470 "__OTR__objects/object_bigokuta/object_bigokuta_DL_005470"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_005470[] = dobject_bigokuta_DL_005470;
#else
static const char object_bigokuta_DL_005470[] __attribute__((aligned (2))) = dobject_bigokuta_DL_005470;
#endif
#define dobject_bigokuta_DL_005650 "__OTR__objects/object_bigokuta/object_bigokuta_DL_005650"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_005650[] = dobject_bigokuta_DL_005650;
#else
static const char object_bigokuta_DL_005650[] __attribute__((aligned (2))) = dobject_bigokuta_DL_005650;
#endif
#define dobject_bigokuta_DL_005710 "__OTR__objects/object_bigokuta/object_bigokuta_DL_005710"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_005710[] = dobject_bigokuta_DL_005710;
#else
static const char object_bigokuta_DL_005710[] __attribute__((aligned (2))) = dobject_bigokuta_DL_005710;
#endif
#define dobject_bigokuta_DL_0058F0 "__OTR__objects/object_bigokuta/object_bigokuta_DL_0058F0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_0058F0[] = dobject_bigokuta_DL_0058F0;
#else
static const char object_bigokuta_DL_0058F0[] __attribute__((aligned (2))) = dobject_bigokuta_DL_0058F0;
#endif
#define dobject_bigokuta_DL_0059B0 "__OTR__objects/object_bigokuta/object_bigokuta_DL_0059B0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_DL_0059B0[] = dobject_bigokuta_DL_0059B0;
#else
static const char object_bigokuta_DL_0059B0[] __attribute__((aligned (2))) = dobject_bigokuta_DL_0059B0;
#endif
#define dobject_bigokuta_Tex_005B90 "__OTR__objects/object_bigokuta/object_bigokuta_Tex_005B90"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Tex_005B90[] = dobject_bigokuta_Tex_005B90;
#else
static const char object_bigokuta_Tex_005B90[] __attribute__((aligned (2))) = dobject_bigokuta_Tex_005B90;
#endif
#define dobject_bigokuta_Tex_005D90 "__OTR__objects/object_bigokuta/object_bigokuta_Tex_005D90"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Tex_005D90[] = dobject_bigokuta_Tex_005D90;
#else
static const char object_bigokuta_Tex_005D90[] __attribute__((aligned (2))) = dobject_bigokuta_Tex_005D90;
#endif
#define dobject_bigokuta_Tex_005E90 "__OTR__objects/object_bigokuta/object_bigokuta_Tex_005E90"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Tex_005E90[] = dobject_bigokuta_Tex_005E90;
#else
static const char object_bigokuta_Tex_005E90[] __attribute__((aligned (2))) = dobject_bigokuta_Tex_005E90;
#endif
#define dobject_bigokuta_Tex_006090 "__OTR__objects/object_bigokuta/object_bigokuta_Tex_006090"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Tex_006090[] = dobject_bigokuta_Tex_006090;
#else
static const char object_bigokuta_Tex_006090[] __attribute__((aligned (2))) = dobject_bigokuta_Tex_006090;
#endif
#define dobject_bigokuta_Tex_006290 "__OTR__objects/object_bigokuta/object_bigokuta_Tex_006290"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Tex_006290[] = dobject_bigokuta_Tex_006290;
#else
static const char object_bigokuta_Tex_006290[] __attribute__((aligned (2))) = dobject_bigokuta_Tex_006290;
#endif
#define dobject_bigokuta_Tex_006310 "__OTR__objects/object_bigokuta/object_bigokuta_Tex_006310"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Tex_006310[] = dobject_bigokuta_Tex_006310;
#else
static const char object_bigokuta_Tex_006310[] __attribute__((aligned (2))) = dobject_bigokuta_Tex_006310;
#endif
#define dobject_bigokuta_Tex_006390 "__OTR__objects/object_bigokuta/object_bigokuta_Tex_006390"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Tex_006390[] = dobject_bigokuta_Tex_006390;
#else
static const char object_bigokuta_Tex_006390[] __attribute__((aligned (2))) = dobject_bigokuta_Tex_006390;
#endif
#define dobject_bigokuta_Tex_006590 "__OTR__objects/object_bigokuta/object_bigokuta_Tex_006590"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Tex_006590[] = dobject_bigokuta_Tex_006590;
#else
static const char object_bigokuta_Tex_006590[] __attribute__((aligned (2))) = dobject_bigokuta_Tex_006590;
#endif
#define dobject_bigokuta_Tex_006790 "__OTR__objects/object_bigokuta/object_bigokuta_Tex_006790"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Tex_006790[] = dobject_bigokuta_Tex_006790;
#else
static const char object_bigokuta_Tex_006790[] __attribute__((aligned (2))) = dobject_bigokuta_Tex_006790;
#endif
#define dobject_bigokuta_Tex_006890 "__OTR__objects/object_bigokuta/object_bigokuta_Tex_006890"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Tex_006890[] = dobject_bigokuta_Tex_006890;
#else
static const char object_bigokuta_Tex_006890[] __attribute__((aligned (2))) = dobject_bigokuta_Tex_006890;
#endif
#define dobject_bigokuta_Skel_006BC0 "__OTR__objects/object_bigokuta/object_bigokuta_Skel_006BC0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bigokuta_Skel_006BC0[] = dobject_bigokuta_Skel_006BC0;
#else
static const char object_bigokuta_Skel_006BC0[] __attribute__((aligned (2))) = dobject_bigokuta_Skel_006BC0;
#endif
@@ -0,0 +1,100 @@
#pragma once
#define dgBirdFlyAnim "__OTR__objects/object_bird/gBirdFlyAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdFlyAnim[] = dgBirdFlyAnim;
#else
static const char gBirdFlyAnim[] __attribute__((aligned (2))) = dgBirdFlyAnim;
#endif
#define dgBirdLeftWingDL "__OTR__objects/object_bird/gBirdLeftWingDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdLeftWingDL[] = dgBirdLeftWingDL;
#else
static const char gBirdLeftWingDL[] __attribute__((aligned (2))) = dgBirdLeftWingDL;
#endif
#define dgBirdLeftWingWrapper1DL "__OTR__objects/object_bird/gBirdLeftWingWrapper1DL"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdLeftWingWrapper1DL[] = dgBirdLeftWingWrapper1DL;
#else
static const char gBirdLeftWingWrapper1DL[] __attribute__((aligned (2))) = dgBirdLeftWingWrapper1DL;
#endif
#define dgBirdLeftWingWrapper2DL "__OTR__objects/object_bird/gBirdLeftWingWrapper2DL"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdLeftWingWrapper2DL[] = dgBirdLeftWingWrapper2DL;
#else
static const char gBirdLeftWingWrapper2DL[] __attribute__((aligned (2))) = dgBirdLeftWingWrapper2DL;
#endif
#define dgBirdRightWingDL "__OTR__objects/object_bird/gBirdRightWingDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdRightWingDL[] = dgBirdRightWingDL;
#else
static const char gBirdRightWingDL[] __attribute__((aligned (2))) = dgBirdRightWingDL;
#endif
#define dgBirdRightWingWrapper1DL "__OTR__objects/object_bird/gBirdRightWingWrapper1DL"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdRightWingWrapper1DL[] = dgBirdRightWingWrapper1DL;
#else
static const char gBirdRightWingWrapper1DL[] __attribute__((aligned (2))) = dgBirdRightWingWrapper1DL;
#endif
#define dgBirdRightWingWrapper2DL "__OTR__objects/object_bird/gBirdRightWingWrapper2DL"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdRightWingWrapper2DL[] = dgBirdRightWingWrapper2DL;
#else
static const char gBirdRightWingWrapper2DL[] __attribute__((aligned (2))) = dgBirdRightWingWrapper2DL;
#endif
#define dgBirdBodyDL "__OTR__objects/object_bird/gBirdBodyDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdBodyDL[] = dgBirdBodyDL;
#else
static const char gBirdBodyDL[] __attribute__((aligned (2))) = dgBirdBodyDL;
#endif
#define dgBirdBodyWrapper1DL "__OTR__objects/object_bird/gBirdBodyWrapper1DL"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdBodyWrapper1DL[] = dgBirdBodyWrapper1DL;
#else
static const char gBirdBodyWrapper1DL[] __attribute__((aligned (2))) = dgBirdBodyWrapper1DL;
#endif
#define dgBirdBodyWrapper2DL "__OTR__objects/object_bird/gBirdBodyWrapper2DL"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdBodyWrapper2DL[] = dgBirdBodyWrapper2DL;
#else
static const char gBirdBodyWrapper2DL[] __attribute__((aligned (2))) = dgBirdBodyWrapper2DL;
#endif
#define dgBirdFaceTex "__OTR__objects/object_bird/gBirdFaceTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdFaceTex[] = dgBirdFaceTex;
#else
static const char gBirdFaceTex[] __attribute__((aligned (2))) = dgBirdFaceTex;
#endif
#define dgBirdTailTex "__OTR__objects/object_bird/gBirdTailTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdTailTex[] = dgBirdTailTex;
#else
static const char gBirdTailTex[] __attribute__((aligned (2))) = dgBirdTailTex;
#endif
#define dgBirdWingTex "__OTR__objects/object_bird/gBirdWingTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdWingTex[] = dgBirdWingTex;
#else
static const char gBirdWingTex[] __attribute__((aligned (2))) = dgBirdWingTex;
#endif
#define dgBirdSkel "__OTR__objects/object_bird/gBirdSkel"
#ifdef _WIN32
static const __declspec(align(2)) char gBirdSkel[] = dgBirdSkel;
#else
static const char gBirdSkel[] __attribute__((aligned (2))) = dgBirdSkel;
#endif
+219
View File
@@ -0,0 +1,219 @@
#pragma once
#define dobject_bji_Skel_0000F0 "__OTR__objects/object_bji/object_bji_Skel_0000F0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Skel_0000F0[] = dobject_bji_Skel_0000F0;
#else
static const char object_bji_Skel_0000F0[] __attribute__((aligned (2))) = dobject_bji_Skel_0000F0;
#endif
#define dobject_bji_TLUT_0000FC "__OTR__objects/object_bji/object_bji_TLUT_0000FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_TLUT_0000FC[] = dobject_bji_TLUT_0000FC;
#else
static const char object_bji_TLUT_0000FC[] __attribute__((aligned (2))) = dobject_bji_TLUT_0000FC;
#endif
#define dobject_bji_Tex_0002FC "__OTR__objects/object_bji/object_bji_Tex_0002FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_0002FC[] = dobject_bji_Tex_0002FC;
#else
static const char object_bji_Tex_0002FC[] __attribute__((aligned (2))) = dobject_bji_Tex_0002FC;
#endif
#define dobject_bji_Tex_00033C "__OTR__objects/object_bji/object_bji_Tex_00033C"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_00033C[] = dobject_bji_Tex_00033C;
#else
static const char object_bji_Tex_00033C[] __attribute__((aligned (2))) = dobject_bji_Tex_00033C;
#endif
#define dobject_bji_Tex_00037C "__OTR__objects/object_bji/object_bji_Tex_00037C"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_00037C[] = dobject_bji_Tex_00037C;
#else
static const char object_bji_Tex_00037C[] __attribute__((aligned (2))) = dobject_bji_Tex_00037C;
#endif
#define dobject_bji_Tex_00047C "__OTR__objects/object_bji/object_bji_Tex_00047C"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_00047C[] = dobject_bji_Tex_00047C;
#else
static const char object_bji_Tex_00047C[] __attribute__((aligned (2))) = dobject_bji_Tex_00047C;
#endif
#define dobject_bji_Tex_0004BC "__OTR__objects/object_bji/object_bji_Tex_0004BC"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_0004BC[] = dobject_bji_Tex_0004BC;
#else
static const char object_bji_Tex_0004BC[] __attribute__((aligned (2))) = dobject_bji_Tex_0004BC;
#endif
#define dobject_bji_Tex_0004FC "__OTR__objects/object_bji/object_bji_Tex_0004FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_0004FC[] = dobject_bji_Tex_0004FC;
#else
static const char object_bji_Tex_0004FC[] __attribute__((aligned (2))) = dobject_bji_Tex_0004FC;
#endif
#define dobject_bji_Tex_0005FC "__OTR__objects/object_bji/object_bji_Tex_0005FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_0005FC[] = dobject_bji_Tex_0005FC;
#else
static const char object_bji_Tex_0005FC[] __attribute__((aligned (2))) = dobject_bji_Tex_0005FC;
#endif
#define dobject_bji_Tex_0009FC "__OTR__objects/object_bji/object_bji_Tex_0009FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_0009FC[] = dobject_bji_Tex_0009FC;
#else
static const char object_bji_Tex_0009FC[] __attribute__((aligned (2))) = dobject_bji_Tex_0009FC;
#endif
#define dobject_bji_Tex_000DFC "__OTR__objects/object_bji/object_bji_Tex_000DFC"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_000DFC[] = dobject_bji_Tex_000DFC;
#else
static const char object_bji_Tex_000DFC[] __attribute__((aligned (2))) = dobject_bji_Tex_000DFC;
#endif
#define dobject_bji_Tex_0011FC "__OTR__objects/object_bji/object_bji_Tex_0011FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_0011FC[] = dobject_bji_Tex_0011FC;
#else
static const char object_bji_Tex_0011FC[] __attribute__((aligned (2))) = dobject_bji_Tex_0011FC;
#endif
#define dobject_bji_DL_002560 "__OTR__objects/object_bji/object_bji_DL_002560"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_002560[] = dobject_bji_DL_002560;
#else
static const char object_bji_DL_002560[] __attribute__((aligned (2))) = dobject_bji_DL_002560;
#endif
#define dobject_bji_DL_002B88 "__OTR__objects/object_bji/object_bji_DL_002B88"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_002B88[] = dobject_bji_DL_002B88;
#else
static const char object_bji_DL_002B88[] __attribute__((aligned (2))) = dobject_bji_DL_002B88;
#endif
#define dobject_bji_DL_002C50 "__OTR__objects/object_bji/object_bji_DL_002C50"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_002C50[] = dobject_bji_DL_002C50;
#else
static const char object_bji_DL_002C50[] __attribute__((aligned (2))) = dobject_bji_DL_002C50;
#endif
#define dobject_bji_DL_002D40 "__OTR__objects/object_bji/object_bji_DL_002D40"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_002D40[] = dobject_bji_DL_002D40;
#else
static const char object_bji_DL_002D40[] __attribute__((aligned (2))) = dobject_bji_DL_002D40;
#endif
#define dobject_bji_DL_002E40 "__OTR__objects/object_bji/object_bji_DL_002E40"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_002E40[] = dobject_bji_DL_002E40;
#else
static const char object_bji_DL_002E40[] __attribute__((aligned (2))) = dobject_bji_DL_002E40;
#endif
#define dobject_bji_DL_002F08 "__OTR__objects/object_bji/object_bji_DL_002F08"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_002F08[] = dobject_bji_DL_002F08;
#else
static const char object_bji_DL_002F08[] __attribute__((aligned (2))) = dobject_bji_DL_002F08;
#endif
#define dobject_bji_DL_002FF8 "__OTR__objects/object_bji/object_bji_DL_002FF8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_002FF8[] = dobject_bji_DL_002FF8;
#else
static const char object_bji_DL_002FF8[] __attribute__((aligned (2))) = dobject_bji_DL_002FF8;
#endif
#define dobject_bji_DL_0030F8 "__OTR__objects/object_bji/object_bji_DL_0030F8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_0030F8[] = dobject_bji_DL_0030F8;
#else
static const char object_bji_DL_0030F8[] __attribute__((aligned (2))) = dobject_bji_DL_0030F8;
#endif
#define dobject_bji_DL_003328 "__OTR__objects/object_bji/object_bji_DL_003328"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_003328[] = dobject_bji_DL_003328;
#else
static const char object_bji_DL_003328[] __attribute__((aligned (2))) = dobject_bji_DL_003328;
#endif
#define dobject_bji_DL_0033F0 "__OTR__objects/object_bji/object_bji_DL_0033F0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_0033F0[] = dobject_bji_DL_0033F0;
#else
static const char object_bji_DL_0033F0[] __attribute__((aligned (2))) = dobject_bji_DL_0033F0;
#endif
#define dobject_bji_DL_0034B8 "__OTR__objects/object_bji/object_bji_DL_0034B8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_0034B8[] = dobject_bji_DL_0034B8;
#else
static const char object_bji_DL_0034B8[] __attribute__((aligned (2))) = dobject_bji_DL_0034B8;
#endif
#define dobject_bji_DL_003580 "__OTR__objects/object_bji/object_bji_DL_003580"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_003580[] = dobject_bji_DL_003580;
#else
static const char object_bji_DL_003580[] __attribute__((aligned (2))) = dobject_bji_DL_003580;
#endif
#define dobject_bji_DL_003648 "__OTR__objects/object_bji/object_bji_DL_003648"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_003648[] = dobject_bji_DL_003648;
#else
static const char object_bji_DL_003648[] __attribute__((aligned (2))) = dobject_bji_DL_003648;
#endif
#define dobject_bji_DL_003710 "__OTR__objects/object_bji/object_bji_DL_003710"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_003710[] = dobject_bji_DL_003710;
#else
static const char object_bji_DL_003710[] __attribute__((aligned (2))) = dobject_bji_DL_003710;
#endif
#define dobject_bji_DL_0037D8 "__OTR__objects/object_bji/object_bji_DL_0037D8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_0037D8[] = dobject_bji_DL_0037D8;
#else
static const char object_bji_DL_0037D8[] __attribute__((aligned (2))) = dobject_bji_DL_0037D8;
#endif
#define dobject_bji_Tex_003908 "__OTR__objects/object_bji/object_bji_Tex_003908"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_003908[] = dobject_bji_Tex_003908;
#else
static const char object_bji_Tex_003908[] __attribute__((aligned (2))) = dobject_bji_Tex_003908;
#endif
#define dobject_bji_Tex_003988 "__OTR__objects/object_bji/object_bji_Tex_003988"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_003988[] = dobject_bji_Tex_003988;
#else
static const char object_bji_Tex_003988[] __attribute__((aligned (2))) = dobject_bji_Tex_003988;
#endif
#define dobject_bji_Tex_003A08 "__OTR__objects/object_bji/object_bji_Tex_003A08"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_Tex_003A08[] = dobject_bji_Tex_003A08;
#else
static const char object_bji_Tex_003A08[] __attribute__((aligned (2))) = dobject_bji_Tex_003A08;
#endif
#define dobject_bji_DL_003F68 "__OTR__objects/object_bji/object_bji_DL_003F68"
#ifdef _WIN32
static const __declspec(align(2)) char object_bji_DL_003F68[] = dobject_bji_DL_003F68;
#else
static const char object_bji_DL_003F68[] __attribute__((aligned (2))) = dobject_bji_DL_003F68;
#endif
+121
View File
@@ -0,0 +1,121 @@
#pragma once
#define dgBiriDischargeLightningAnim "__OTR__objects/object_bl/gBiriDischargeLightningAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriDischargeLightningAnim[] = dgBiriDischargeLightningAnim;
#else
static const char gBiriDischargeLightningAnim[] __attribute__((aligned (2))) = dgBiriDischargeLightningAnim;
#endif
#define dgBiriClimbAnim "__OTR__objects/object_bl/gBiriClimbAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriClimbAnim[] = dgBiriClimbAnim;
#else
static const char gBiriClimbAnim[] __attribute__((aligned (2))) = dgBiriClimbAnim;
#endif
#define dgBiriDefaultAnim "__OTR__objects/object_bl/gBiriDefaultAnim"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriDefaultAnim[] = dgBiriDefaultAnim;
#else
static const char gBiriDefaultAnim[] __attribute__((aligned (2))) = dgBiriDefaultAnim;
#endif
#define dgBiriTentaclesDL "__OTR__objects/object_bl/gBiriTentaclesDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriTentaclesDL[] = dgBiriTentaclesDL;
#else
static const char gBiriTentaclesDL[] __attribute__((aligned (2))) = dgBiriTentaclesDL;
#endif
#define dgBiriInnerHoodDL "__OTR__objects/object_bl/gBiriInnerHoodDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriInnerHoodDL[] = dgBiriInnerHoodDL;
#else
static const char gBiriInnerHoodDL[] __attribute__((aligned (2))) = dgBiriInnerHoodDL;
#endif
#define dgBiriOuterHoodDL "__OTR__objects/object_bl/gBiriOuterHoodDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriOuterHoodDL[] = dgBiriOuterHoodDL;
#else
static const char gBiriOuterHoodDL[] __attribute__((aligned (2))) = dgBiriOuterHoodDL;
#endif
#define dgBiriOuterHoodTex "__OTR__objects/object_bl/gBiriOuterHoodTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriOuterHoodTex[] = dgBiriOuterHoodTex;
#else
static const char gBiriOuterHoodTex[] __attribute__((aligned (2))) = dgBiriOuterHoodTex;
#endif
#define dgBiriTentacles0Tex "__OTR__objects/object_bl/gBiriTentacles0Tex"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriTentacles0Tex[] = dgBiriTentacles0Tex;
#else
static const char gBiriTentacles0Tex[] __attribute__((aligned (2))) = dgBiriTentacles0Tex;
#endif
#define dgBiriTentacles1Tex "__OTR__objects/object_bl/gBiriTentacles1Tex"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriTentacles1Tex[] = dgBiriTentacles1Tex;
#else
static const char gBiriTentacles1Tex[] __attribute__((aligned (2))) = dgBiriTentacles1Tex;
#endif
#define dgBiriTentacles2Tex "__OTR__objects/object_bl/gBiriTentacles2Tex"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriTentacles2Tex[] = dgBiriTentacles2Tex;
#else
static const char gBiriTentacles2Tex[] __attribute__((aligned (2))) = dgBiriTentacles2Tex;
#endif
#define dgBiriTentacles3Tex "__OTR__objects/object_bl/gBiriTentacles3Tex"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriTentacles3Tex[] = dgBiriTentacles3Tex;
#else
static const char gBiriTentacles3Tex[] __attribute__((aligned (2))) = dgBiriTentacles3Tex;
#endif
#define dgBiriTentacles4Tex "__OTR__objects/object_bl/gBiriTentacles4Tex"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriTentacles4Tex[] = dgBiriTentacles4Tex;
#else
static const char gBiriTentacles4Tex[] __attribute__((aligned (2))) = dgBiriTentacles4Tex;
#endif
#define dgBiriTentacles5Tex "__OTR__objects/object_bl/gBiriTentacles5Tex"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriTentacles5Tex[] = dgBiriTentacles5Tex;
#else
static const char gBiriTentacles5Tex[] __attribute__((aligned (2))) = dgBiriTentacles5Tex;
#endif
#define dgBiriTentacles6Tex "__OTR__objects/object_bl/gBiriTentacles6Tex"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriTentacles6Tex[] = dgBiriTentacles6Tex;
#else
static const char gBiriTentacles6Tex[] __attribute__((aligned (2))) = dgBiriTentacles6Tex;
#endif
#define dgBiriTentacles7Tex "__OTR__objects/object_bl/gBiriTentacles7Tex"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriTentacles7Tex[] = dgBiriTentacles7Tex;
#else
static const char gBiriTentacles7Tex[] __attribute__((aligned (2))) = dgBiriTentacles7Tex;
#endif
#define dgBiriInnerHoodTex "__OTR__objects/object_bl/gBiriInnerHoodTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriInnerHoodTex[] = dgBiriInnerHoodTex;
#else
static const char gBiriInnerHoodTex[] __attribute__((aligned (2))) = dgBiriInnerHoodTex;
#endif
#define dgBiriSkel "__OTR__objects/object_bl/gBiriSkel"
#ifdef _WIN32
static const __declspec(align(2)) char gBiriSkel[] = dgBiriSkel;
#else
static const char gBiriSkel[] __attribute__((aligned (2))) = dgBiriSkel;
#endif
@@ -0,0 +1,184 @@
#pragma once
#define dgIllusionRoomCol "__OTR__objects/object_blkobj/gIllusionRoomCol"
#ifdef _WIN32
static const __declspec(align(2)) char gIllusionRoomCol[] = dgIllusionRoomCol;
#else
static const char gIllusionRoomCol[] __attribute__((aligned (2))) = dgIllusionRoomCol;
#endif
#define dgIllusionRoomNormalDL "__OTR__objects/object_blkobj/gIllusionRoomNormalDL"
#ifdef _WIN32
static const __declspec(align(2)) char gIllusionRoomNormalDL[] = dgIllusionRoomNormalDL;
#else
static const char gIllusionRoomNormalDL[] __attribute__((aligned (2))) = dgIllusionRoomNormalDL;
#endif
#define dgIllusionRoomIllusionDL "__OTR__objects/object_blkobj/gIllusionRoomIllusionDL"
#ifdef _WIN32
static const __declspec(align(2)) char gIllusionRoomIllusionDL[] = dgIllusionRoomIllusionDL;
#else
static const char gIllusionRoomIllusionDL[] __attribute__((aligned (2))) = dgIllusionRoomIllusionDL;
#endif
#define dgIllusionRoomTreeDL "__OTR__objects/object_blkobj/gIllusionRoomTreeDL"
#ifdef _WIN32
static const __declspec(align(2)) char gIllusionRoomTreeDL[] = dgIllusionRoomTreeDL;
#else
static const char gIllusionRoomTreeDL[] __attribute__((aligned (2))) = dgIllusionRoomTreeDL;
#endif
#define dobject_blkobjTex_008890 "__OTR__objects/object_blkobj/object_blkobjTex_008890"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_008890[] = dobject_blkobjTex_008890;
#else
static const char object_blkobjTex_008890[] __attribute__((aligned (2))) = dobject_blkobjTex_008890;
#endif
#define dobject_blkobjTex_009090 "__OTR__objects/object_blkobj/object_blkobjTex_009090"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_009090[] = dobject_blkobjTex_009090;
#else
static const char object_blkobjTex_009090[] __attribute__((aligned (2))) = dobject_blkobjTex_009090;
#endif
#define dobject_blkobjTex_00C090 "__OTR__objects/object_blkobj/object_blkobjTex_00C090"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_00C090[] = dobject_blkobjTex_00C090;
#else
static const char object_blkobjTex_00C090[] __attribute__((aligned (2))) = dobject_blkobjTex_00C090;
#endif
#define dobject_blkobjTex_00D090 "__OTR__objects/object_blkobj/object_blkobjTex_00D090"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_00D090[] = dobject_blkobjTex_00D090;
#else
static const char object_blkobjTex_00D090[] __attribute__((aligned (2))) = dobject_blkobjTex_00D090;
#endif
#define dobject_blkobjTex_009890 "__OTR__objects/object_blkobj/object_blkobjTex_009890"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_009890[] = dobject_blkobjTex_009890;
#else
static const char object_blkobjTex_009890[] __attribute__((aligned (2))) = dobject_blkobjTex_009890;
#endif
#define dobject_blkobjTex_00B890 "__OTR__objects/object_blkobj/object_blkobjTex_00B890"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_00B890[] = dobject_blkobjTex_00B890;
#else
static const char object_blkobjTex_00B890[] __attribute__((aligned (2))) = dobject_blkobjTex_00B890;
#endif
#define dobject_blkobjTex_00C890 "__OTR__objects/object_blkobj/object_blkobjTex_00C890"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_00C890[] = dobject_blkobjTex_00C890;
#else
static const char object_blkobjTex_00C890[] __attribute__((aligned (2))) = dobject_blkobjTex_00C890;
#endif
#define dobject_blkobjTex_00B090 "__OTR__objects/object_blkobj/object_blkobjTex_00B090"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_00B090[] = dobject_blkobjTex_00B090;
#else
static const char object_blkobjTex_00B090[] __attribute__((aligned (2))) = dobject_blkobjTex_00B090;
#endif
#define dobject_blkobjTex_00E090 "__OTR__objects/object_blkobj/object_blkobjTex_00E090"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_00E090[] = dobject_blkobjTex_00E090;
#else
static const char object_blkobjTex_00E090[] __attribute__((aligned (2))) = dobject_blkobjTex_00E090;
#endif
#define dobject_blkobjTex_008090 "__OTR__objects/object_blkobj/object_blkobjTex_008090"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_008090[] = dobject_blkobjTex_008090;
#else
static const char object_blkobjTex_008090[] __attribute__((aligned (2))) = dobject_blkobjTex_008090;
#endif
#define dobject_blkobjTex_00A890 "__OTR__objects/object_blkobj/object_blkobjTex_00A890"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_00A890[] = dobject_blkobjTex_00A890;
#else
static const char object_blkobjTex_00A890[] __attribute__((aligned (2))) = dobject_blkobjTex_00A890;
#endif
#define dobject_blkobjTex_00D890 "__OTR__objects/object_blkobj/object_blkobjTex_00D890"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_00D890[] = dobject_blkobjTex_00D890;
#else
static const char object_blkobjTex_00D890[] __attribute__((aligned (2))) = dobject_blkobjTex_00D890;
#endif
#define dobject_blkobjTex_00A090 "__OTR__objects/object_blkobj/object_blkobjTex_00A090"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_00A090[] = dobject_blkobjTex_00A090;
#else
static const char object_blkobjTex_00A090[] __attribute__((aligned (2))) = dobject_blkobjTex_00A090;
#endif
#define dobject_blkobjTex_00E890 "__OTR__objects/object_blkobj/object_blkobjTex_00E890"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_00E890[] = dobject_blkobjTex_00E890;
#else
static const char object_blkobjTex_00E890[] __attribute__((aligned (2))) = dobject_blkobjTex_00E890;
#endif
#define dobject_blkobjTex_013090 "__OTR__objects/object_blkobj/object_blkobjTex_013090"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_013090[] = dobject_blkobjTex_013090;
#else
static const char object_blkobjTex_013090[] __attribute__((aligned (2))) = dobject_blkobjTex_013090;
#endif
#define dobject_blkobjTex_012890 "__OTR__objects/object_blkobj/object_blkobjTex_012890"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_012890[] = dobject_blkobjTex_012890;
#else
static const char object_blkobjTex_012890[] __attribute__((aligned (2))) = dobject_blkobjTex_012890;
#endif
#define dobject_blkobjTex_012090 "__OTR__objects/object_blkobj/object_blkobjTex_012090"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_012090[] = dobject_blkobjTex_012090;
#else
static const char object_blkobjTex_012090[] __attribute__((aligned (2))) = dobject_blkobjTex_012090;
#endif
#define dobject_blkobjTex_010090 "__OTR__objects/object_blkobj/object_blkobjTex_010090"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_010090[] = dobject_blkobjTex_010090;
#else
static const char object_blkobjTex_010090[] __attribute__((aligned (2))) = dobject_blkobjTex_010090;
#endif
#define dobject_blkobjTex_010890 "__OTR__objects/object_blkobj/object_blkobjTex_010890"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_010890[] = dobject_blkobjTex_010890;
#else
static const char object_blkobjTex_010890[] __attribute__((aligned (2))) = dobject_blkobjTex_010890;
#endif
#define dobject_blkobjTex_011090 "__OTR__objects/object_blkobj/object_blkobjTex_011090"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_011090[] = dobject_blkobjTex_011090;
#else
static const char object_blkobjTex_011090[] __attribute__((aligned (2))) = dobject_blkobjTex_011090;
#endif
#define dobject_blkobjTex_011890 "__OTR__objects/object_blkobj/object_blkobjTex_011890"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_011890[] = dobject_blkobjTex_011890;
#else
static const char object_blkobjTex_011890[] __attribute__((aligned (2))) = dobject_blkobjTex_011890;
#endif
#define dobject_blkobjTex_00F890 "__OTR__objects/object_blkobj/object_blkobjTex_00F890"
#ifdef _WIN32
static const __declspec(align(2)) char object_blkobjTex_00F890[] = dobject_blkobjTex_00F890;
#else
static const char object_blkobjTex_00F890[] __attribute__((aligned (2))) = dobject_blkobjTex_00F890;
#endif
+198
View File
@@ -0,0 +1,198 @@
#pragma once
#define dobject_bob_Skel_0000F0 "__OTR__objects/object_bob/object_bob_Skel_0000F0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Skel_0000F0[] = dobject_bob_Skel_0000F0;
#else
static const char object_bob_Skel_0000F0[] __attribute__((aligned (2))) = dobject_bob_Skel_0000F0;
#endif
#define dobject_bob_TLUT_000108 "__OTR__objects/object_bob/object_bob_TLUT_000108"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_TLUT_000108[] = dobject_bob_TLUT_000108;
#else
static const char object_bob_TLUT_000108[] __attribute__((aligned (2))) = dobject_bob_TLUT_000108;
#endif
#define dobject_bob_Tex_000308 "__OTR__objects/object_bob/object_bob_Tex_000308"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Tex_000308[] = dobject_bob_Tex_000308;
#else
static const char object_bob_Tex_000308[] __attribute__((aligned (2))) = dobject_bob_Tex_000308;
#endif
#define dobject_bob_Tex_000348 "__OTR__objects/object_bob/object_bob_Tex_000348"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Tex_000348[] = dobject_bob_Tex_000348;
#else
static const char object_bob_Tex_000348[] __attribute__((aligned (2))) = dobject_bob_Tex_000348;
#endif
#define dobject_bob_Tex_000388 "__OTR__objects/object_bob/object_bob_Tex_000388"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Tex_000388[] = dobject_bob_Tex_000388;
#else
static const char object_bob_Tex_000388[] __attribute__((aligned (2))) = dobject_bob_Tex_000388;
#endif
#define dobject_bob_Tex_000788 "__OTR__objects/object_bob/object_bob_Tex_000788"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Tex_000788[] = dobject_bob_Tex_000788;
#else
static const char object_bob_Tex_000788[] __attribute__((aligned (2))) = dobject_bob_Tex_000788;
#endif
#define dobject_bob_Tex_0007C8 "__OTR__objects/object_bob/object_bob_Tex_0007C8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Tex_0007C8[] = dobject_bob_Tex_0007C8;
#else
static const char object_bob_Tex_0007C8[] __attribute__((aligned (2))) = dobject_bob_Tex_0007C8;
#endif
#define dobject_bob_Tex_000FC8 "__OTR__objects/object_bob/object_bob_Tex_000FC8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Tex_000FC8[] = dobject_bob_Tex_000FC8;
#else
static const char object_bob_Tex_000FC8[] __attribute__((aligned (2))) = dobject_bob_Tex_000FC8;
#endif
#define dobject_bob_Tex_0017C8 "__OTR__objects/object_bob/object_bob_Tex_0017C8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Tex_0017C8[] = dobject_bob_Tex_0017C8;
#else
static const char object_bob_Tex_0017C8[] __attribute__((aligned (2))) = dobject_bob_Tex_0017C8;
#endif
#define dobject_bob_Tex_001FC8 "__OTR__objects/object_bob/object_bob_Tex_001FC8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Tex_001FC8[] = dobject_bob_Tex_001FC8;
#else
static const char object_bob_Tex_001FC8[] __attribute__((aligned (2))) = dobject_bob_Tex_001FC8;
#endif
#define dobject_bob_Tex_0020C8 "__OTR__objects/object_bob/object_bob_Tex_0020C8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Tex_0020C8[] = dobject_bob_Tex_0020C8;
#else
static const char object_bob_Tex_0020C8[] __attribute__((aligned (2))) = dobject_bob_Tex_0020C8;
#endif
#define dobject_bob_Tex_0021C8 "__OTR__objects/object_bob/object_bob_Tex_0021C8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Tex_0021C8[] = dobject_bob_Tex_0021C8;
#else
static const char object_bob_Tex_0021C8[] __attribute__((aligned (2))) = dobject_bob_Tex_0021C8;
#endif
#define dobject_bob_Tex_002208 "__OTR__objects/object_bob/object_bob_Tex_002208"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_Tex_002208[] = dobject_bob_Tex_002208;
#else
static const char object_bob_Tex_002208[] __attribute__((aligned (2))) = dobject_bob_Tex_002208;
#endif
#define dobject_bob_DL_003B78 "__OTR__objects/object_bob/object_bob_DL_003B78"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_003B78[] = dobject_bob_DL_003B78;
#else
static const char object_bob_DL_003B78[] __attribute__((aligned (2))) = dobject_bob_DL_003B78;
#endif
#define dobject_bob_DL_003F68 "__OTR__objects/object_bob/object_bob_DL_003F68"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_003F68[] = dobject_bob_DL_003F68;
#else
static const char object_bob_DL_003F68[] __attribute__((aligned (2))) = dobject_bob_DL_003F68;
#endif
#define dobject_bob_DL_0040B0 "__OTR__objects/object_bob/object_bob_DL_0040B0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_0040B0[] = dobject_bob_DL_0040B0;
#else
static const char object_bob_DL_0040B0[] __attribute__((aligned (2))) = dobject_bob_DL_0040B0;
#endif
#define dobject_bob_DL_0041E0 "__OTR__objects/object_bob/object_bob_DL_0041E0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_0041E0[] = dobject_bob_DL_0041E0;
#else
static const char object_bob_DL_0041E0[] __attribute__((aligned (2))) = dobject_bob_DL_0041E0;
#endif
#define dobject_bob_DL_004310 "__OTR__objects/object_bob/object_bob_DL_004310"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_004310[] = dobject_bob_DL_004310;
#else
static const char object_bob_DL_004310[] __attribute__((aligned (2))) = dobject_bob_DL_004310;
#endif
#define dobject_bob_DL_004458 "__OTR__objects/object_bob/object_bob_DL_004458"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_004458[] = dobject_bob_DL_004458;
#else
static const char object_bob_DL_004458[] __attribute__((aligned (2))) = dobject_bob_DL_004458;
#endif
#define dobject_bob_DL_004588 "__OTR__objects/object_bob/object_bob_DL_004588"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_004588[] = dobject_bob_DL_004588;
#else
static const char object_bob_DL_004588[] __attribute__((aligned (2))) = dobject_bob_DL_004588;
#endif
#define dobject_bob_DL_0046B8 "__OTR__objects/object_bob/object_bob_DL_0046B8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_0046B8[] = dobject_bob_DL_0046B8;
#else
static const char object_bob_DL_0046B8[] __attribute__((aligned (2))) = dobject_bob_DL_0046B8;
#endif
#define dobject_bob_DL_004A48 "__OTR__objects/object_bob/object_bob_DL_004A48"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_004A48[] = dobject_bob_DL_004A48;
#else
static const char object_bob_DL_004A48[] __attribute__((aligned (2))) = dobject_bob_DL_004A48;
#endif
#define dobject_bob_DL_004B18 "__OTR__objects/object_bob/object_bob_DL_004B18"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_004B18[] = dobject_bob_DL_004B18;
#else
static const char object_bob_DL_004B18[] __attribute__((aligned (2))) = dobject_bob_DL_004B18;
#endif
#define dobject_bob_DL_004BE8 "__OTR__objects/object_bob/object_bob_DL_004BE8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_004BE8[] = dobject_bob_DL_004BE8;
#else
static const char object_bob_DL_004BE8[] __attribute__((aligned (2))) = dobject_bob_DL_004BE8;
#endif
#define dobject_bob_DL_004C38 "__OTR__objects/object_bob/object_bob_DL_004C38"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_004C38[] = dobject_bob_DL_004C38;
#else
static const char object_bob_DL_004C38[] __attribute__((aligned (2))) = dobject_bob_DL_004C38;
#endif
#define dobject_bob_DL_004D08 "__OTR__objects/object_bob/object_bob_DL_004D08"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_004D08[] = dobject_bob_DL_004D08;
#else
static const char object_bob_DL_004D08[] __attribute__((aligned (2))) = dobject_bob_DL_004D08;
#endif
#define dobject_bob_DL_004DD8 "__OTR__objects/object_bob/object_bob_DL_004DD8"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_004DD8[] = dobject_bob_DL_004DD8;
#else
static const char object_bob_DL_004DD8[] __attribute__((aligned (2))) = dobject_bob_DL_004DD8;
#endif
#define dobject_bob_DL_004E28 "__OTR__objects/object_bob/object_bob_DL_004E28"
#ifdef _WIN32
static const __declspec(align(2)) char object_bob_DL_004E28[] = dobject_bob_DL_004E28;
#else
static const char object_bob_DL_004E28[] __attribute__((aligned (2))) = dobject_bob_DL_004E28;
#endif
+289
View File
@@ -0,0 +1,289 @@
#pragma once
#define dobject_boj_Skel_0000F0 "__OTR__objects/object_boj/object_boj_Skel_0000F0"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Skel_0000F0[] = dobject_boj_Skel_0000F0;
#else
static const char object_boj_Skel_0000F0[] __attribute__((aligned (2))) = dobject_boj_Skel_0000F0;
#endif
#define dobject_boj_TLUT_0000FC "__OTR__objects/object_boj/object_boj_TLUT_0000FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_TLUT_0000FC[] = dobject_boj_TLUT_0000FC;
#else
static const char object_boj_TLUT_0000FC[] __attribute__((aligned (2))) = dobject_boj_TLUT_0000FC;
#endif
#define dobject_boj_Tex_0002FC "__OTR__objects/object_boj/object_boj_Tex_0002FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_0002FC[] = dobject_boj_Tex_0002FC;
#else
static const char object_boj_Tex_0002FC[] __attribute__((aligned (2))) = dobject_boj_Tex_0002FC;
#endif
#define dobject_boj_Tex_00037C "__OTR__objects/object_boj/object_boj_Tex_00037C"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_00037C[] = dobject_boj_Tex_00037C;
#else
static const char object_boj_Tex_00037C[] __attribute__((aligned (2))) = dobject_boj_Tex_00037C;
#endif
#define dobject_boj_Tex_0003BC "__OTR__objects/object_boj/object_boj_Tex_0003BC"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_0003BC[] = dobject_boj_Tex_0003BC;
#else
static const char object_boj_Tex_0003BC[] __attribute__((aligned (2))) = dobject_boj_Tex_0003BC;
#endif
#define dobject_boj_Tex_0005BC "__OTR__objects/object_boj/object_boj_Tex_0005BC"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_0005BC[] = dobject_boj_Tex_0005BC;
#else
static const char object_boj_Tex_0005BC[] __attribute__((aligned (2))) = dobject_boj_Tex_0005BC;
#endif
#define dobject_boj_Tex_0005FC "__OTR__objects/object_boj/object_boj_Tex_0005FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_0005FC[] = dobject_boj_Tex_0005FC;
#else
static const char object_boj_Tex_0005FC[] __attribute__((aligned (2))) = dobject_boj_Tex_0005FC;
#endif
#define dobject_boj_Tex_0006FC "__OTR__objects/object_boj/object_boj_Tex_0006FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_0006FC[] = dobject_boj_Tex_0006FC;
#else
static const char object_boj_Tex_0006FC[] __attribute__((aligned (2))) = dobject_boj_Tex_0006FC;
#endif
#define dobject_boj_Tex_0007FC "__OTR__objects/object_boj/object_boj_Tex_0007FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_0007FC[] = dobject_boj_Tex_0007FC;
#else
static const char object_boj_Tex_0007FC[] __attribute__((aligned (2))) = dobject_boj_Tex_0007FC;
#endif
#define dobject_boj_Tex_0008FC "__OTR__objects/object_boj/object_boj_Tex_0008FC"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_0008FC[] = dobject_boj_Tex_0008FC;
#else
static const char object_boj_Tex_0008FC[] __attribute__((aligned (2))) = dobject_boj_Tex_0008FC;
#endif
#define dobject_boj_Tex_00093C "__OTR__objects/object_boj/object_boj_Tex_00093C"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_00093C[] = dobject_boj_Tex_00093C;
#else
static const char object_boj_Tex_00093C[] __attribute__((aligned (2))) = dobject_boj_Tex_00093C;
#endif
#define dobject_boj_Tex_000A3C "__OTR__objects/object_boj/object_boj_Tex_000A3C"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_000A3C[] = dobject_boj_Tex_000A3C;
#else
static const char object_boj_Tex_000A3C[] __attribute__((aligned (2))) = dobject_boj_Tex_000A3C;
#endif
#define dobject_boj_Tex_000A7C "__OTR__objects/object_boj/object_boj_Tex_000A7C"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_000A7C[] = dobject_boj_Tex_000A7C;
#else
static const char object_boj_Tex_000A7C[] __attribute__((aligned (2))) = dobject_boj_Tex_000A7C;
#endif
#define dobject_boj_DL_0026F0 "__OTR__objects/object_boj/object_boj_DL_0026F0"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_0026F0[] = dobject_boj_DL_0026F0;
#else
static const char object_boj_DL_0026F0[] __attribute__((aligned (2))) = dobject_boj_DL_0026F0;
#endif
#define dobject_boj_DL_002AC8 "__OTR__objects/object_boj/object_boj_DL_002AC8"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_002AC8[] = dobject_boj_DL_002AC8;
#else
static const char object_boj_DL_002AC8[] __attribute__((aligned (2))) = dobject_boj_DL_002AC8;
#endif
#define dobject_boj_DL_002C10 "__OTR__objects/object_boj/object_boj_DL_002C10"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_002C10[] = dobject_boj_DL_002C10;
#else
static const char object_boj_DL_002C10[] __attribute__((aligned (2))) = dobject_boj_DL_002C10;
#endif
#define dobject_boj_DL_002D18 "__OTR__objects/object_boj/object_boj_DL_002D18"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_002D18[] = dobject_boj_DL_002D18;
#else
static const char object_boj_DL_002D18[] __attribute__((aligned (2))) = dobject_boj_DL_002D18;
#endif
#define dobject_boj_DL_002E20 "__OTR__objects/object_boj/object_boj_DL_002E20"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_002E20[] = dobject_boj_DL_002E20;
#else
static const char object_boj_DL_002E20[] __attribute__((aligned (2))) = dobject_boj_DL_002E20;
#endif
#define dobject_boj_DL_002F68 "__OTR__objects/object_boj/object_boj_DL_002F68"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_002F68[] = dobject_boj_DL_002F68;
#else
static const char object_boj_DL_002F68[] __attribute__((aligned (2))) = dobject_boj_DL_002F68;
#endif
#define dobject_boj_DL_003070 "__OTR__objects/object_boj/object_boj_DL_003070"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_003070[] = dobject_boj_DL_003070;
#else
static const char object_boj_DL_003070[] __attribute__((aligned (2))) = dobject_boj_DL_003070;
#endif
#define dobject_boj_DL_003178 "__OTR__objects/object_boj/object_boj_DL_003178"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_003178[] = dobject_boj_DL_003178;
#else
static const char object_boj_DL_003178[] __attribute__((aligned (2))) = dobject_boj_DL_003178;
#endif
#define dobject_boj_DL_003350 "__OTR__objects/object_boj/object_boj_DL_003350"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_003350[] = dobject_boj_DL_003350;
#else
static const char object_boj_DL_003350[] __attribute__((aligned (2))) = dobject_boj_DL_003350;
#endif
#define dobject_boj_DL_003468 "__OTR__objects/object_boj/object_boj_DL_003468"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_003468[] = dobject_boj_DL_003468;
#else
static const char object_boj_DL_003468[] __attribute__((aligned (2))) = dobject_boj_DL_003468;
#endif
#define dobject_boj_DL_003578 "__OTR__objects/object_boj/object_boj_DL_003578"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_003578[] = dobject_boj_DL_003578;
#else
static const char object_boj_DL_003578[] __attribute__((aligned (2))) = dobject_boj_DL_003578;
#endif
#define dobject_boj_DL_003680 "__OTR__objects/object_boj/object_boj_DL_003680"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_003680[] = dobject_boj_DL_003680;
#else
static const char object_boj_DL_003680[] __attribute__((aligned (2))) = dobject_boj_DL_003680;
#endif
#define dobject_boj_DL_003798 "__OTR__objects/object_boj/object_boj_DL_003798"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_003798[] = dobject_boj_DL_003798;
#else
static const char object_boj_DL_003798[] __attribute__((aligned (2))) = dobject_boj_DL_003798;
#endif
#define dobject_boj_DL_0038A8 "__OTR__objects/object_boj/object_boj_DL_0038A8"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_0038A8[] = dobject_boj_DL_0038A8;
#else
static const char object_boj_DL_0038A8[] __attribute__((aligned (2))) = dobject_boj_DL_0038A8;
#endif
#define dobject_boj_DL_0039B0 "__OTR__objects/object_boj/object_boj_DL_0039B0"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_0039B0[] = dobject_boj_DL_0039B0;
#else
static const char object_boj_DL_0039B0[] __attribute__((aligned (2))) = dobject_boj_DL_0039B0;
#endif
#define dobject_boj_TLUT_003B98 "__OTR__objects/object_boj/object_boj_TLUT_003B98"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_TLUT_003B98[] = dobject_boj_TLUT_003B98;
#else
static const char object_boj_TLUT_003B98[] __attribute__((aligned (2))) = dobject_boj_TLUT_003B98;
#endif
#define dobject_boj_Tex_003D90 "__OTR__objects/object_boj/object_boj_Tex_003D90"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_003D90[] = dobject_boj_Tex_003D90;
#else
static const char object_boj_Tex_003D90[] __attribute__((aligned (2))) = dobject_boj_Tex_003D90;
#endif
#define dobject_boj_Tex_003DD0 "__OTR__objects/object_boj/object_boj_Tex_003DD0"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_003DD0[] = dobject_boj_Tex_003DD0;
#else
static const char object_boj_Tex_003DD0[] __attribute__((aligned (2))) = dobject_boj_Tex_003DD0;
#endif
#define dobject_boj_Tex_003ED0 "__OTR__objects/object_boj/object_boj_Tex_003ED0"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_003ED0[] = dobject_boj_Tex_003ED0;
#else
static const char object_boj_Tex_003ED0[] __attribute__((aligned (2))) = dobject_boj_Tex_003ED0;
#endif
#define dobject_boj_Tex_003FD0 "__OTR__objects/object_boj/object_boj_Tex_003FD0"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_003FD0[] = dobject_boj_Tex_003FD0;
#else
static const char object_boj_Tex_003FD0[] __attribute__((aligned (2))) = dobject_boj_Tex_003FD0;
#endif
#define dobject_boj_Tex_004050 "__OTR__objects/object_boj/object_boj_Tex_004050"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_004050[] = dobject_boj_Tex_004050;
#else
static const char object_boj_Tex_004050[] __attribute__((aligned (2))) = dobject_boj_Tex_004050;
#endif
#define dobject_boj_Tex_004150 "__OTR__objects/object_boj/object_boj_Tex_004150"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_004150[] = dobject_boj_Tex_004150;
#else
static const char object_boj_Tex_004150[] __attribute__((aligned (2))) = dobject_boj_Tex_004150;
#endif
#define dobject_boj_Tex_004250 "__OTR__objects/object_boj/object_boj_Tex_004250"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_Tex_004250[] = dobject_boj_Tex_004250;
#else
static const char object_boj_Tex_004250[] __attribute__((aligned (2))) = dobject_boj_Tex_004250;
#endif
#define dobject_boj_DL_0052E0 "__OTR__objects/object_boj/object_boj_DL_0052E0"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_0052E0[] = dobject_boj_DL_0052E0;
#else
static const char object_boj_DL_0052E0[] __attribute__((aligned (2))) = dobject_boj_DL_0052E0;
#endif
#define dobject_boj_DL_005528 "__OTR__objects/object_boj/object_boj_DL_005528"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_005528[] = dobject_boj_DL_005528;
#else
static const char object_boj_DL_005528[] __attribute__((aligned (2))) = dobject_boj_DL_005528;
#endif
#define dobject_boj_DL_005738 "__OTR__objects/object_boj/object_boj_DL_005738"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_005738[] = dobject_boj_DL_005738;
#else
static const char object_boj_DL_005738[] __attribute__((aligned (2))) = dobject_boj_DL_005738;
#endif
#define dobject_boj_DL_0059B0 "__OTR__objects/object_boj/object_boj_DL_0059B0"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_0059B0[] = dobject_boj_DL_0059B0;
#else
static const char object_boj_DL_0059B0[] __attribute__((aligned (2))) = dobject_boj_DL_0059B0;
#endif
#define dobject_boj_DL_005BC8 "__OTR__objects/object_boj/object_boj_DL_005BC8"
#ifdef _WIN32
static const __declspec(align(2)) char object_boj_DL_005BC8[] = dobject_boj_DL_005BC8;
#else
static const char object_boj_DL_005BC8[] __attribute__((aligned (2))) = dobject_boj_DL_005BC8;
#endif
@@ -0,0 +1,51 @@
#pragma once
#define dgBombFlowerLeafOutwardsTex "__OTR__objects/object_bombf/gBombFlowerLeafOutwardsTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBombFlowerLeafOutwardsTex[] = dgBombFlowerLeafOutwardsTex;
#else
static const char gBombFlowerLeafOutwardsTex[] __attribute__((aligned (2))) = dgBombFlowerLeafOutwardsTex;
#endif
#define dgBombFlowerLeafUpwardsTex "__OTR__objects/object_bombf/gBombFlowerLeafUpwardsTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBombFlowerLeafUpwardsTex[] = dgBombFlowerLeafUpwardsTex;
#else
static const char gBombFlowerLeafUpwardsTex[] __attribute__((aligned (2))) = dgBombFlowerLeafUpwardsTex;
#endif
#define dgBombFlowerBombTex "__OTR__objects/object_bombf/gBombFlowerBombTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBombFlowerBombTex[] = dgBombFlowerBombTex;
#else
static const char gBombFlowerBombTex[] __attribute__((aligned (2))) = dgBombFlowerBombTex;
#endif
#define dgBombFlowerFuseTex "__OTR__objects/object_bombf/gBombFlowerFuseTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBombFlowerFuseTex[] = dgBombFlowerFuseTex;
#else
static const char gBombFlowerFuseTex[] __attribute__((aligned (2))) = dgBombFlowerFuseTex;
#endif
#define dgBombFlowerLeavesDL "__OTR__objects/object_bombf/gBombFlowerLeavesDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBombFlowerLeavesDL[] = dgBombFlowerLeavesDL;
#else
static const char gBombFlowerLeavesDL[] __attribute__((aligned (2))) = dgBombFlowerLeavesDL;
#endif
#define dgBombFlowerBombAndSparkDL "__OTR__objects/object_bombf/gBombFlowerBombAndSparkDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBombFlowerBombAndSparkDL[] = dgBombFlowerBombAndSparkDL;
#else
static const char gBombFlowerBombAndSparkDL[] __attribute__((aligned (2))) = dgBombFlowerBombAndSparkDL;
#endif
#define dgBombFlowerBaseLeavesDL "__OTR__objects/object_bombf/gBombFlowerBaseLeavesDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBombFlowerBaseLeavesDL[] = dgBombFlowerBaseLeavesDL;
#else
static const char gBombFlowerBaseLeavesDL[] __attribute__((aligned (2))) = dgBombFlowerBaseLeavesDL;
#endif
@@ -0,0 +1,23 @@
#pragma once
#define dobject_bombiwa_TLUT_000000 "__OTR__objects/object_bombiwa/object_bombiwa_TLUT_000000"
#ifdef _WIN32
static const __declspec(align(2)) char object_bombiwa_TLUT_000000[] = dobject_bombiwa_TLUT_000000;
#else
static const char object_bombiwa_TLUT_000000[] __attribute__((aligned (2))) = dobject_bombiwa_TLUT_000000;
#endif
#define dobject_bombiwa_Tex_000020 "__OTR__objects/object_bombiwa/object_bombiwa_Tex_000020"
#ifdef _WIN32
static const __declspec(align(2)) char object_bombiwa_Tex_000020[] = dobject_bombiwa_Tex_000020;
#else
static const char object_bombiwa_Tex_000020[] __attribute__((aligned (2))) = dobject_bombiwa_Tex_000020;
#endif
#define dobject_bombiwa_DL_0009E0 "__OTR__objects/object_bombiwa/object_bombiwa_DL_0009E0"
#ifdef _WIN32
static const __declspec(align(2)) char object_bombiwa_DL_0009E0[] = dobject_bombiwa_DL_0009E0;
#else
static const char object_bombiwa_DL_0009E0[] __attribute__((aligned (2))) = dobject_bombiwa_DL_0009E0;
#endif
@@ -0,0 +1,65 @@
#pragma once
#define dgBowlingWoodPanelTex "__OTR__objects/object_bowl/gBowlingWoodPanelTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBowlingWoodPanelTex[] = dgBowlingWoodPanelTex;
#else
static const char gBowlingWoodPanelTex[] __attribute__((aligned (2))) = dgBowlingWoodPanelTex;
#endif
#define dgBowlingStoneWallTex "__OTR__objects/object_bowl/gBowlingStoneWallTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBowlingStoneWallTex[] = dgBowlingStoneWallTex;
#else
static const char gBowlingStoneWallTex[] __attribute__((aligned (2))) = dgBowlingStoneWallTex;
#endif
#define dgBowlingStripesTex "__OTR__objects/object_bowl/gBowlingStripesTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBowlingStripesTex[] = dgBowlingStripesTex;
#else
static const char gBowlingStripesTex[] __attribute__((aligned (2))) = dgBowlingStripesTex;
#endif
#define dgBowlingRound1WallDL "__OTR__objects/object_bowl/gBowlingRound1WallDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBowlingRound1WallDL[] = dgBowlingRound1WallDL;
#else
static const char gBowlingRound1WallDL[] __attribute__((aligned (2))) = dgBowlingRound1WallDL;
#endif
#define dgBowlingRound2WallDL "__OTR__objects/object_bowl/gBowlingRound2WallDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBowlingRound2WallDL[] = dgBowlingRound2WallDL;
#else
static const char gBowlingRound2WallDL[] __attribute__((aligned (2))) = dgBowlingRound2WallDL;
#endif
#define dgBowlingDL_1B80 "__OTR__objects/object_bowl/gBowlingDL_1B80"
#ifdef _WIN32
static const __declspec(align(2)) char gBowlingDL_1B80[] = dgBowlingDL_1B80;
#else
static const char gBowlingDL_1B80[] __attribute__((aligned (2))) = dgBowlingDL_1B80;
#endif
#define dgBowlingFirstAndFinalRoundCol "__OTR__objects/object_bowl/gBowlingFirstAndFinalRoundCol"
#ifdef _WIN32
static const __declspec(align(2)) char gBowlingFirstAndFinalRoundCol[] = dgBowlingFirstAndFinalRoundCol;
#else
static const char gBowlingFirstAndFinalRoundCol[] __attribute__((aligned (2))) = dgBowlingFirstAndFinalRoundCol;
#endif
#define dgBowlingSecondRoundCol "__OTR__objects/object_bowl/gBowlingSecondRoundCol"
#ifdef _WIN32
static const __declspec(align(2)) char gBowlingSecondRoundCol[] = dgBowlingSecondRoundCol;
#else
static const char gBowlingSecondRoundCol[] __attribute__((aligned (2))) = dgBowlingSecondRoundCol;
#endif
#define dgBowlingDefaultCol "__OTR__objects/object_bowl/gBowlingDefaultCol"
#ifdef _WIN32
static const __declspec(align(2)) char gBowlingDefaultCol[] = dgBowlingDefaultCol;
#else
static const char gBowlingDefaultCol[] __attribute__((aligned (2))) = dgBowlingDefaultCol;
#endif
+170
View File
@@ -0,0 +1,170 @@
#pragma once
#define dgTreasureChestCurveSkel "__OTR__objects/object_box/gTreasureChestCurveSkel"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestCurveSkel[] = dgTreasureChestCurveSkel;
#else
static const char gTreasureChestCurveSkel[] __attribute__((aligned (2))) = dgTreasureChestCurveSkel;
#endif
#define dgTreasureChestCurveAnim_4B60 "__OTR__objects/object_box/gTreasureChestCurveAnim_4B60"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestCurveAnim_4B60[] = dgTreasureChestCurveAnim_4B60;
#else
static const char gTreasureChestCurveAnim_4B60[] __attribute__((aligned (2))) = dgTreasureChestCurveAnim_4B60;
#endif
#define dgTreasureChestCurveAnim_4F70 "__OTR__objects/object_box/gTreasureChestCurveAnim_4F70"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestCurveAnim_4F70[] = dgTreasureChestCurveAnim_4F70;
#else
static const char gTreasureChestCurveAnim_4F70[] __attribute__((aligned (2))) = dgTreasureChestCurveAnim_4F70;
#endif
#define dgTreasureChestAnim_000128 "__OTR__objects/object_box/gTreasureChestAnim_000128"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestAnim_000128[] = dgTreasureChestAnim_000128;
#else
static const char gTreasureChestAnim_000128[] __attribute__((aligned (2))) = dgTreasureChestAnim_000128;
#endif
#define dgTreasureChestAnim_00024C "__OTR__objects/object_box/gTreasureChestAnim_00024C"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestAnim_00024C[] = dgTreasureChestAnim_00024C;
#else
static const char gTreasureChestAnim_00024C[] __attribute__((aligned (2))) = dgTreasureChestAnim_00024C;
#endif
#define dgTreasureChestAnim_00043C "__OTR__objects/object_box/gTreasureChestAnim_00043C"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestAnim_00043C[] = dgTreasureChestAnim_00043C;
#else
static const char gTreasureChestAnim_00043C[] __attribute__((aligned (2))) = dgTreasureChestAnim_00043C;
#endif
#define dgTreasureChestChestFrontDL "__OTR__objects/object_box/gTreasureChestChestFrontDL"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestChestFrontDL[] = dgTreasureChestChestFrontDL;
#else
static const char gTreasureChestChestFrontDL[] __attribute__((aligned (2))) = dgTreasureChestChestFrontDL;
#endif
#define dgTreasureChestFrontTex "__OTR__objects/object_box/gTreasureChestFrontTex"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestFrontTex[] = dgTreasureChestFrontTex;
#else
static const char gTreasureChestFrontTex[] __attribute__((aligned (2))) = dgTreasureChestFrontTex;
#endif
#define dgTreasureChestBossKeyChestFrontDL "__OTR__objects/object_box/gTreasureChestBossKeyChestFrontDL"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestBossKeyChestFrontDL[] = dgTreasureChestBossKeyChestFrontDL;
#else
static const char gTreasureChestBossKeyChestFrontDL[] __attribute__((aligned (2))) = dgTreasureChestBossKeyChestFrontDL;
#endif
#define dgTreasureChestBossKeyFrontTex "__OTR__objects/object_box/gTreasureChestBossKeyFrontTex"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestBossKeyFrontTex[] = dgTreasureChestBossKeyFrontTex;
#else
static const char gTreasureChestBossKeyFrontTex[] __attribute__((aligned (2))) = dgTreasureChestBossKeyFrontTex;
#endif
#define dgTreasureChestChestSideAndLidDL "__OTR__objects/object_box/gTreasureChestChestSideAndLidDL"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestChestSideAndLidDL[] = dgTreasureChestChestSideAndLidDL;
#else
static const char gTreasureChestChestSideAndLidDL[] __attribute__((aligned (2))) = dgTreasureChestChestSideAndLidDL;
#endif
#define dgTreasureChestSideAndTopTex "__OTR__objects/object_box/gTreasureChestSideAndTopTex"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestSideAndTopTex[] = dgTreasureChestSideAndTopTex;
#else
static const char gTreasureChestSideAndTopTex[] __attribute__((aligned (2))) = dgTreasureChestSideAndTopTex;
#endif
#define dgTreasureChestBossKeyChestSideAndTopDL "__OTR__objects/object_box/gTreasureChestBossKeyChestSideAndTopDL"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestBossKeyChestSideAndTopDL[] = dgTreasureChestBossKeyChestSideAndTopDL;
#else
static const char gTreasureChestBossKeyChestSideAndTopDL[] __attribute__((aligned (2))) = dgTreasureChestBossKeyChestSideAndTopDL;
#endif
#define dgTreasureChestBossKeySideAndTopTex "__OTR__objects/object_box/gTreasureChestBossKeySideAndTopTex"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestBossKeySideAndTopTex[] = dgTreasureChestBossKeySideAndTopTex;
#else
static const char gTreasureChestBossKeySideAndTopTex[] __attribute__((aligned (2))) = dgTreasureChestBossKeySideAndTopTex;
#endif
#define dgTreasureChestSkel "__OTR__objects/object_box/gTreasureChestSkel"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestSkel[] = dgTreasureChestSkel;
#else
static const char gTreasureChestSkel[] __attribute__((aligned (2))) = dgTreasureChestSkel;
#endif
#define dgTreasureChestCol "__OTR__objects/object_box/gTreasureChestCol"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestCol[] = dgTreasureChestCol;
#else
static const char gTreasureChestCol[] __attribute__((aligned (2))) = dgTreasureChestCol;
#endif
#define dgBoxBlob_00025C "__OTR__objects/object_box/gBoxBlob_00025C"
#ifdef _WIN32
static const __declspec(align(2)) char gBoxBlob_00025C[] = dgBoxBlob_00025C;
#else
static const char gBoxBlob_00025C[] __attribute__((aligned (2))) = dgBoxBlob_00025C;
#endif
#define dgBoxBlob_00044C "__OTR__objects/object_box/gBoxBlob_00044C"
#ifdef _WIN32
static const __declspec(align(2)) char gBoxBlob_00044C[] = dgBoxBlob_00044C;
#else
static const char gBoxBlob_00044C[] __attribute__((aligned (2))) = dgBoxBlob_00044C;
#endif
#define dgTreasureChestCurveSkelLimbsLimb_005DE4Curve2DL_0059D0 "__OTR__objects/object_box/gTreasureChestCurveSkelLimbsLimb_005DE4Curve2DL_0059D0"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestCurveSkelLimbsLimb_005DE4Curve2DL_0059D0[] = dgTreasureChestCurveSkelLimbsLimb_005DE4Curve2DL_0059D0;
#else
static const char gTreasureChestCurveSkelLimbsLimb_005DE4Curve2DL_0059D0[] __attribute__((aligned (2))) = dgTreasureChestCurveSkelLimbsLimb_005DE4Curve2DL_0059D0;
#endif
#define dgTreasureChestCurveSkelLimbsLimb_005E08Curve2DL_005C48 "__OTR__objects/object_box/gTreasureChestCurveSkelLimbsLimb_005E08Curve2DL_005C48"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestCurveSkelLimbsLimb_005E08Curve2DL_005C48[] = dgTreasureChestCurveSkelLimbsLimb_005E08Curve2DL_005C48;
#else
static const char gTreasureChestCurveSkelLimbsLimb_005E08Curve2DL_005C48[] __attribute__((aligned (2))) = dgTreasureChestCurveSkelLimbsLimb_005E08Curve2DL_005C48;
#endif
#define dgTreasureChestCurveSkelLimbsLimb_005E2CCurve2DL_005B80 "__OTR__objects/object_box/gTreasureChestCurveSkelLimbsLimb_005E2CCurve2DL_005B80"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestCurveSkelLimbsLimb_005E2CCurve2DL_005B80[] = dgTreasureChestCurveSkelLimbsLimb_005E2CCurve2DL_005B80;
#else
static const char gTreasureChestCurveSkelLimbsLimb_005E2CCurve2DL_005B80[] __attribute__((aligned (2))) = dgTreasureChestCurveSkelLimbsLimb_005E2CCurve2DL_005B80;
#endif
#define dgTreasureChestCurveSkelLimbsLimb_005E50Curve2DL_005D10 "__OTR__objects/object_box/gTreasureChestCurveSkelLimbsLimb_005E50Curve2DL_005D10"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestCurveSkelLimbsLimb_005E50Curve2DL_005D10[] = dgTreasureChestCurveSkelLimbsLimb_005E50Curve2DL_005D10;
#else
static const char gTreasureChestCurveSkelLimbsLimb_005E50Curve2DL_005D10[] __attribute__((aligned (2))) = dgTreasureChestCurveSkelLimbsLimb_005E50Curve2DL_005D10;
#endif
#define dgTreasureChestCurveSkelLimbsLimb_005E74Curve2DL_005AB8 "__OTR__objects/object_box/gTreasureChestCurveSkelLimbsLimb_005E74Curve2DL_005AB8"
#ifdef _WIN32
static const __declspec(align(2)) char gTreasureChestCurveSkelLimbsLimb_005E74Curve2DL_005AB8[] = dgTreasureChestCurveSkelLimbsLimb_005E74Curve2DL_005AB8;
#else
static const char gTreasureChestCurveSkelLimbsLimb_005E74Curve2DL_005AB8[] __attribute__((aligned (2))) = dgTreasureChestCurveSkelLimbsLimb_005E74Curve2DL_005AB8;
#endif
#define dobject_boxTex_004F80 "__OTR__objects/object_box/object_boxTex_004F80"
#ifdef _WIN32
static const __declspec(align(2)) char object_boxTex_004F80[] = dobject_boxTex_004F80;
#else
static const char object_boxTex_004F80[] __attribute__((aligned (2))) = dobject_boxTex_004F80;
#endif
@@ -0,0 +1,86 @@
#pragma once
#define dobject_brob_Anim_000290 "__OTR__objects/object_brob/object_brob_Anim_000290"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_Anim_000290[] = dobject_brob_Anim_000290;
#else
static const char object_brob_Anim_000290[] __attribute__((aligned (2))) = dobject_brob_Anim_000290;
#endif
#define dobject_brob_DL_0007E0 "__OTR__objects/object_brob/object_brob_DL_0007E0"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_DL_0007E0[] = dobject_brob_DL_0007E0;
#else
static const char object_brob_DL_0007E0[] __attribute__((aligned (2))) = dobject_brob_DL_0007E0;
#endif
#define dobject_brob_DL_000898 "__OTR__objects/object_brob/object_brob_DL_000898"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_DL_000898[] = dobject_brob_DL_000898;
#else
static const char object_brob_DL_000898[] __attribute__((aligned (2))) = dobject_brob_DL_000898;
#endif
#define dobject_brob_DL_0009D0 "__OTR__objects/object_brob/object_brob_DL_0009D0"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_DL_0009D0[] = dobject_brob_DL_0009D0;
#else
static const char object_brob_DL_0009D0[] __attribute__((aligned (2))) = dobject_brob_DL_0009D0;
#endif
#define dobject_brob_DL_000AE8 "__OTR__objects/object_brob/object_brob_DL_000AE8"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_DL_000AE8[] = dobject_brob_DL_000AE8;
#else
static const char object_brob_DL_000AE8[] __attribute__((aligned (2))) = dobject_brob_DL_000AE8;
#endif
#define dobject_brob_DL_000C00 "__OTR__objects/object_brob/object_brob_DL_000C00"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_DL_000C00[] = dobject_brob_DL_000C00;
#else
static const char object_brob_DL_000C00[] __attribute__((aligned (2))) = dobject_brob_DL_000C00;
#endif
#define dobject_brob_Tex_000D48 "__OTR__objects/object_brob/object_brob_Tex_000D48"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_Tex_000D48[] = dobject_brob_Tex_000D48;
#else
static const char object_brob_Tex_000D48[] __attribute__((aligned (2))) = dobject_brob_Tex_000D48;
#endif
#define dobject_brob_Skel_0015D8 "__OTR__objects/object_brob/object_brob_Skel_0015D8"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_Skel_0015D8[] = dobject_brob_Skel_0015D8;
#else
static const char object_brob_Skel_0015D8[] __attribute__((aligned (2))) = dobject_brob_Skel_0015D8;
#endif
#define dobject_brob_Anim_001678 "__OTR__objects/object_brob/object_brob_Anim_001678"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_Anim_001678[] = dobject_brob_Anim_001678;
#else
static const char object_brob_Anim_001678[] __attribute__((aligned (2))) = dobject_brob_Anim_001678;
#endif
#define dobject_brob_Anim_001750 "__OTR__objects/object_brob/object_brob_Anim_001750"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_Anim_001750[] = dobject_brob_Anim_001750;
#else
static const char object_brob_Anim_001750[] __attribute__((aligned (2))) = dobject_brob_Anim_001750;
#endif
#define dobject_brob_Anim_001958 "__OTR__objects/object_brob/object_brob_Anim_001958"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_Anim_001958[] = dobject_brob_Anim_001958;
#else
static const char object_brob_Anim_001958[] __attribute__((aligned (2))) = dobject_brob_Anim_001958;
#endif
#define dobject_brob_Col_001A70 "__OTR__objects/object_brob/object_brob_Col_001A70"
#ifdef _WIN32
static const __declspec(align(2)) char object_brob_Col_001A70[] = dobject_brob_Col_001A70;
#else
static const char object_brob_Col_001A70[] __attribute__((aligned (2))) = dobject_brob_Col_001A70;
#endif
@@ -0,0 +1,16 @@
#pragma once
#define dgBubbleTex "__OTR__objects/object_bubble/gBubbleTex"
#ifdef _WIN32
static const __declspec(align(2)) char gBubbleTex[] = dgBubbleTex;
#else
static const char gBubbleTex[] __attribute__((aligned (2))) = dgBubbleTex;
#endif
#define dgBubbleDL "__OTR__objects/object_bubble/gBubbleDL"
#ifdef _WIN32
static const __declspec(align(2)) char gBubbleDL[] = dgBubbleDL;
#else
static const char gBubbleDL[] __attribute__((aligned (2))) = dgBubbleDL;
#endif

Some files were not shown because too many files have changed in this diff Show More