Radium - Dev log

Weclome!
I've been working on a new tool to hopefully fill a gap. Radium is going to be a recorded animation creator, and edit. As well as a halo script IDE. I have a small bit of work done at this point, and I wanted to give a run down on what to expect.

Starting off with the recorded animation editor.

by the initial release I plan to be able to read and edit all recorded animations inside a compiled map, and a scenario file. I decided on working with a project space, instead of modifying individual scenarios at a time. So you can bind as many scenarios as you like to the project. The primary window will have a opengl context which can render actors, as well as vehicles. It will be able to load each of the units in a map, and you can chose which the ra will run on for preview. Each of the vectors can be modified with a rotation gizmo. Along side that is a timeline scrubber, where you can add key points and interpolate between the keys. The timeline will have a curve modifier so you can adjust the weights of the interpolation. Radium will save the recorded animations to the scenario. For convenience it will also be able to call tool (or tool variant) to compile the map(s).

basically for beta release I plan to have the following for RAs done:

Create a Radium project [x]

Bind scenarios to that project[x]

Load existing RAs from scenarios[ ]

Load existing RAs from compiled map [x]

Load RA from a exported snipping.

Find any scripted references to the RA and list which units it's actually used on in game[ ]

modify/create recorded animations[ ]

Timeline scrubber to preview RA[ ]

Keys that can be interpolated between (rotations) [ ]

Keys that can change player control state (start crouch, start jump)[ ]

Keys that can change the players walking direction[ ]

Keys that can bind scripts to be called at specific times during RA (say, when character starts to run, call the script that destroys the warthog)[ ]

Keys that call other recorded animations to play, while this one pauses and waits for return.[ ]
Save the recorded animations to the scenario[ ]

Call tool functions to compile map (Convenience)

Call halo ce with devmode and console (if you don't already have a seperate shortcut for it already)

This would be enough to get us started making custom RAs for halo.

Now since halo script, and recorded animations are closely related, I decided I wanted to go ahead and include an IDE into Radium for halo script. This will also be able to gather the scripts in precompiled, and compiled maps and allow us to edit them in the window. I plan to have full syntax color styling, and auto fill. Since radium binds to the scenario, it will also be able to gather any references, and autofill the correct tag type into scripts for you based on the tags in the map. (say you call 'Recording_play <unit> <RA>' It will automatically fill in the available units in the scenario, and the available RAs in the scenario, and throw errors if you entered something not found.) The script editor will also be able to autofill function return types as well.

Since Radium has access to the scenario information it will also be able to implement "compiler directive" style commands. It can dynamically fill in tag data from the scenario into the script when it saves/compiles the script. Say for example you want to check to see if a specific tag is available in a map, you can ask radium to check if it exists. It will fill in the true or false when it saves the script. This could also be used for anything really. Say...the name of a tag with local directory, which dependencies it has, how many dependencies its dependencies have, etc.

I'm going to ATTEMPT to hook to sapien's .exe and try to find it I can get the function location for compiling scripts. If I can, with a reference to sapien, I could compile a scenarios scripts from inside the editor, and output sapiens output to the output box in radium. This would allow for you to work all in one place, while still getting the scripts compiled the same way they would be if radium hadn't been used.

for beta release I plan to have the following:

Create Radium Project [x]

Bind scenario(s) to the project [x]

Load existing scripts from map [x]

Decompile script data + find string references. [ ]

Load existing scripts from scenario [ ]

Decompile script data + find string references. [ ]

Modify existing, or create a new script

Create script from exported snipping

Dictionary for tags in scenario [ ]

Dictionary for scripts (with return types) in the scenario [ ]

Dictionary for globals in the scenario [ ]

Save the scripts, and organize in the scenario folder. [ ]

(Compile the scripts by calling sapiens script compile function [ ])

Gather tag information dynamically from scenario at compile. [ ]

Beside that there will be some quality of life things like autoback up, and autosave.

a few last notes:

Everything with an x is what's been done already.

After some discussion it will end up open source once it's all said and done.

I do work two jobs, so it might take a bit to finish; however, projected time until a beta release could be a month or two. I plan to update this thread as I go so you can follow along with development.

Here are some pictures of the progress.

I'm not the best at UI design (this is actually my first attempt at a UI with c++ instead of .net); however, I plan to make all the colors customizable as well.

(Sorry for the activate windows, I downloaded the windows 10 beta, then it crashed and fucked me out of my windows 8 legit key. I'm not giving them my money again -.-)

If there are any features you think would be nice to implement, let me know and I'll see if I can make it happen c:

Share this post

Link to post

Share on other sites

Exciting stuff! It reads, and decodes all of the different control versions! literally took me all day to debug it x.x

Did the thing! Also made the panels collapsible to reduce clutter. It parses all of the RA data as well. Had to make some minor tweaks to my core to accommodate for loading from a scenario; however, after two days of saying the magic curse words it worked!
Next is to add the keys to the timeline scrubber, Write the openGL context, and read model data

Share this post

Link to post

Share on other sites

Progress!
It's been a bit of a rough battle, but I've basically caught up on progress on linux. Much still needs to be done; however, everything is loaded and running smooth.

Spoilers for pics

Spoiler

Project Select/ Creation

Main window has some changes

You can rearrange the pannels as well, also stack them since it's using QT docks. (I lied about GTK+ after waisted time)

Graph of facing vectors over time (in frames). Red X, Blue Y. I plan to make these editable with handles. Might be difficult with reading them from file. They look pretty jagged, I'm curious about what it would look like smoothed. in due time though c:

Share this post

Link to post

Share on other sites

Update: the world is ending and both my jobs are considered essential. So I'm working 80 hours a week. I'm working when I can. Current status is I broke everything and need to reprogram core. During optimization I found a lot of redundant code that I could generalize into a parent class. Mostly parsing data, and saving data. Been working on a generic data class. Most progress has been programmatic

Share this post

Link to post

Share on other sites

a lot of programming efforts was going into reinventing the wheel. I was still using my incomplete Core SDK I started months ago. Breaking from that should allow me to focus more on features.

*Please note these are all optional*

Current features in development:

script consolidation - no more 4 script limitations! Spread out your scripts into as many files as you like. Radium will consolidate them into one at compile. This should help larger projects keep more organized. This is done with a c style include, or module style “from ____ import ______”

Internal reference resolution - access the initial data from the scenario as parameters for functions. This will allow you to do things like

and radium will fill in the name of the starting primary weapon when it consolidates the script. The arg just strips out the file name from the entire path. This should help generalize scripts

external reference resolution - let’s you import a tag, and use it just like with an internal reference; however, it allows you to gather information from a tag that won’t be built into the map. Only has access to the initial information, if you want real time data use LUA. This should help generalize Scripts.

integrity check - verifies syntax and checks for errors before sending to sapien for compile. This should help debugging by giving error highlighting.

Multiplayer desync checker - gives warnings when a command is used that won’t work in multiplayer (this is far on the back burner)