Alchemy 5 Tutorial

Started by ak2yny, January 13, 2022, 12:18PM

Previous topic - Next topic
January 13, 2022, 12:18PM Last Edit: November 09, 2023, 12:34AM by ak2yny


By UltraMegaMagnus, nikita488, KingAdam85, LarsAlexandersson and ak2yny
Logo by Outsider

Table of Contents
Supplemental Content

What is Covered in This Tutorial

      This tutorial covers the installation and usage of the Alchemy 5 version that we have, thanks to KingAdam85, including Finalizer, Insight Viewer and 3ds Max Plugins.

Requirements and Limits

  • Alchemy 5, MSVCR, and DirectX are covered in the installation guide below.
  • 3DS Max, min. v2008, max. v2012: Optional.
  • Windows. Doesn't run on Linux systems (incl OSX).

General Knowledge


      Alchemy is the game engine the X-Men Legends and Ultimate Alliance games run on. Vicarious Visions acquired Alchemy and developed it during the times that these games were released.
      Silicon Studio is responsible for the translation of the Alchemy 5 version that we have. Because this studio is based in Tokyo, the installer and parts of the documentation are in Japanese. The Programs themselves are in English and Japanese.

      By the way: Alchemy was originally developed by Intrinsic Graphics, which was acquired by Vicarious Visions, that's why we find the letters IG in Alchemy everywhere.

      When we start the games, we get some company credits, and Alchemy is one of them:

Alchemy 5?

      Each new game can have new functions, because the game engine also evolved, as game developers learn and progress themselves. Version 5 of Alchemy has new functions, compared to Alchemy 2.5 (which was the only version we had before), like animation mixing, a command line tool for optimizations, easier exports in 3ds Max, and many more. We still discover new functions today.

      However, game engine versions are not forward compatible, in most cases. They are backward compatible, meaning IGB content from older games mostly work in newer games. Some content of console versions and PC versions aren't compatible, even with the same game engine version. Sometimes, we can change the version number of each IGB file (which corresponds with the Alchemy version number) with a hex-editor, by changing offset 2c. It must be a specific maximal number for the various games and versions. MUA PC 2006 must have max. 08 at offset 2c, in XML2 PC it's 06. Changing this number sometimes makes IGB files forward compatible, but it doesn't always work (eg. Alchemy 5 content doesn't work in XML2).

Quote from: Dark_Mark on October 07, 2008, 11:34AM
Alchemy may be a little old, but it's all we have.
Dark_Mark was talking about Alchemy 2.5, but it's true today for Alchemy 5 as well. We were very lucky to find a newer version of Alchemy, which allows us to create more content for Ultimate Alliance.

      The version we got, is an evaluation copy only, and asks regularly to connect to This should not be functioning any longer, so it doesn't matter if you click 'Yes' or 'No'. I recommend to click 'No', since there is no point in having it use your internet without getting results.

Child and Parent?

      I am assuming that the relationship between parents and children is known to the reader. Much like the child comes from the parent, the child node comes from the parent node, and nodes are arranged in a similar structure like a family tree, (schematic view). The schematic view is not active, if the scene info is missing, but the parent and child nodes are always arranged in such a way that it is clear who is the parent (tree view), and child nodes sometimes are in a group called "childList". Alchemy processes nodes, starting at the root and going through (traversing) all children, top-down in the schematic view. The whole structure of the parent and all children are a form of a scene graph, and often called like this in the apps and documentation.

      And what are nodes? It's not so important to understand that. For our purpose we could see them as things with a name and often properties. Each node can have a different function.

Optimization, Finalizer, Insight?

      The Alchemy tools come with two main programs, with an UI. The first program is Finalizer, which can be used to edit IGB files, including automatic processes, which are called optimizations. The second program is Insight Viewer, which can be used to preview model IGB files. IGB without a scene info (igSceneInfo) won't show in Insight. All texture-only IGB files (eg. icons, loading screens) can not be viewed with Insight.


      The programs to create IGB 3D content are 3DS Max and Maya by Autodesk, but they don't support IGB files by default. We need a plugin for that.


      Alchemy uses the word skin for two things: Skin, as in weighted (skinned) model with skeleton; and the Skin modifier from 3DS Max. Both are related to the same thing, a geometry that can be "morphed"/modified by bones (skeleton). A gemoetry that can't be modified/changed is called a model or unskinned geometry, while skins are sometimes called skinned geometry.

Texture Map?

      Alchemy 2.5 and early games didn't support multitexture techniques, so let's talk about this for a little bit. They are textures that look similar to the main texture (commonly referred to as diffuse map), but with different colors and shades, which add certain effects to the skin. The coolest is probably the normal map, which adds bumps to certain areas, simulating height on a flat geometry (sometimes called bump map, while the official bump map does the same with a different method). MUA has a certain, uncommon way to handle the textures, so please check this post. The most noticeable one is the normal map on PS3 and PC 2006, which is almost a compressed normal map (DXT5nm), except that it uses the standard DXT5 format. The 360 and Remaster versions use the standard normal map, remaining versions don't use any normal maps.

Alchemy 5 Documentation

      With the installed version of  Alchemy 5 comes a documentation in Japanese. Unless you speak Japanese it may not be very useful. But it can be quite helpful, if you understand codes. It also has pictures, and you can copy the text and use a translator. A considerable part of it is in English, and searching for content (eg. igTransform) works in most cases.

      I also recommend to check out the Alchemy 2.5 documentation for specific help in English (eg. about igTransform).

Useful Links

January 13, 2022, 12:18PM #1 Last Edit: March 02, 2024, 01:31AM by ak2yny


By UltraMegaMagnus, nikita488, LarsAlexandersson and ak2yny
Logo by Outsider


      0) Make sure, that Microsoft Visual C++ 2008 Redistributable (MSVCP) is installed: Go to "Apps and Features" (Windows 10 settings) and scroll down to check if it is installed. The plugin DLLs also need version 2010 (or 2012 or 2013 needs to be tested).
      In case it is not installed, download and install it from here (2010). A 64bit system requres both, the 32bit and 64bit redistributables. If MSVCP is not correctly installed, you will get an error about "side-by-side configuration" when you try to use Alchemy. If MSVCP 2010 isn't correctly installed, you'll not be able to view certain skins or use certain tools.
      Also make sure that DirectX 9c is installed. Usually it's installed with XML2 or MUA1. It seems like the games sometimes run without DirectX 9c, so if you get some DLL errors when using Alchemy, be sure to install the DX9 libraries.

      Important: Skip the steps that you already did (i.e. don't install Alchemy 5 a second time).

(skip for portable version)

      Download Alchemy 5 (includes some tools by nikita488)

      1) Extract the archive and execute "Alchemy50-BaseEvaluation-10-0529.exe" in the folder "1 - Alchemy 5 Installer...".

      Here comes the tricky part, because the installer is in Japanese only. But don't worry, it is pretty straight forward:

      1a) The buttons are on the bottom-right, as we are used to from other installers. To continue, we need to click the "Next" button (as marked in the image below).

      1b) Fortunately, the buttons are mostly identical in all windows. The second is slightly different, but at the same place. Click on "Accept" (marked) to accept the licence agreement.

      1c) The next window allows us to select the location, where we want to install Alchemy. The default location is C:\Alchemy, but you can click on (browse) to change the location (the pop-up window will be in the system language). The "Alchemy" folder will automatically be added and created. Click on "Next", if satisfied with the location.

      1d) The fourth window is to setup the environment variables. It is extremely important that you don't change them, because Alchemy and related tools will not work if anything is changed here (Alchemy path [1] must be IG_ROOT, and Path variable [2] must be selected). Simply click "Next" (3).

      1e) We are asked if we want to install ArtistPack, and SDK files for DirectX. DirectX 9c is a pre-requirement, but it is already installed, if XML2 or MUA1 are running on the same machine. ArtistPack on the other hand is the core of Alchemy and must be selected. Then, click on "Next".

      1f) If a compatible 3ds Max and/or Maya is installed, you may install the corresponding plugins. I recommend to not select any, as that's covered in step 3. Click on the marked button to start installation.

      1g) During installation, you may be confronted with warning and information messages. Click on "OK", the installation should still complete successfully. After the installation is complete, click on "Next".

      1h) At the end, you can unselect to open the Readme, and click on "Finish" (marked).

      When Alchemy is installed, you get shortcuts in Windows start menu, called "Alchemy Finalizer" and "Alchemy Insight Viewer". You also have a proper installation entry in "Apps and Features", which allows you to safely, and correctly remove Alchemy.

      2) Copy everything from the folder "2 - Copy-paste the content of this folder to your Alchemy 5 installation directory" (found in Alchemy 5 and tools.7z) to the same directory, where you installed Alchemy (including Alchemy folder). Make sure that the folder structure matches. The process was successful, if you replaced "libIGCore.dll" and "OptDefaults.ini".

Portable Installation
(skip if you already installed Alchemy 5)

      Download Alchemy 5 Portable (includes tools by nikita488)

      1) Extract the ZIP to a location of your choice.

      2) To install environment variables, and effectively make Alchemy 5 Portable work, run Setup.bat as administrator.

      This often doesn't work on Windows 10. If no window appears with a success message...
      2a) an elevated command prompt (do not use an already open command window - you have been warned), and...
      2b) ...type or paste the path and name of the Setup.bat, including double-quotes, eg. "C:\Alchemy\Setup.bat", and press enter.

      Hint: If you move Alchemy Portable to a different folder, you can run Setup.bat again to update the information.

Optional: Install the 3ds Max plugins

      3) Plugins exist for 3ds Max versions 2008-2012 32bit (64bit is not supported). If you don't have one, I recommend to get v 2012 32bit (SP2, Update). Note: this is a trial version, and it's not possible to buy a licence for it today, AFAIK. The "other option" is not revealed here.

      3a) Download the Plugins.
      3b) Extract the archive.
      3c) Install the plugin for your version of 3ds Max. The procedure for installing plugins is always the same. (video)
      3d) Move or copy the content of MaxScripts to C:\ProgramFiles (x86)\Autodesk\3ds Max <ReleaseNumber>\
      3e) Open 3ds Max and add the Alchemy icons to a toolbar.
            (In category, select "Alchemy")

      Repeat step 3c for any other plugins you want to install (eg. FBX plugin), and step 3d for any scripts (eg. ActorX "plugin").

      Some plugins are easier to install, if they come with an installer (.exe).

Finish Installation

      4) If you didn't reboot before, I highly recommend to do so now, because the environment variables are usually not working unless you log-out and log-in again.

Reset Alchemy

      After two months, Alchemy 5 locks access, because it's just a preview version. Don't worry: to re-grant access to Alchemy 5, you only need to remove the registry information that tells the program when it was installed. Follow these instructions:

      1) Download the Alchemy registry reset batch file by MrKablamm0fish.

      2) Run "Reset_Alchemy_5_Eval.bat". You may be confronted with a "Windows protected your PC" window. In this case click on "More Info", and "Run Anyway". Press a key when prompted.

      That's it. Now, Alchemy 5 runs like it was newly installed.

Uninstall Alchemy


      Follow the regular uninstallation process.

Portable Installation

      1) Go to the Alchemy 5 installation folder.

      2) Run Setup.bat. If one of the two following messages appear, press 'Y' to unregister/uninstall Alchemy 5.
An identical installation was found. Do you want to unregister Alchemy from this system [Y,N]?Alchemy found. Do you want to unregister Alchemy from this system (press N to update the setup instead) [Y,N]?If another message appears, Alchemy 5 is already uninstalled. In that case, close the console (black window) to abort.

      3) Optionally, also delete the complete Alchemy 5 folder.

Useful Links

January 17, 2022, 03:37PM #2 Last Edit: December 22, 2023, 06:51AM by ak2yny


By ak2yny
Logo by Outsider

Getting to Know the Finalizer UI

      If we start Finalizer, the window will be empty and useless, until we open a file. Common methods to open a file work in Finalizer, including dragging, and dropping files on the window, except dragging them onto the Optimiziations section (2), which will display a warning (so no problem, if you accidentally dropped there). File > Open is another common method to open files, which is also supported by Finalizer. If Finalizer is associated with IGB files, you can open them directly from file explorers.

      Once open, we will see various content in each section of the UI. Let's start with the five main sections.

      On the bottom-left (1) is the Optimizer Palette, with all installed optimizations, which can (potentially) be applied to the IGB file. The optimizations can modify the IGB files, but they can often be used to see content (such as displaying information, or extracting images).

      On the bottom-middle (2), there's the Optimization section, where the selected optimizations appear. This is usually the part that we use most, when working with Finalizer. Many optimizations provide options (settings), to adjust each optimization. Double-click on an optimization in this window to display and change these options (3). There can be multiple identical optimizations in this window, and they can have different options.
      Right-clicks on an optimization will bring up the context menu. "Configure" brings up the same window (3), like when we double-click on an optimizaton. "Reset configuration" restores the default settings for the selected optimization(s). "Load configuration from file" lets us browse for an ini file with saved settings for this optimization. A warning will show (and nothing else will happen), if the ini file has incompatible settings (eg. are for a different optimization). Save such an ini file by selecting "Save configuration to file". Multiple optimizations can be saved, one after the other, by selecting multiple ones. These ini files can be loaded as optimization sets as well. This can be done by clicking on "Add optimization set". To replace the existing optimization list with the ones for an ini file, drag and drop the ini files onto the optimization section (2). Accidentally dropping them on a different section will display a warning and nothing else will happen. If we want to save all optimizations as an ini file, we can select "Save all as optimization set". Select "Save selected as optimization set", to save the selected optimizations in a single ini file. Chenge the order of the optimizations be selecting "Move up" or "Move down". We can do the same by dragging them up and down. Remove one or multiple selected optimizations by selecting "Remove item" (or pressing Delete). Select Remove all items to clear the optimizations section. "Run this optimization" will run the selected optimization(s), while "Run all optimizations" will run all. Tha latter can also be done by pressing Ctrl+R, or clicking on Run optimizations (4). Optimizations will be run from top-down. When an optimization ran, it will be greyed out, until a a new file is opened. A greyed out optimization can not be changed, saved (except if all are saved), removed, or run.

      The optimization output is displayed on the bottom-right (5). It will show a minimum of information about the file and optimization, and will display "Optimization thread finished" when done.

      The top-left section (6) displays the content of the IGB file. It is called tree view. We can browse through the content like in Windows File Explorer. Each thing with a plus (+) is a node, all others are attributes (properties of a node). Attributes can be nodes too. There are various types of nodes (eg. igGroup, igSkin, igActor, igAttrSet, igTransform, etc). This type defines the content and attributes of a node.

      On the top-right (7) is the schematic view, which displays the same content as the tree view, but nicer. This view is not always active, depending on the IGB file. Right-click on a node brings up the context menu. "Properties" just shows more information and is not very useful. "Edit object fields" is the most useful option, and it lets us change the name of the node, and often various properties/attributes. Attributes are displayed as child nodes in the tree view, but they have to be edited by selecting "Edit object fields" on the parent node. When an attribute is a node (with a + in the tree view) it is displayed in the schematic view, and can be edited, like a node. "Find in tree view" jumps to the tree view and selects the corresponding node there, expanding all parent nodes. The same thing can be done the other way around in the tree view, by selecting "Find in schematic view". "Select parent" selects the parent node (the one above), "Select childeren" selects all child nodes, while "Select descendants" selects all children and their children (descendants) and theirs, etc. "Select siblings" selects all nodes that have the same parent node, like in a family, plus itself. "Open item(s)" and "Close item(s)" opens all selected nodes to display the child nodes. The same can be achieved on a single node, by double-clicking on it. "Create new child for item" and "Create new attribute for item" let us create child nodes and attributes for the selected node. "Move item(s) to new parent" does exactly what it says. This allows us to rearrange the nodes, insert parent nodes (create child on parent and move to this new child), or remove parent nodes (move to grandparent and delete parent). "Arrange selected item(s)" arranges the selected child nodes alphabetically. "Show item in viewer" is supposed to show the item (eg. segment) in the insight viewer, which we can opened by selecting View > Show viewer. This crashes Finalizer in most cases, however. "Select root node for optimizations" defines the selected node as root node. Optimizations only apply on the root and all its child nodes, so this can be used to omit other nodes from the optimization(s).
      Only "Properties", "Edit object fields", "Delete item(s)..." and "Find in tree view" (schematic view) are available in the tree view as well. This means that we cannot rearrange the nodes, or add nodes and attributes in a file where the schematic view is inactive.

      Menubar is next. There are also some nice keyboard shortcuts here.

      File: We talked about "Open". "Save" and "Save As" should be clear. The only format supported is IGB, so save as is only useful for changing the filename. I usually use Ctrl+S. "Revert to saved (ReOpen)" is a very useful option, because we can reset the state after adding optimizations that we aren't satisfied with. Undo often doesn't work, so we can use ReOpen to undo all. "Dump to ASCII file (.iga)" and "View ASCII (.iga)" usually aren't very useful, but it sometimes lets us explore the content in a text file, which lets us find more content in there. Then we get a list of recently open files. "Exit" is clear as well.

      Edit: "Undo" would probably be the best function, if it would work for all changes. "Cut", "Copy" and "Paste" are the same as in any other program. Unfortunately, we can't copy/cut/paste nodes or optimizations. "Find in Tree" is the search (find) function of Finalizer. It lets us search in the tree view for a node with a certain name or with a certain type (see below). "Find again" searches for the next match with a single click or shortcut combination.

      View: Toggle "Toolbar", which we'll talk about next. Toggling "Status Bar" makes barely any difference. Not much useful information there. "Show tool tips" displays information in a small yellow tooltip window. We can display the lines in the schematic view as straight "Schematic Lines" or curved "Schematic Arcs" (which is the default). "Show Viewer" displays Insight Viewer. By default, it is shown when Finalizer is opened. We can change that behaviour by editing alchemy.ini, which is in the same folder as sgFinalizer.exe. Select "Hide Viewer" to hide it. "Update remote viewer" and "Set remote viewer..." are functions that probably none of us can make use of, since we are not developers with a console that is set up with a development tool (ie. viewer for Alchemy).

      Optimizer: I never use "Run Optimizations", since we have the button on the bottom-right. The shortcut (Ctrl+R) is much more useful. "Cancel Optimizations" can be useful if we realize, or see, that something is set wrong. Be sure to undo the changes when cancelled, to avoid issues.

      Help: "About sgFinalizer..." shows Alchemy and Finalizer version numbers.

      Lastly, the tool bar. We can't edit it, except toggle it on and off, and drag it around to different locations. The buttons can be quite useful, if you forget the shortcuts, like me.

      The first icon is to open a file, second to save one. Third is ReOpen (see above). Fourth and Fifth are for ASCII files, as described above (not very useful). Cut/copy/paste are not as useful as you'd think, but here you can see right away if you can copy something or not. Ninth and tenth icons are find and find again, as described above. Eleventh is yet another run optimizations button. We'll probably never use the twelfth (remote viewer). The remote viewer would be displayed to the right of it. The thirteenth and fourteenth icons are for remote viewer as well. The fifteenth button is the same info window with the version numbers of Finalizer and Alchemy.

Extra Settings

      Alchemy has an alchemy.ini file with default settings that can make the use of Finalizer more convenient. INI files can be opened with any text editor, and normally are assigned to the default text editor. In it, there are four sections: [CORE] - "useQueryPerformanceCounter" should be true; [GFX] - "multiThreaded" should be true as well; [Finalizer]; and  [PLUGINS].

      Under [Finalizer] are five settings, of which one is important: showViewer = true. This defines if Insight Viewer is always displayed when an IGB is opened with Finalizer or not. True means that it is opened, false means that only the Finalizer window is opened. Change it to showViewer = false, to change the behaviour from the initial setting (showViewer = true). The "viewLine" setting changes the default display option of the lines between nodes. With "unnamedNodeName" we can change the default name of nodes (which are not named by default). We can change the language to Japanese with lang = .jp. If it is missing, the language is English (default). Other languages are not supported. I don't know what "instanceColor" does and it's probably unimportant.

      The [PLUGINS] section allows us to specify the exact location for the folders with the plugins. They should not be defined, as Alchemy automatically reads them as a relative path. The plugins should be kept in the default location and these lines removed (unless Alchemy works as expected).

Run Optimizations

      The main use of Finalizer is running optimizations. They are meant for adjusting an IGB for specific uses, like a specific geme, engine, or platform. There have various other uses, such as debugging, converting, extracting, etc. A few of them are introduced below. Remember that Alchemy 5 is from 2008, and has limited compatibility with earlier and later Alchemy engines and games.

      Often, optimizations should be used in a combination with other optimizations. Most of them can be configured. One or more optimizations, with or without custom configurations, can be saved as an optimization set ("Save all as optimization set", "Save selected as optimization set", or "Save configuration to file"). They are saved in the .ini format, and can be edited with text (or various other) editors as well. Such .ini files are optimization sets. Comment and empty lines are useless for Finalizer. Optimization sets can be loaded by right-click and selecting "Add optimization set" or "Load optimization set" (the latter is only available on an empty optimization section). Load will create a new list of optimizations, and add will add the contents of the set to the current list. The sets can also be added by dragging and and dropping the .ini files from file explorer onto the optimization section, which will replace any current optimizations in the list with the ones from the .ini file.

      Many optimizations are dependeding on others, and a few require the file to be saved, before it can run successfully. The only one that is known to behave like this, is "Externalize images". In this case, run previous optimizations, save the file, and open the file again (or better yet: close Finalizer and open the file again). Then run the "Externalize images" and subsequent optimization(s).

      Here is an example for adding, configuring, and running the "Externalize images" optimization:

      As with many optimizations, it is a very fast and easy process, once you are familiar with it.

Use Finalizer to Extract and Replace Images

      This has its own thread.

Use Finalizer to Merge IGB Files

      Merge an IGB with the currently open IGB file. This is useful for example to add attributes to another geometry (such as a position), or to add geometry to another one (such as objects to a map). To do that, certain attributes and nodes must be connected with each other ("Move items to new parent") and the unused ones removed ("Delete item and descendants"), after merging. In the options, say "yes" to "Append to existing root" to add the new IGB to the root node of the currently open IGB, but it's not recommended, because the hierarchy is less logical.

      We can also merge IGBs by holding Ctrl while dropping an IGB to an already open IGB file. It will be appended to the existing root node.

      Example for merging two objects, to replace one with the other, including connecting and removing nodes:

Use Finalizer to Create Attributes

      Attributes are properties to objects, such as their transparency (can be used to enable and disable transparency). With "Create new attribute for item" we can select from most attributes, but they do only affect certain types of nodes or attributes.

      Example for adding transparency to texture attributes via the alpha function attributes:

Use Finalizer to Scale, Rotate, and/or Move

      If the IGB's schematic view is active, geometry or textures can be transformed by editing the parent's igTransform matrix. If a node doesn't have an igTransform parent (or grandparent, etc.) in a proper location in the hierarchy, it can be created by selecting "Create new child for item" and igTransform from the drop-down list (using specialized igModelViewTransform, igStoreTransform, or igTextureTransform can help with processing speed).

      A transform matrix is difficult to understand for humans, so I made a spreadsheet to translate humanly understandable transformations (rotate, scale, etc.) for us.

  • Copy the current matrix and paste it in the spreadsheet under Input Matrix.
  • Enter the transformations on the left side.
  • Copy the Output Matrix (copy) and paste it in the matrix field of the igTransform node (replacing the complete content)
Always copy the complete Matrix. Be thorough. Here's the spreadsheet.

      Here is an example for moving a mannequin:

      NOTE: AFAIK, it is not possible to transform a skinned geometry in the same way, because of the weights. Needs to be tested.

Use Finalizer to Create Skin Segments from Separate Geometry

      Any geometry node can be added to an igSegment parent ("Move item(s) to new parent"), which can be named. This enables the geometry to be separately shown and hidden in the game by using a segment code with the same name that the node was named.

Use Finalizer to Hide (Remove) Skin Segments

      Segments can be removed by deleting igSegment nodes ("Delete item and descendants"):

January 19, 2022, 02:14PM #3 Last Edit: March 02, 2024, 01:43AM by ak2yny Reason: Adding frame details


By ak2yny
Logo by Outsider

Getting to Know the Insight Viewer UI

      It's very important to experiment with this app, as it is easier to learn it by doing, than reading anything here. Some IGB files (all original skins) don't display in Insight, because of incompatible parts in the file. They have to be viewed in the game.

      What isn't viewport operations (2), time controls (3), or menu bar (1), is called viewport. In the viewport, we can use the mouse (press and hold buttons and move the mouse) to rotate, move and scale the view in a three dimensional environment.

      The viewport operations (2) control the functions of the left and right mouse button. The pick mode (leftmost button of the viewport operation) disables the right mouse button and enables the left button to select elements of the displayed object(s). Sometimes no element can be selected, which means that it is basically disabled, too. Once any elemet is selected, the mouse mode is automatically changed to the second, middle mode, the rotate mode. The rotate mode is the standard mode, and enables the left mouse button to rotate (around Z and Y axes) and the right button to scale (zoom, actually) and rotate around the X axis. The focus point for scale and rotate is the origin point of the object(s). The middle mouse button can be used to move the object(s), which is the same in all viewport operation modes. The fly mode (rightmost button of the viewport operation) enables the left mouse button to slowly zoom-in and the right button to zoom-out (press only, moving the mouse does nothing). This zoom drags slightly after releasing the button.

      The leftmost menu in the menubar (1 - Alchemy icon) shows the Alchemy version and other details about Alchemy.

      The second menu "File" has common commands, such as "Load" (same as open), "Save" (save as), and "Quit". "Reload" is not very useful (only if the file has been changed). I don't know what "Save Concrete" does (seems to do the same thing as Save). This menu is not available, when the viewer is started through Finalizer.

      The third menu "View" has quite a few practical commands. "Reset view", for example, as it restores the initial view, which shows the model/skin/map as the whole from the front. "Reset vertical" only restores the vertical positioning, which often results in unpractical views. "Selected object(s)" is all about how selected objects display when selected in the pick mode. There is no other way to unselect, other than with this Unselect command. Center on selection puts the selected elements to the center without changing the zoom. If nothing's selected, it centers to the origin point. Fit to selection does the same thing, but adjusts the zoom to the selected element (very close if nothing's selected). Show name shows the name of the selected element in the text area, which starts at the bottom left area of the viewport (added at the bottom of the list). Show selection and Show bounding box show a wireframe cube with the extents of the element, filled with a semi-transparent color with the latter command. Show normals is to display the direction that each triangle (polygon) is displayed to (don't ask me why it's called normals). Show triangles shows the selected element as wireframe, which consists of the polygons/triangles. "Viewport operations" has the same three commands as the three buttons on the bottom left (2). "Camera" lets us select a camera view, if the IGB file comes with at least one. In this case, the view will be as this camera is positioned, instead of showing the whole model from the front. Although, the camera views seem to not work so well. We can "Export camera"s, which saves a cameraExport.igb file (with the current position of the view in the viewport and a camera node), even if the viewed file has no cameras. In "Home view" we can Save a view and Restore it, in the same way the Reset view works. If no view is saved, Restore does the exact same thing as Reset view. I don't know what Clipping planes does, this information will be updated as I know more. "Hide UI" is one of the most important commands to talk about, because once it's hidden, it stays hidden (no access to commands). The only known fix is to close Insight and open it again. It may happen that the hidden UI is saved and it cannot be reversed, unless the Alchemy registry is removed (be extra careful when modifying the registry). "Dump output" usually does nothing. We can show "Planes", which divide the shown object along one or multiple of three dimensions, along the origin point, with a semi transparent plane.

      "Options": We can "Disable" various attributes of an IGB file. Texture, are the only ones that almost always make a difference. Other attributes that can be disabled/hidden are: lighting, blending, texture matrix, fog, depth test, vertex blending, alpha test, clipping, and cullface. If an IGB scene has lights, they can be disabled and enabled with the "Lights" > Use scene lights command. They are enabled by default, but lights are always off, as long as lighting is disabled. Use head light and Use specular head light turn on an additional light, which shines on the object from the current viewpoint. We can activate or force (activate must be off) the next four commands. "Alpha test" is about alpha channels (transparency), but I don't know what it does exactly. "Back-face culling" is to remove everything that doesn't face the front (ie. is hidden/invisible). The difference should not be visible (unless normals are corrupt). "Wireframe" displays the object(s) as a wireframe. "Flat shading" ignores that the geometry is smooth, which more or less results in an unsmoothed object, if a shader/light is applied on the object. "Sort" and "Transparency" are about texture transparency. Sort is about interaction of the visuals Textures, Transparent, Transparent BackToFront, and Opaque BackToFront. Methods are Default, No depth write, Separate front and back, and Separate front and back no depth write. These make no difference unless an object has partial transparency. The area where the scene is visible, can supposedly be modified with "Frust cull" (FRUST_CULL - default/pyramid, AABOX, or SPHERE). Usually, makes no difference. It's possible to increase, or decrease "Patches", which is usually not seen on the object(s).

      "Time": Is all about animations. Here are the same controls, that are found on the bottom right of the window (3) - except "Reset" (reset all time controls); "Normal speed"; animation play modes: "Loop", "Bounce", "Continuous" which replace the play mode defined in the IGB that plays initially; and "Display time" and "Display speed". "Stop", "Play", and "Play back" control if the animation is played while the speed is preserved. "Increase speed", and "Decrease speed" are very helpful to better view the details in an animation. For even more details, or to find an exact position, we can use "Step forward" and "Step backward" while the animation is stopped.

      "Statistics": There are a lot of commands in here, but I'll keep it short: We can display pretty much anything about computer graphics, displaying at the same location on the UI as Show name (or Display time and speed). For example, we can display the Geometry Node count an object has. Useful to know how many parts a skin has (incl. skin segments). Performance > Frame count is missing in the preview above, but it displays how many frames the current animation has (frames = animation length). Additionally, it's possible to display the frame rate (as seen), but it's just the current frame rate of Insight Viewer, which is usually very high (depending on the machine), indicating that Insight requests a lot of resources. We can "Reset all" statistics, if they are dynamic, or "Hide all", to get a clean UI again.

      "Actor": Is all about animations again. Actors are basically geometries that are able to act, ie. transform themselves (incl. skeletons and animations). The "Actor" sub-menu lists all skeletons of a skinned geometry. There is usually only one (skeletons in animations aren't listed), and we don't have to use this often. The "Anims" sub-menu lists all animations from an animation file. If we click on one, the animation is played in the play mode it has defined, except if a play mode in the Time menu is selected. With "Randomness" we can randomly play an animation from the list by activating Auto Switch (not sure what Random Start does). In Change interval, and Change count, we can change the randomness settings. "Show Anim Name" shows the current animation detail at the same location as Show name. If an animation was reflected with the Reflect animations optimization, this can supposedly be enabled and disabled with the "Reflected" command (not tested). Skeletons of animations are not shown, not in the menu, nor in the viewport. We can show the skeletons of skins, however, by enabling an option in "Show Skeletons" (Skel Only or Skel+Skin).

Opening Multiple Files in Insight Viewer

      It's possible to have multiple .igb files open at the same time, which allows viewing them together. This is most useful for viewing animations, because their skeleton doesn't show. It's possible to open files from different locations, but the most common way is to drop them onto the app (1) or shortcut (2), which only works with files from the same folder.

      The only other method is command prompt, which allows opening files from various locations. For example: Open a command prompt window, drag and drop the insight.exe onto the window, and then the .igb files, one after the other (from the file explorer). Make sure to add a space after dropping each file and .exe.

      When we open a skin and animation sets (or multiple ones), we can preview animations, because the skeleton of the skin can act the animations. Skins that have been exported with Alchemy 5, can act the animation with the skin. Otherwise, only the skeleton can act the animations (if they have an igSceneInfo). Use one of the Show Skeletons commands.

Example showing an animation and two Alchemy 2.5 skins with Skel+Skin active.

Use Insight Viewer for Skinning

      Skinners who make skins for Alchemy 5 compatible platforms (MUA1) may prefer the Alchemy 5 method to re-skin IGB skins. After extracting the images, they can view the current version of the extracted image in Insight Viewer, by selecting File > Reload. Nice: They can have the image file and viewer next to each other, then save the image, and reload in Insight to see the result right away. The image may first be replaced with another.

      Images can also be extracted with different settings, depending on the format. Make sure to always select "Yes" on Reference external, and "No" on Internalize Images. I recommend to use PNG format (Extension) for X (eg. IG_GFX_TEXTURE_FORMAT_X_8) and RGB (only RGBA 32bits has been tested - RGBA_8888_32) formats. Use TGA for everything else.

January 20, 2022, 03:40AM #4 Last Edit: February 10, 2022, 07:05AM by ak2yny


By ak2yny
Logo by Outsider

      Coming Soon...

January 24, 2022, 03:40AM #5 Last Edit: March 26, 2022, 06:23AM by ak2yny


By ak2yny
Logo by Outsider

Getting to Know the Command Prompt

      Correct usage of sgOptimizer and animationProducer depends on knowledge of the command prompt. This is common knowledge and shared in a lot of media, not difficult to find.

      However, there are some extremely convenient actions for the command prompt, which are difficult to find in one place. First off, we can recall previous commands with the "up" and "down" arrow keys.

      In the video above, you can see how to interact with files, by first browsing to them. We can skip the browsing by entering the complete path to the file (which is identical to the text left of the ">") and the filename and extension (which is identical to the text right of the ">"). In one of the examples above, it would be: "C:\Users\adam.morrell\Desktop\sample.txt". In a command context, for creating a folder for example, it would look like this: "mkdir C:\Users\adam.morrell\Desktop\folder1".
      This gets problematic as soon as the path, or the filename include any character from the Quotation marks are required... list in the cmd wiki article. The path and filename must then have one double-quote at the very start (before the drive letter) and one at the very end (after the extension), ie. be surrounded by double-quotes.
      We can use autocomplete with tab while typing full paths as well, which will automatically add double-quotes for us if needed (but it's buggy with some special characters). We can drop a file from the file explorer on the command prompt window and the full path and name will be insterted. But we have to make sure to sourround problematic paths/filenames with double-quotes.
      Is a full path and filename really easier than browsing to it? That's up to you. And browsing to a location can be speed-up by using the file explorer in a similar way (drop a folder on command prompt, after the "cd /d " command), or by opening up command prompt at the target location.

      We can also copy a path and/or filename, or a part of, or full command, and paste it in command prompt.

      We only talked about absolute paths now. But we can also use relative paths, which are convenient, if we are working by browsing to locations.
      Example: I have two files. File1 is "C:\Games\MUATools\animations\previewAnimations.bat", file 2 "C:\Games\MUATools\animations\default\14_warbird.igb". I want to use both files in the same command, but I can't use them together ("previewAnimations 14_warbird.igb"), because they aren't in the same folder. I can use the relative path to the .igb, however, which looks like this: "previewAnimations default\14_warbird.igb", when I browse to "C:\Games\MUATools\animations". When I browse to "C:\Games\MUATools\animations\default", I can use this command: "..\previewAnimations.bat 14_warbird.igb". A relative path can contain multiple sub-folders (eg. "animations\default\14_warbird.igb"). These relative paths can be used with anything (eg. cd "Games\MUATools\animations"). We can use autocomplete (with tab) as well.

      In the latest version of cmd, we can use the mouse to select, but we can only copy the selection.
      An example for creating a collide hull (so we can't walk through the object) with ravenOptimizer, including copy/pasting a command:


By Vicarious Visions, ak2yny
Logo by Outsider

Optimizations in Finalizer and for sgOptimizer (command line)

      External, saved, folders, etc., as specified in the options, must always follow Windows rules, ie. must not include invalid filename characters.

igBuildNativeGeometry: Build native igGeometryAttr2 (geometry)

      Converts igGeometryAttr2 vertex buffer into platform specific format and build platform specific display lists. (Xbox 360 = Xenon)
      Options for removing original data, specific options for Wii, and PS2.

igChangeInterpolationMethod: Change interpolation method (animation)

      Changes the interpolation method in the animation objects igTransformSequence1_5, for faster interpolation.
      Options for splines, for translation (position), rotation, and scaling.

igChangeObjectName: Change object name

      Changes the name of a node.
      Options to filter the node type and target name (old name), and for a new name.

igChangePlayMode: Change play mode (animation)

      Changes the play mode in the animation objects igTransformSequence1_5 or igEnbayaAnimationSource.
      Options are repeat (0); clamp (1); bounce (2); loop (3); bounce once (4); reverse repeat (6); reverse clamp (7); reverse bounce (8); reverse loop (9); reverse bounce once (10). Clamp means that, after the animation, the last frame is held, until it is cancelled or replaced. Bounce means that the animation is played forward and then backward. Reverse means that the animation plays backward, and in bounce, that it plays backward and then forward.

igClearMaterialSpecular: Clear material specular (textures)

      Clears the specular color component for all material nodes in the scene.

igCollapseAllHierarchies: Collapse all hierarchies (IGB structure)

      Simplifies a hierarchy by replacing complex nodes with equivalent simpler forms and removing empty ones. Deletes empty groups and attribute sets, applies static transforms to children, and combines chains of attribute nodes.
      Options for nodes to exclude, and order preservation.

igCollapseHierarchy: Collapse hierarchy (IGB structure)
      Same as igCollapseAllHierarchies, but the node type has to be selected, and only one type can be optimized at a time.
      Options for node type, and order preservation.

igCollectLight: Collect static lights (light and shade)

      Collects static lights in the scene into a single node, attached to the root.

igCombineAnimDatabases: Combine Animation Databases (animation)

      Combines the specified context files of skins, skeletons, and animations into a single IGB. This is similar in function to the Animation Producer, but simplified.
      Options for plain file lists for context, skeletons, skins, animations, appearances; also options to reset bindings; and for default skeletons, skins, animations.

igGenerateMacroTexture: Combine textures (textures)

      Combines a list of separate textures into a single mosaic macro texture. Texture coordinates are fixed as well.
      Options for max. width and height; texture name; texture format; PS2 specific option.

igCombineTransforms: Combine transforms (geometry, animation)

      Combines stacked transforms (reduce node count). In animations, if they have a transform sequence their keyframes can often be merged. It gets problematic if the resultant transform contains a shear.
      Options to filter transforms by name, and shear detection.

igCompressGeometryAttr2: Compress igGeometryAttr2 (geometry)

      Compresses igGeometryAttr2 vertex data into fixed point numbers. By default, only the geometry statistic is shown. The format has platform specific.
      Options for vertex data, platform, and statistics.

igConvertGeometryAttr: Convert igGeometryAttr to igGeometryAttr2 (geometry)

      Converts igGeometryAttr into igGeometryAttr2. igGeometryAttr2 is more flexible and uses igVertexArray2 for its vertex array interface.
      Options for bounds of igVertexArray2, and access mode for igVertexStream (must be IG_VERTEX_ACCESS_WRITE_ONCE [3] to save the concrete form of an igVertexArray2).

igConvertMorphInstance: Convert igMorphInstance to igMorphInstance2 (geometry)

      Converts igMorphInstance into igMorphInstance2. Check Supplement 2.
      Options for creating info, and removing igMorphSequence.

igConvertImage: Convert images (textures)

      Converts textures between different internal formats. Accepts a file with a list of filenames to include/exclude.
      Options for format (incl. pixel order for each platform), memory saving, incl./excl. list (the filenames must not include the path, but the extension they're registered with inside the file, which often doesn't match the actual format).

igConvertSimpleShader: Convert to igSimpleShader (light and shade)

      Converts from older shader methods to igSimpleShader, which is the current way to set-up shaders.
      Options for set-up mode, platform, shader parameters, and debugging.

igConvertTransform: Convert transformations (transform)

      Optimizes transform sequences by replacing them with a faster one where possible.
      Options for tolerances.

igOptConvertTextureBindAttrto1_5: <TAM> Convert igTextureBindAttr to igTextureBindAttr1_5 (textures)

      Converts igTextureBindAttr to igTextureBindAttr1_5 to use the Texture Asset Manager-based (TAM-based) API of the visual context (handle-based pagable API).
      Options for name and export.
      Hidden optimization.

igCreateToolInfoFromGeometry: Create Geometry Tool Info (geometry)

      Creates a info node, which stores all of the geometry nodes of a specific type.
      Options for name, and geometry type filter.

igCreateLod: Create LOD

      Creates a level-of-detail node.
      Options for numbers of levels (lod); max. and min. range; config file (unknown format); name.

igCreateTransform: Create Transform (transform)

      Creates a transform node above the specified nodes according to a macro language. The format is [r|s|t][x|y|z|u|<#,#,#>[w|h|d][ #]. For example: to rotate 90 degrees about the Z axis, translate 5.4 down Y, and uniformly scale by 1/3 of the width of the subgraph, type "rz90 ty5.4 suw0.33" in Matrix string. Also supported: "origin normalize" - the keyword origin translates the center of the subgraph to the original, and the keyword normalize will scale the subgraph by its largest dimension, making the largest dimension length 1.0.
      Options for node filtering.

igCreateActorBounds: Create actor bounds (animation)

      This optimization tracks all the bones of an actor by playing all animations in igAnimationDatabases on it. The maximal extent bound is created.
      Options for animation play sample rate, scale factor, and scaling mode (picture).

igCreateAnimationDatabases: Create animation databases (animation)

      Sometimes when saving an IGB an associated animation database can get dropped from the info list. This optimization searches the scene graph for actors and readds the appropriate animation databases into the info list for the IGB file.

igCreateBoundingBoxes: Create bounding boxes (geometry)

      Produces bounding boxes for each node, optionally allowing a parent and child to avoid redundant bounding box definitions when they are identical.
      Options for removing old bounding boxes; creating new b.b.; optimizing b.b.; preserving b.b. for igActors separately; animations & other transforms (store without transforming is useful for PSP); exclusion; type (AABox [ 0 ], Sphere [ 1 ], Box [ 2 ]).

igCreateInfosFromRegistry: Create infos from registry (infos)

      This optimization creates infos from ini.
      Options for name, existing info list, and ini file.

igMacrotextureStrip: Create macrotexture strip (textures)

      This optimzation can be used to combine geometry that has tiled (repeat) texture coordinates. It uses one dimension of the texture coordinate to indicate which section of the texture to use. Along the other dimension the repeat occurs.  It is therefore limited to textures that repeat in only one dimension, but it is possible to ignore the tiled coordinates along U.
      Options for filtering nodes, ignore U, min. mag. filter settings for new texture, and name for new texture.

igCreateToolInfoFromNode: Create node ToolInfo (infos)

      Creates an igToolInfo which contanis all nodes of a specified type.
      Options for name of info, and node filtering.

igCreateStaticGraph: Create static graph (IGB structure)

      This optimization traverses (process from start to child and further down, 'till the end) the scene graph starting at the specified node(s), essentially saving the output so that the scene graph does not need to be traversed at runtime. This optimization is destructive, the original scene graph is deleted and replaced by a list of igAttrs. All nodes except for igTransform are deleted. igTransforms are reorganized into a transform-only scene graph and special nodes are inserted under them which update the matrices in the pre-traversed attributes. All updates to transform nodes will behave as if though the original scene graph was still around. This optimization can only process nodes which derive from igGeometry, igAttrSet, igTransform, and igGroup - all other node types will be ignored.
      Options for node filtering, mode (experimental modes seem to have been removed), store volume, and restoring.

igStatisticsSkin: Display statistics for actor skins (infos)

      Displays information about animations, skins, and bones (skeleton).
      Options for content, sorting, and layout.

igStatisticsGeometry: Display statistics for geometry (infos)

      Displays information about the vertex data in geometries.
      NOTE: Morphed vertex count is the base vertex array being morphed. "Skinned" counts are any vertices/primitives that have blend indices. Morphed, skinned vertices and primitives are counted only once, and are counted in morph total. Instanced geometry is counted again, so total vertex count is indicative of the number of vertices the host machine will have to process each frame; the number is not useful for memory usage calculations.
      Options for content, sorting, and layout.

igStatisticsInstanceUsage: Display statistics for instanced nodes (infos)

      Display information about instanced nodes.
      Options for content, sorting, texture names, and layout.

igStatisticsMemoryUsage: Display statistics for memory usage (infos)

      Displays the number of bytes used by Alchemy objects. Not all data is included in the calculation.
      Options for content, sorting, and layout.

igStatisticsNodeUsage: Display statistics for node usage (infos)

      Displays information about nodes and their relation. (Usage example: igAttrSet has an attribute list and a child list. If there is a pattern where there is 3 attrs and 4 children, this can be identified and the option of creating a hard-coded ig3Attr4ChildSet can be considered for performance gains.)
      Options for content, sorting, node filtering, and layout.

igStatisticsSceneGraph: Display statistics for scene graph (infos)

      Displays information about all nodes. This optimization can cause some memory overhead during processing.
      Options for content, sorting, and layout.

igStatisticsStaticGraph: Display statistics for static graph (infos)

      Displays information about static graph nodes. This optimization can cause some memory overhead during processing.
      Options for content, sorting, and layout.

igStatisticsTexture: Display statistics for textures (infos)

      Displays information about each texture image in an IGB file.
      Options for content, sorting, texture names, and layout.

igStatisticsTransform: Display statistics for transforms (infos)

      Displays information about transform nodes in the scene graph.
      Options for content, sorting, and layout.

igStatisticsDumpGeometry: Dump geometry (Debug)

      Dump vertex values into a file with normal text format.
      Options for start and end vertex number, array info, and filename.

igEnbayaCompressAnimations: Enbaya Compress Animations (animation)

      Use Enbaya compression on animations to reduce file size.
      Options for quantization error, sample rate, track count, statistics, named bones, sorting, and special case file (specify individual animations). If a special case file is used, any unspecified animations will use the options specified in the optimization.
      The Special Case INI file should follow this format: <[animation name (optional filename and database)]>=[quantization error],[sample rate]. (Filenames are case-insensitive; all other comparisons are case-sensitive.) Example:

igExposeActorSkinGraphs: Expose actor skin graphs (geometry, textures)

      Exposes skin graphs by attaching a copy the skins or skin groups below igActors in the scene.

igExportGeometry: Externalize geometries (geometry)

      Creates externally-referenced IGB files for each geometry in the graph. Each igGeometry will be replaced with a reference. The path to the referenced IGB file will be the same as the input file (plus optional sub-folder).
      Options for subdirectory, and prefix.

igExternalizePixelShader: Externalize igPixelShaderAttrs (light and shade)

      Removes all igPixelShaderAttrs from the IGB and moves them to an external igPixelShaderInfo saved in the specified IGB. The current IGB will then externally reference the shaders in the user-specified IGB.
      Option for the IGB filename of the external shader info.

igExternalizeVertexShader: Externalize igVertexShaderAttrs (light and shade)

      Same as igExternalizePixelShader, but for igVertexShaderAttrs.

igImageExternal: Externalize images (textures)

      Finds all textures in a graph and creates external image files for each.
      Options for reference (modifies the hierarchy to reference the externalized images and deletes any internal copies - the file does not work in games anymore); internalize (re-internalize externalized images - does not work from sgOptimizer.exe - does not work on an open and modified file); image format (PNG - works only on PNG8 textures or TGA); sub-folder; overwrite/enummerate.

igExternalizeTexture: Externalize textures (textures)

      Same as igExternalizePixelShader, but for igTextureAttrs.

igExtractTextureFilter: <TAM> Extract texture filter (textures)

      For each igAttrSet that contains an igTextureBindAttr, extracts that texture bind's minification and magnification filter values and creates a new igTextureFilterAttr that is then appended to the current igAttrSet. (igTextureFilterAttr uses the visual context's global filter API and that mode must be enabled by specifying in an Alchemy.ini [GFX] section: useGlobalTextureFilter = true)
      Hidden optimization.

igExtractTextureWrap: <TAM> Extract texture wrap (textures)

      For each igAttrSet that contains an igTextureBindAttr, extracts that texture bind's wrapU and wrapV values and creates a new igTextureWrapAttr that is then appended to the current igAttrSet. (igTextureWrapAttr uses the visual context's global wrap API and that mode must be enabled by specifying in an Alchemy.ini [GFX] section: useGlobalTextureWrap = true)
      Hidden optimization.

igFlattenHierarchy: Flatten hierarchy (IGB structure)

      Unfactors all or part of a hierarchy by replicating internal groups and attributes to create a single path from the starting node to each leaf node. This expansion of a graph is commonly used to prepare for subsequent optimizations.
      Options for filtering (groups, attribute sets, transforms).

igCollapseGeometry: Gather geometries (geometry)

      For each render state present at a geometry, moves all geometries that inherit that state to a single new child of the starting node. In simpler words, combines igGeometry nodes into one. Only igGeometryAttr2 is supported. The resulting empty igGeometry nodes can be removed with "Collapse hierarchy (igGeometry)".
      Options for minimum specs, maximum specs, and group node handling.

igGatherTransforms: Gather transforms (transform)

      Gathers similar transforms with the same transform sequences (matrix and animation) and merges the children under a single transform (ie. combines igTransforms). The old transform node is emptied but not removed.
      Option for node filtering.

igGenerateGlobalColor: Generate Global Color (light and shade)

      Generates igGlobalColorStateAttr for igGeometry. Removes vertex colors to enable vertex shading.

igUseMipmap: Generate Mipmaps (textures)

      Generates mipmap levels for textures.
      Options for texture scaling, min./mag. filtering, smallest texture size, texture filtering (auto-generate mipmap flag from the modeller), and exclude/include file lists (only filename with extension on each line).

igGeneratePerVertexColors: Generates Per Vertex Color (light and shade)

      Generates per vertex color for igGeometryAttr and igGeometryAttr2 based on the global color.

igGenerateTangentBinormals: Generates Tangent Binormals (geometry, textures)

      Generates tangents and binormals for igGeometryAttr. The geometry needs to have position, normals and texture coordinates. (Usually)
      Options for smoothing, normal map, and node name

igHideActorSkinGraphs: Hide actor skin graphs (geometry, textures)

      Hides the previously exposed skin graphs attached below igActors in the scene. Ie. undo igExposeActorSkinGraphs.

igInstanceGeometriesByName: Instance geometries by name (geometry)

      Geometries with the same name are instanced to only one geometry. Ie. combines geometries with the same name.

igInstanceScene: Instance scene

      This creates N instances of the current scene. This is largely intended for benchmarking uses. Note: To have "shade textures" behave properly on Actors, "expose actor skin graphs" before running this optimization, and "hide actor skin graphs" afterwards.
      Options for copies/instances, instancing (share), number of instances, scaling, shape, shader, color, and bounds.

igInternalizeShader: Internalize Shader (light and shade)

      Embed the shader definition in the IGB file instead of using the implementation in the shaders directory. The shader is saved as a script.

igLimitActorBlendPalettes: Limit Actor Matrix Palettes (geometry)

      This optimization breaks up geometries to limit the number of matrices per mesh for the skinning. (Should improve calculation performance for some modes, eg. vertex shaders.) It's recommended to run "Strip triangles" before, and "Collapse igBlendMatrixSelect" afterwards.
      Option for matrix count.

igMapTextureImages: Map texture images (textures)

      Creates an igMappedObjectInfo with a list of all igTextureAttrs mapped to the names of the images they hold. Image-less igTextureAttrs are ignored. The igMappedObjectInfo also maps all igSceneInfos in the file to their names so they can be accessed directly from the igMappedObjectInfo.
      Option for name of the igMappedObjectInfo node.

igMergeIGB: Merge IGBs

      Insert a specified IGB into the current scene. By default, this inserts a new group root node, and appends the specified file to the right of the original scene under the new node. If "Append to existing root" is true, then the specified file will be added under the current root node.
      Options for the filename, including extension (supports path); and hierarchy.

igDebugMessageBox: Message Box (Debug)

      Interrupts to display a message box with a pre-defined message.
      Option for message text.

igNameInfos: Name infos (infos)

      Autonames infos in an IGBfile so that they are unique. The name is in the form <CLASS_META>_<FILENAME>_<COUNTER>.
      Options for info type search string, and match method.

igNormalizeNormals: Normalize normals (geometry)

      This optimization goes through all geometry in the scene graph and makes all vertex normals of length 1.0. Only supports igGeometryAttr2.

igNormalizeTextureCoord: Normalize texture coordinates (textures)

      Removes large integer repeat counts in the texture mapping coordinates of geometry and limit the maximum texture extent across a single polygon to avoid the PS2 hardware limitations.
      Options for enabling/disabling UV coordinates normalization; splitting triangles (if the width multiplied by the UV repeat exceeds the "Split Threshold", then triangles are split, if enabled to max. N subdivisions); image filtering.


By Vicarious Visions, ak2yny
Logo by Outsider


igMacroOpt: Optimization Macro (file)

      Runs an optimization script from a file.
      Option for script file name.

igOptimizeActorAnimations: Optimize actor animations (animation)

      Attempts to share data among animations and remove igAnimationTracks which do not map onto bones in the skeleton(s). Tolerance parameters can be used to specify how similar two keyframe components need to be before being considered equivalent.
      Options for Translation tolerance (the maximum difference in translations along an axis); Quaternion tolerance (the cosine of the maximum variation in orientation); Scale tolerance; Time tolerance (the maximum difference between the times); Share animation data (if true, shares data among animations in the database if possible); Remove unused tracks.

igOptimizeActorSkeletons: Optimize actor skeletons (animation)

      Converts unused joints to bones and removes unused bones.
      Options for converting unused joints, and removing unused bones separately.

igOptimizeActorKeyframes: Optimize igActor keyframes (animation)

      Removes redundant keyframes from the animations in an igAnimationDatabase. Tolerances that determine if two keyframes are considered 'equal' can be user-specified. If the animation is visibly degraded by this process, reduce the tolerance until acceptable results are achieved.
      Options for Maximum translation (along one axis); Maximum angle change (the cosine of the maximum variation in orientation/quaternion rotation); scaling; base keyframe time.

igOptimizeActorSkinsInScenes: Optimize igActor skins in scenes

      Runs optimization on igSkin only.
      Options for filename (of optimization script to execute), and skin filtering (local).

igOptimizeMorphInstance2: Optimize igMorphInstance2 (geometry)

      Optimizes igMorphInstance2 into platform specific data sets.
      Options for platform (vertex format - Software [ 0 ] = no change), normal vectors, and normalizing normals (for Software, ie. DX9 and OpenGL) incl. threshold.

igPackageImagesExternally: Package (copy) images externally (textures)

      Creates an IGB with an igImageInfo in it, containing each igImage.
      Options for name (of info), and filename.

igPromoteAllAttrs: Promote all attributes (IGB structure)

      Factors all shared attributes and regroups nodes beneath each unique attribute set to minimize state changes required to render a hierarchy (ie. may improve speed). This reduces redundant attribute application at the expense of spatial coherency.
      Option for filtering.

igPromoteAttrs: Promote attributes (IGB structure)

      Same as igPromoteAllAttrs, but only on a specific attribute type. May be further improved if run multiple times.
      Options for attribute type, and unit id filtering.

igRavenSetupMUAMaterial: Raven: Setup MUA Material (textures)

      Adds additional texture maps to igGeometry that MUA uses. (Plugin)
      Options for files for each texture map (must be full path and filename, incl. extension - if in same folder as IGB may be filename and extension only), reflectance (only if no reflection mask is specified, and reflection maps are specified), tangent binormals, and texture filtering (diffuse name - must be specified and must match diffuse filename without extension exactly).

igRebindActors: Rebind igActors (animation)

      Restores the integrity of actors after modifications to the animation databases they depend upon (eg igReflectAnimations).
      Option to apply reflected animations.

igReduceBlendWeights: Reduce blend weights (geometry)

      Sorts and reduces the number of blend weights use in vertex arrays in the specified scene graph. Note that the reduction depends on the blend weights being sorted. Specifying blend weight count of -1 will cause the optimization to skip the reduction step, allowing this to be used only to sort blend weights. Weights whose contribution is less than the weight threshold may be removed if the result will be faster runtime processing of the data.
      Options for sorting method (separate skeleton selection by name for SORT_BY_DISTANCE_TO_BONE), min. and max. weight count (how many bones per vertex), weight threshold (reduceByThreshold enables weight removing for vertices with more than max. weight count), error notification, and arrays.

igReductionMesh: Reduction Mesh (geometry)

      Reduces polygons in geometries. It's recommended to use this on geometries that require little details.
      Options for reduction amount (in percent), method (position, incl. amount), edge preserving, debugging, and geometry filtering (supports regex).

igReflectAnimations: Reflect animations (animation)

      Attempts to reflect animations, such that any motion on the right hand side is played on the left, and vice versa. By default the strings 'l_' 'r_' and 'left' 'right' are used to identify and match bones. The user has the ability to add their own reference string, and also specify the plane of reflection: YZ, XZ, XY. Note: igRebindActors is required after this operation to see the results.
      Options for identifiers ('left', 'right' and 'ignore'), and mirror plane.

igRemoveActorAnimationState: Remove Actor animation state (animation)

      Removes igAnimationState in igAimationCombiner. Insight Viewer must be closed for this optimization.
      Option for reset only (if no, deletes all igAnimationState, which can reduce IGB file size; if yes does not change anything in the animation result).

igRemoveBonesFromActor: Remove Bones from igActor (animation, geometry)

      Removes bones from igActor skeletons and skins. Specify bones to remove (option) with a comma delimited list of bone names. Requires an igAnimationDatabase to find actors, skeletons, and skins.

igRemoveInfo: Remove Infos (infos)

      Removes all infos in a file based on their class name.
      Options for class (list should be specified with commas to separate the class names) and object filtering, and switch for exclude/include.

igRemoveAllAttrs: Remove all attributes (IGB structure)

      Removes all unspecified attribute types and its subclasses from igAttributeLists in the hierarchy. This is useful to remove lighting and texturing attributes when these modes will not be enabled.
      Option for attribute filtering.

igRemoveAllDefaultAttrs: Remove all default attrs (IGB structure)

      Removes all attributes that have their default creation values. Note that the default value for an attribute is not the same as its default value on the visual context. Use with caution.
      Option for attribute filtering.

igRemoveAnimationTrackChannel: Remove animation track channel (animation)

      Removes a driven channel from all igAnimation matching the specified names for all igAnimationDatabase (only). If animation name or animation track name are not specified, than all animations or tracks, respectively, will be processed.
      Options for channel (move/translate, rotate, scale), and name filtering.

igRemoveAttrs: Remove attributes (IGB structure)

      Removes all instances of the specified attribute type and its subclasses from igAttributeLists in the hierarchy.
      Option for attribute filtering.

igRemoveCenterOfRotation: Remove center of rotation (animation)

      Removes any Center of Rotation vectors from transform sequences by inserting bones into skeletons and tracks into animations. This may be needed because actors do not support Center of Rotation, which means objects may not render correctly. NOTE: igRebindActors must be executed immediately after running this optimization.

igRemoveGeometryAttr: Remove geometry attributes (geometry)

      Removes all geometry attributes of a specific primitive type. Only supports igGeometryAttr2.
      Option for primitive type.

igRemoveNames: Remove names

      Removes names from named objects.
      Useful for data reduction (eg. consoles). Be careful: Some objects must be named.

igRemoveNodeFlag: Remove node flag (IGB structure)

      Removes the flags on nodes. This is primarily to be used with the 'Spatial partition' optimization.
      Options for node filtering (exclude), removing the flag for nodes with only a single child, flag filtering, and choice for removing node or flag only.

igRemoveTextureImages: Remove texture images (textures)

      Removes igImages from all igTextureAttrs containing igImages, and changes the source of the igTextureAttr to IG_GFX_TEXTURE_SOURCE_BUFFER. WARNING: This will basically make all igImage-containing igTextureAttrs identical.

igRemoveVertexComponent: Remove vertex component (geometry)

      Removes selected components from geometries in the hierarchy.
      Options for normals, colors, coordinates, weights, tangents & bi-normals, and type filtering.

igRepairHierarchy: Repair hierarchy (IGB structure)

      Repairs missing relationships between parents and children by adding each node to the parent list of its children and the child list of its parents.
      Options for disabling repair, and separate parent list toggle.

igReplaceByGroup: Replace node by igGroup (IGB structure)

      Replaces each occurrence of the specified node type or a subclass of that type with an igGroup.
      Options for type of node, substring (filtering the types), and search settings.

igResizeImage: Resize images (textures)

      Resizes images in a hierarchy by a scale factor or to a maximum size using a chosen image filter. Use factor for scale factors (eg. 2 for double size), and max. values for absolute image pixel size. This is not suited for considerable upscaling (or downscaling), because of quality loss.
      Options for width and height (separate), mipmaps, power of two (only accepting dimensions with a height/width ratio of 1:1, 1:2, or 2:1), and filter (filter 4, lanczos3 is recommended - noteworthy other filters include gaussian [blur] and triangle [good lines]).

igResortTransparency: Resort transparency (textures)

      In some cases the child order might be changed. If the transparency is required to be baked into the scene graph this optimization should be used to make sure that transparent subtrees appear after opaque subtrees. It's not perfect and mainly suited for debugging.

igPhotoshopScript: Run photoshop script (textures)

      Executes a Photoshop script on each image.
      Options for name, window display, and image filtering.

igScaleActors: Scale igActors (geometry)

      Applies a uniform Scale to the skeleton, mesh, and animation data in an igAnimationDatabase. All dependent actor databases must be rebound using the separate optimization "Rebind igActors" after this operation.
      Option for scale factor.

igScalePs2Texture: Scale ps2 texture (textures)

      When 4, or 8 bit textures are less than 128 wide they should be scaled to a larger size on PS2 hardware or they will be internally scaled. This optimizations searches for such texture bind attributes in attr sets and performs the scale or reflection when possible.
      Option for rotating (if height is 128 or more, the issue is solved by rotation).

igScalePerVertexColors: Scale vertex colors (geometry)

      Applies a scale factor to the vertex color in geometry. Only igGeometryAttr2 supported.
      Option for scale factor.

igSeperateTransformChannels: Seperate transform seq channels (transform)

      Analyzes a transform sequence and separates channels that are unused, it promotes static translations above, and scale and rotation below the transform node.
      Options for node filtering, and separate enabling/disabling of each transform channel.

igSetStaticGeometry: Set static geometries (geometry)

      Replaces each occurrence of igGeometry with the non-skinned igStaticGeometry. Can improve performance.

igNameUnique: Set unique names

      Generates unique names for nodes by appending _<number> to non-unique names.

igSetVertexStreamAccessMode: Set vertex stream access mode (geometry)

      Changes the access mode for igVertexStream (in igVertexArray2).
      Option for access mode (method is platform dependent).

igShareAttrs: Share attributes (IGB structure)

      Replaces equivalent attributes in a hierarchy with references to a single shared instance to optimize state tracking and memory use.
      Option for attribute type filtering.

igSpatialPartition: Spatial partition (IGB structure)

      Regroups a hierarchy based on spatial extent (divides) to accelerate frustum-based rendering and intersection traversals. Please make notes that this opt. needs to be run from SpatialPartition.ini, as by itself it produces dynamic nodes and invalid bounding boxes. Only igGeometryAttr2 supported. (Useless if the IGB is already efficient)
      Options for tree type, hierarchy limiting, and geometry splitting.

igSpecializeTransforms: Specialize transforms (transform)

      Replaces each occurrence of igTransform with igModelViewTransform, igTextureTransform, or igVertexBlendTransform depending on the transform target. Can improve traversal time in scenes with many transforms.

igSplitGeometries: Split large geometries (geometry)

      Splits geometries larger than 64K vertices into geometries smaller than 64K vertices. Many platforms cannot draw geometries with more than 64K vertices. Typically, this optimization should be used after igStripTriangles, because igStripTriangles gathers geometries together and can create extra vertices.

igStripLines: Strip Lines (geometry)

      Compacts geometries by producing one or more line strip primitives (IG_GFX_DRAW_LINE_STRIP). Only igGeometryAttr2 supported. For wireframe objects.
      Option for indexing.

igStripTriangles: Strip triangles (geometry)

      Compacts geometries by producing one or more triangle strip primitives. When potential strips have lengths below the specified threshold, independent triangles are produced. Should be used after "Spatial partition". Only igGeometryAttr2 supported.
      Options for triangle numbers, stitching, indexing, and igGeometryAttr2 merging.

igMSStripTriangles: Strip triangles (Microsoft) (geometry)

      Same as igStripTriangles, but uses the Microsoft Xbox stripper, currently only stitching is supported.

igNVStripTriangles: Strip triangles (Nvidia) (geometry)

      Same as igStripTriangles, but uses the Nvidia stripper.

igTransformAlpha: Transform alpha channel (textures)

      Scales the alpha value of the texture. The texture must be 32bit.
      Options for offset and scale (new alpha = offset + old alpha / scale).

igUntileTextureCoordinates: Untile texture coordinates (textures)

      Removes the repeat on U by tesselating geometry. It will generate approximately 2 * repeat + 2 triangles per triangle that has U tiling.  This is useful in order to macrotexture geometries. It will probably not work correctly with skinned geometry.
      Option for rounding.

      Following optimizations are hidden, and may be leftover:

igOptTraverseGraph (options for node type filtering)
igConvertTransformsToCompressedSequencesQS (reduce memory)

      Following optimizations are hidden, be careful when using (PC Only library):

igLimitActorBlendPalettes2: Limit Actor Matrix Palettes 2

      This optimization breaks up geometries to limit the number of matrices per mesh for the skinning.

igQuantizeImages4Bit: Quantize Images (4-bit)

      This optimization converts igImages from RGBA_8888 to 4-bit palettized. It is primarily intended for the PlaystationPortable. Performance is very bad on large textures, but the visual quality is generally better than igConvertImages.
      Options for alpha handling and iterations.


By Vicarious Visions, ak2yny
Logo by Outsider

Nodes That Can Be Created Manually


      An Actor is a model, which can act, as in actor in the theatrical world. Alchemy uses this node to define if a model can be "moved". These models are geometrys, which then must be children of Actors.


      Use this to make a parent for attributes and nodes. This is to guarantee that the attributes are only used on the child nodes.


      The 3D child nodes will be displayed as billboard, from a pre-defined eyepoint, with a pre-defined orientation from the eypoint. Define that by "Editing object fields".


      Same as igAttrSet, for nodes that contain igVertexBlendMatrixListAttr attributes. For animated skins.


      This is only an Alchemy internal node for the Insight Viewer to find the camera location inside the IGB file.


      Adds depth of field shader information to igCamera.


      Creates a view-dependant environment mapping effect. All child geometry nodes will be rendered with an environment map. Textures must be defined obviously.
      We can add platform specific settings to the shader:
      igDx8EnvironmentMapShader (Direct X)
      igOglEnvironmentMapShader (Open GL)


      Child of, and same as igAttrSet, but only igDrawableAttr and igGeometryAttr2 (and other drawing-related) attributes can be set. Cannot have child nodes. It's possible to set non-drawing-related attributes, or to create a child node, but the results are undocumented (may crash).


      Can have multiple child nodes. Has no functions, other than being a parent. An igGroup with only one child is useless.


      This is for a skeleton joint and adjusts transform nodes (position and movement) to take care of the mesh deformation, which is affected by multiple bones.


      The root node of a component IGB, which is a file that includes nodes that correspond to visual content (eg. model IGB files).


      Same as igAttrSet, for nodes that contain only igLightAttr attributes.


      Same as igAttrSet, for nodes that contain only igLightStateAttr attributes.


      Level-of-Detail Node which is defined by its children, starting with the highest resolution. The distance from the viewpoint to the defined center (an object field) defines what child (numbered) of this node is drawn.


      Replaces the current model-view matrix (mvm)/matrix (from parent, grandparent, etc.) with the matrix from a bone, defined by an index, by generating an attribute for the current mvm. Requires a skinned geometry, but only affects unskinned geometry children.


      Same as igTransform, but only affects model-view matrices (mvm). A model-view matrix is a type of matrix that is used to define model coordinates. The matrix type is merely to specify matrices for faster and more accurate processing.


      Same as igTransformRecorder, but only affects model-view matrices (mvm).


      Same as igBlendTransformRecorder, but only affects model-view matrices (mvm).


      An instance of an igMorphBase object with additional settings. IgMorphBase cannot be created in the schematic view, but must exist. These objects morph a geometry, and igMorphInstance must be a child of an igGeometry node. Normally, this node is created by the exporter.


      Same as igMorphInstance, without the need of an igMorphBase.


      Same as igAttrSet, but the contained attributes are overridden instead of defined.


      Casts hard, translucent shadows from its children. Requires lights (light list), and a model view matrix (mvm). Has object fields for plane (where the shadow is cast on), color, transparency, and accepts attributes.


      Casts soft shadows from a list of caster children on receiver children. Requires lights. Works with textures. Has texture and many shadow properties object fields.


      Similar to igSwitch, this node, which is otherwise an igGroup, can be turned on and off through commands. The children are active (show) by default. Apparently, it is also possible to replace a segment with another segment, but I doubt that the games are able to make use of this. An igSegment must have an unique name to be identified with, so that the command finds the segment as expected.


      A shader is used to create lit and shadowed areas (or other effects) on a model.
      Used to create shaders in Alchemy through shader children.


      Old version, which is used in a similar way as igSimpleShader.


      Results from exporting Ether Shader. May not work in games. Use the optimization "Convert to igSimpleShader" to fix that (data may be lost in the process).


      An igShader2 child, which needs attributes to process.


      Same as igAttrSet, but has an extra object field to enable multiple igShaderParametersAttr.


      Same as igGeometry, but doesn't support skinned geometry (ie. weighted geometry). Slightly faster than igGeometry on non-skinned geometry.


      A node and its children are referred to as a scene graph (the children can are called sub-graphs). So, this means that this node and its children are static and can't experience any change. If defined with this node, Alchemy can cache this node and its children for faster processing.


      Convert non-static transform nodes to static nodes for use with igStaticGraph.


      This node and its children can be turned on and off, using commands. The default is off (don't show). All children or a specific child node (using index) can be turned off with the command.


      Same as igTransform, but only affects texture matrices. A texture matrix is a type of matrix that is used to define texture coordinates. The matrix type is merely to specify matrices for faster and more accurate processing.


      Same as igTransformRecorder, but only affects texture matrices.


      Similar to igTransformSequence, it plays nodes in a sequence (defined by play mode), continuing with the next time switch, after the previous is completed, as defined by the time.


      Automatically converted to igTimeTransform1_5.


      Modifies times in child nodes by applying attributes on them, and as defined in the object fields of the node.


      Defines position, rotation and size (coordinates) of the child nodes with a matrix. Supports keyframe animation through igTransformSource with igTransformSequence and igTransformSequence1_5 (ie. defining a sequence of matrices).


      Takes a snapshot of the current transform matrix. Only useful if the igTransform (or chain of igTransforms) is animated. The snapshotting makes more sense when only applied to a part of all the animated geometry.


      Same as igTransformRecorder, but saves the matrix into an attribute.


      Stores information of the IGB file. Can have two child nodes:
      igHashedUserInfo: sorted list (the list is accessed using binary search)
      igSimpleUserInfo: simple list (the list is accessed using linearly search)


      Specify vector values (X Y Z W) in the object fields of this node, to modify the UV coordinates in all child nodes with textures. It flows, ie. adds the specified amount every 1 millisecond.


      Same as igTransform, but only affects vertex blend matrices. A vertex blend matrix is a type of matrix for vertex blending, ie. painted vertices. The matrix type is merely to specify matrices for faster and more accurate processing.

      Following nodes have no documentation:


Nodes That Can't Be Created Manually

      Following nodes are leftover, for IGB compatibility.


      Following nodes may be leftover, they can't be created manually:



By Vicarious Visions, ak2yny
Logo by Outsider

Attributes That Can Be Created Manually

      Attributes only apply to nodes with the same parent. State attributes usually are requred to turn the related properties on.


      Similar to igBlendFunctionAttr, but doesn't blend, ie. makes hard edges, depending on the object fields and amount of alpha in each pixel. Alpha has better compatibility with old versions of IGB files and games.


      Same as igBlendStateAttr, but for igAlphaFunctionAttr.

ASP Texture Attributes:

      ASP (Advanced Shader Pipeline) is to convert 2D shaders (and other old gen shaders) to more advanced shaders (pixel shaders). Only ASPDX9 (Windows DirectX9), Xbox360, and PS3 are compatible with ASP (must support shader model 3.0 and up). Some parameters are ignored. The following attributes are for ASP only:
igASPClutTextureBindAttr binds ASP palette textures
igASPEnvMapAttr parameters for environment map
igASPExpandMeshAttr parameters for normal map direction
igASPGlossMapAttr parameters for gloss/emission map
igASPLookupTextureBindAttr binds ASP lookup textures
igASPMaterialAttr define all texture maps
igASPNormalMapConfigAttr parameters for normal map
igASPParallaxMapAttr parameters for parallax map
igASPReceiveShadowStateAttr toggle shadow receiving on and off
igASPRimSpecularAttr parameters for (rim) specular map
igASPSwayAttr parameters sway map (grass shake)
igASPTextureCoordSourceAttr reference coordinates for ASP textures
igASPTextureFunctionAttr Same as igBlendFunctionAttr for ASP textures.
igASPWaterAttr parameters for normal maps for waves

PS2 (& PSP) Visual Attributes:

       Note: The destination is where parameters are before they're output (ie. in the destination buffer), as opposed to the source parameters.
igBlendingControlStateAttr similar to igBlendStateAttr (PABE)
igBlendingCorrectionStateAttr similar to igBlendStateAttr (FBA)
igColorScalerStateAttr turns color scaling on and off
igDestinationAlphaFunctionAttr sets the values for destination alpha testing
igDestinationAlphaStateAttr turns destination alpha testing on and off
igMacroTextureRegionAttr selects a region of a texture (eg. to repeat). Wrap values from igTextureAttr will be ignored. Coordinates are in texture pixels (0 - 521).
igTextureAddressModeAttr turns igMacroTextureRegionAttr on and off, and defines the addressing mode
igMatrixOptStateAttr turns matrix optimizations on and off
igMipMapAttr defines mipmap parameters, for PS2 and PSP only
igMultiPassStateAttr turns fast multi-pass rendering on and off
igTexGenMatrixAttr defines a texture matrix. For old Alchemy engines.


      Defines how much to blend to alpha, if igBlendStateAttr is enabled.


      Turns blend on and off, effectively enabling alpha (transparency) in textures, as it is off without this attribute.


      Stores blend matrices, which can be applied with commands. Please write me, if you know what a blend matrix is.


      Use this to index the igBlendMatricesAttr, so that commands can be made on one or multiple indices.


      Clears the system rendering buffer, according to the specified object fields. Cannot be a child of igAttrSet.


      Turns clipping on and off.


      Defines a color for when vertex colors are not specified. Settings (inlcuding game settings) change the priority of the color attribute, vertex color, and material properties.


      Creates a color component (red, green, blue, alpha) mask. Adjust components of nodes with the same parent, according to the object fields.


      Turns face culling on and off. Supports front- and back-face culling. Performance is improved with culling on.


      Lifts geometry off of a plane. This is commonly used to improve shadow casting for these geometries.


      Testing the depth (z-buffer) according to the settings in the object field.


      Turns depth testing on and off.


      Turns depth (z-) buffer on and off. Use this to enable better working alpha textures (without it, igBlendStateAttr blends too much with the background, making lights and shadows distort the colours).


      Replaces alpha values in the frame buffer (ie. real-time alpha modification) with values set in the object fields. For Gamecube only.


      A list of attributes that are parsed and applied, according to the list. The goal is to reduce attribute count for identical attributes.


      Turns dithering on and off.


      By default the geometry creates the drawable, this attribute modifies that. All other geometry attributes must be based on this attribute. Usually fails to be created manually.


      Controls the fog (appearance and behaviour). Fog itself is in the API.


      Turns igFogAttr on and off.


      Automatically creates igGeometryAttr1_5. Did not support vertex array.


      Controls rendering options, includind user defined vertex data.


      Same as igGeometryAttr1_5, advanced, less requirements.


      Turns vertex attributes on and off. Doesn't support Gamecube and Direct X.


      Disables vertex colors, which enables color blending/painting on the geometry. This is a Raven Software optimization. Plugin by nikita488.


      Defines light parameters. Must be added to igLightSet (doesn't work in igAttrSet).


      Turns lighting on and off during rendering. May have the same effect as igLightStateAttr, but instead of turning off the source, it turns off the effect.


      Turns igLightAttr on and off. Must be added to igLightStateSet (doesn't work in igAttrSet).


      Defines the line width for line drawing, for Xbox only.


      Same as igMacroTextureRegionAttr, but supports selecting parts of multiple textures (unknown max size, and unit).


      Defines material information for rendering lighting and surface color.


      Filters the material component (texture map, eg. normal) for vertex painting/coloring.


      Undocumented. Likely turns specular mapping on and off (similar to advanced lighting).


      Defines mipmap parameters (max anisotropic, max mipmap level, lod), for DX9, Xbox360, and PS3 only.


      Modifies all mvm for the nodes it affects.


      Modifies geometry with vector morphing. Up to three geometries in ASP, up to 15 on others. Therefore platform specific.


      Turns multisampling on and off, for a particular set of geometry. Has no effect on a single-sampled buffer.


      Turns normalizaton of normals on and off. This is often required for lighting, reflection mapping and other calculations to work correctly.


      A patch is a defined set of vertices. This attribute works with UV mapping, and bezier or b-spline curves. Not well documented, please tell us if you know more about this.


      Tessellation is the division of a patch (set of vertices), used for shading purposes. This attribute works by defining UV division values. Please tell us if you know more about this.


      Defines the pipeline mode for use with a specific platform. Turns igVertexShaderAttr on (or off).


      Defines the pixel pipeline mode for use with a specific platform. Effectively turns pixel shader on and off.


      Defines the pixel shader and if it's on or off. Requires igPixelShaderBindAttr.


      Binds igPixelShaderAttr to the node, but igPixelPipelineModeAttr still needs to be defined for it to work.


      Defines the polygon drawing mode (fill - default, lines, points).


      Modifies a projection matrix, to change the perspective.


      Defines the render destination type in the buffer/memory (texture, single or double visual).


      Turns igRenderDestinationAttr on and off. This attribute can't be created normally: there is a workaround described in the documentation.


      Copy textures from or to a render destination in the buffer/memory.


      Defines the color of ambient lights. Is added in the calculation with other lighting properties.


      Defines parameters for scissoring.


      Defines the scissor window (viewport or user defined).


      Defines the shading mode (facet/flat, smooth).


      Defines various shader parameters.


      Defines sprite parameters.


      Defines how to enable or disable drawing to individual pixels by defining operations that use the stencil buffer.


      Turns igStencilFunctionAttr on and off.


      Turns tessellation on and off.


      Contains various texture data (including name and mipmap info), and defines options for the texture (eg. filter, repeat/wrap modes). Also Requires igTextureBindAttr.


      Binds one or multiple igTextureAttr to a texture.


      Same as igTextureBindAttr, but can only bind one igTextureAttr.


      Turns igTextureBindAttr (& 1_5) on and off.


      Holds information, if the texture coordinations are user defined or one of many automatically generated sources.


      Defines the cube faces and textures for cube-maps.


      Defines the filters for the texture. Same can be done with igTextureAttr.


      Defines extended blend/alpha parameters for the texture.


      Defines a matrix to modify the texture coordinates.


      Turns igTextureMatrixAttr on and off.


      Unloads (removes) a texture.


      Defines the texture wrapping (clamp, repeat). Same can be done with igTextureAttr.


      Defines a time parameter, which some nodes require.


      A matrix that is responsible for modifying geometry according to animations, through a skeleton, a process called vertex blending aka skin-and-bones.


      A list of pointers to blending matrices.


      Turns igVertexBlendMatrixAttr on and off.


      Turns igVertexShaderAttr on and off.


      Defines vertex shader parameters. Requires igVertexShaderBindAttr and igPipelineModeAttr.


      Binds igVertexShaderAttr. Please inform us if you know where these attributes need to be placed (bound to).


      Hints a view matrix. Please inform us if you know what hinting a matrix means. This attribute lets us define matrix values.


      Defines a viewport/window (aka sub-region) in the render destination (buffer before the image is shown on the screen).


      Parent attribute for most other attributes. Most are visual attributes.


      Filters operations by type, and holds the volume for a geometry or group of attributes.

      Following attributes have no documentation:


      Following attributes are leftover:


      Use igMacroTextureRegionAttr or igTextureAddressModeAttr instead.

Attributes That Can't Be Created Manually

      Following attributes may be leftover, they can't be created manually:


February 10, 2022, 06:47AM #10 Last Edit: December 22, 2023, 06:40AM by ak2yny


By Vicarious Visions, ak2yny, Nicaras
Logo by Outsider

Transformation Matrix

      There are mainly two types of matrices: Single-precision and double-precision. But don't ask me what's the difference.

      A transform matrix consists of four rows of vecors of a certain type. They are X Y Z and a fourth dimension, usually with a valid value between 0 and 1 (commonly referred to as W or T vector). Each row changes the geometry in a different way. The top three rows set various dimensions. The fourth row is the translation, or position.

      The top-left 3x3 values are used for common three dimensional matrix transformations. This is very hard to understand, check out the tutorial above, called Use Finalizer to Scale, Rotate, and/or Move (incl. video).

      Research results:

  • Scale: scale + shear values
  • Rotate: scale + shear values (2x2 for each dimension)
  • Move: translation values
  • Shear: shear values
  • Flip:

    • Back/front: Change +/- in the first column (sx, sxy, sxz and tx values)
    • Left/right: Change +/- in the second column (syx, sy, syz and ty values)
    • Vertical: Change +/- in the third column (szx, szy, sz and tz values)

      Scale values:
     sx  0   0   0
     0   sy  0   0
     0   0   sz  0
     0   0   0   1

      Translation values:
     1   0   0   0
     0   1   0   0
     0   0   1   0
     tx  ty  tz  1

      Shear values:
     1   syx szx 0
     sxy 1   szy 0
     sxz syz 1   0
     0   0   0   1

Quote from: Alchemy-documentation on May 29, 2010, 08:42AM
The shear values have the effect of moving a point in one dimension as another changes. For instance, shearXY shears the x coordinate as the y coordinate changes.

Alchemy 5 Image Formats

      Image formats are defined by channels and bit depth. They are further sepparated by platform, especially Gamecube/Wii, and Direct X (PC, DDS).


      Intensity aka grayscale image with 8 bits (1 channel) - no transparency supported


      Alpha channel only, with 8 bits


      Intensity aka grayscale image with alpha channel and 4 bits per channel


      Intensity aka grayscale image with alpha channel and 8 bits per channel


      RGB (Red Green Blue channels) 8 bit image with 3 and 2 bits per channel - no transparency supported


      RGB (Red Green Blue channels) 24 bit image with 8 bits per channel - no transparency supported


      RGBA (Red Green Blue Alpha channels) 8 bit image with 2 bits per channel - PNG


      RGBA (Red Green Blue Alpha channels) 16 bit image with 4 bits per channel - PNG


      RGBA (Red Green Blue Alpha channels) 32 bit image with 8 bits per channel - PNG


      RGB (Red Green Blue channels) 16 bit image with 5 and 6 bits per channel - no transparency supported


      RGBA (Red Green Blue Alpha channels) 16 bit image with 5 and 1 bits per channel - PNG


      Indexed color image with 8 bits - limited transparency


      Indexed color image with 4 bits - limited transparency


      DirectX texture 1 (Red Green Blue Alpha channels) for textured 3d objects - DDS - transparency not fully supported


      DirectX texture 2 (Red Green Blue Alpha channels) for textured 3d objects - DDS


      DirectX texture 3 (Red Green Blue Alpha channels) for textured 3d objects with best alpha channel support - DDS


      DirectX texture 1 (Red Green Blue Alpha channels) for textured 3d objects on Gamecube and Wii consoles - DDS - transparency not fully supported


      RGBA (Red Green Blue Alpha channels) 16 bit image with 5 and 3 bits per channel for Gamecube and Wii consoles - PNG - please let us know if you know more


      RGB (Red Green Blue channels) 16 bit image with 5 and 6 bits per channel for Gamecube and Wii consoles - no transparency supported


      Intensity aka grayscale image with 8 bits (1 channel) for Gamecube and Wii consoles - no transparency supported


      Intensity aka grayscale image with alpha channel and 8 bits per channel for Gamecube and Wii consoles


      Intensity aka grayscale image with alpha channel and 4 bits per channel for Gamecube and Wii consoles


      Unknown - please let us know if you know more


      Indexed color image with 8 bits for PSP - limited transparency


      Indexed color image with 4 bits for PSP - limited transparency

I have a problem. I have installed Microsoft Visual C 2008 and Alchemy 5, copied and pasted the content of folder 2 to my Alchemy 5 installation directory, and rebooted my computer. But when I tried to click on image2igb-ls to create my own  :magneto: Magneto Loading Screen, image2igb-ls immediately closed out. What should I do?

Quote from: spidermatt on August 10, 2023, 10:13AM
I have a problem. I have installed Microsoft Visual C 2008 and Alchemy 5, copied and pasted the content of folder 2 to my Alchemy 5 installation directory, and rebooted my computer. But when I tried to click on image2igb-ls to create my own  :magneto: Magneto Loading Screen, image2igb-ls immediately closed out. What should I do?

Do you also have the 2010 Visual C++ distributable? That's also a requirement

I have two Visual C++  2010 redistributables. One is x64 and another is x86. It still won't work for me.

I would suggest coming to our Discord server. Much of our community is active there, and you'll get help in real time. It'll be faster and easier. The site is mainly used for more permanent stuff like releases and tutorials, so people don't check it often.