DI-Guy SDK Documentation  13.5
DI-Guy Changes and Version History

Table of Contents

DI-Guy Data History

For an overview of data changes please see release notes:

DI-Guy Version 13.5

DI-Guy 13.5

Build Changes : New directory structure:

  • The directory structure for DI-Guy applications has been updated to be more in line with other MAK products.
  • Bin directories have been unified into a single bin64 directory. Path changes to run applications no longer needed.
  • Applications run from the bin directory will correctly locate resources without need for environment variables.
  • To run applications from outside the bin directory, DIGUY environment variable can be set so resources can be located.
  • Installer no longer sets DIGUY variable by default, option to set variable can be enabled during the install.
  • Runtime objects no longer indicate build type using md/mdd/mdn suffix. Release uses base name, and debug uses 'd' suffix.
  • Due to some internal changes programming examples no longer use visual studio property sheets. But they are still available in programming_examples/vs_property_sheets and they are used in programming_examples/diguy_ogl/vs_prop_sheets.

New Equipment System:

Allows character to mix and match additional shapes at run-time without defining new appearances. This allows more helmet and head customization, as well as backpacks and other accessories. The equipment list is based around the current character skeleton (actor), the end user is currently responsible to not wind up with combinations that aren't visually perfect.

  • Character Viewer now includes UI demoing equipment
  • DI-Guy Digest now outputs data needed to support equipment.

Equipment API:

Query API:

New Character Customization Tools:

DI-Guy now supports configurable uniform arm, rank and name label patches. Currently there's only one appearance that supports these but we expect to roll out more in an upcoming release. Uniform patches require subclassing diguyGraphicsTextureArray, Name patches require implementing text rendering to a texture in diguyGraphicsShape. A sample implementation is provided. The Following api calls were added:

Query API:

Graphics API changes:

diguyGraphicsShape added:

Performance Improvements:

  • Architectural redesign of LOD calculation and shadow pass calculation lod and culling calculations are done in multiple threads and now reused for shadow pass and main pass. This avoids reculling the character list. Added function to expand character radius ( diguyScenario::set_cull_bounds_scale_factor() ). Typically a 2x increase is enough to capture anyone that's outside of the main view frustum. Characters that aren't instanced are inserted into a much smaller list of characters to draw one at a time. These are sorted and drawn front to back for pass 1 and back to front for pass2. These changes yield a massive speedup for large scenes with instancing system on, as well as significant improvements even without the instancing system.
  • We've switched to just using tbb thread controls. diguyApp::get_num_threads() now defaults to -1 which will just allow tbb to choose. call diguyApp::set_num_threads(1) to turn things single threaded or pick a number to limit diguy to using that number of cores.
  • Removed:
    • diguyApp::set_use_qt_threading_infrastructure()
    • diguyApp::get_use_qt_threading_infrastructure(),
    • diguyApp::set_use_intel_threading_infrastructure()
    • diguyApp::get_use_intel_threading_infrastructure()
    • diguyApp::reserve_num_threads()
  • Multi-threaded pipeline code is now on by default in the SDK.
  • Performance improvements to calculating character animation position update.
  • Performance improvements to generating transparency pass data, will reuse data from pass1.
  • Instancing system now supports the 99% of models, previously some flt hierarchy layouts could break instancing, flight LOD nodes and other node structures should work now.
  • All together a test 6400 character scene with shadows on has gone from 65ms to 10ms! Shadow pass is almost free now.

Misc changes:

DI-Guy Scenario

  • Improved networking UI and networking logic to allow for changing protocols through the UI.
  • Network protocol no longer needs to be set with a command line option, although doing so changes the default on startup.
  • UI layout settings are now saved using Qt's save/restore logic, which allows for saving more detailed UI info.
  • Older UI preferences files are no longer compatible with 13.5.

DI-Guy Character Viewer

  • Added Equipment configuration UI
  • Added networking support and UI for testing simple publishing of character data.
  • Networking works like scenario does now. Protocol can be changed via UI.
  • UI layout settings are now saved using Qt's save/restore logic, which allows for saving more detailed UI info.
  • Older UI preferences files are no longer compatible with 13.5.
  • Many improvements to LOD testing Mode.
  • Improvement to mesh selection display.
  • Additional debug visualizations
  • Added PBR testing GUI.

DI-Guy Motion Editor and animation system

  • UI improvements to gesture editing.
  • UI improvements to action table editing
  • UI improvements to animation blend tree nodes.

New Action Graph Editor:

  • A new modern transition editing system that replaces NxN transition tables with groups of shared transitions and a stream lined finite state machine, soldier_action_graph is first character type to use the system.

New Animation blend tree features:

  • Selector supports posture and Hand Item type.
  • Blenders can now use instantaneous animation velocity or initial animation velocity, can allow nicer blends in locomotion system, initial animation velocity stores the speed at the beginning of the current motion loop and then blends into the next motion loop when the velocity is changing. but makes things less responsive.

DI-Guy Version 13.3/13.4

DI-Guy 13.3/13.4

  • Upgrade to Qt 5.
  • Fixed issue where unpaused characters would immediately update the total amount of time they were paused for, usually skipping to the end of the action. Now, unpausing resumes where the character left off.
  • IK link points: links or connections points can now be used to define both target points and the IK chain endpoint. IK solver looks for target points "l_grip_1" and "l_grip_2", and IK endpoint "l_palm". If found, these links override offsets defined in Weapon Supplemental Data.
  • Memory and performance improvements to the instancing system and per-character memory.
  • Improved animation system performance on complex blend trees.
  • Added support for asynchronous texture loading to retained mode renderers. See diguyApp::run_background_load_update().
  • OSG Examples now demonstrate asynchronous texture loading logic.
  • Added support for Microsoft Concurrency Visualizer markers and spans. See diguyApp::set_enable_concurrency_visualizer_markers().
  • The new diguyCharacter callback (CALLBACK_ID_CURRENT_ARC_CHANGED) can be used to listen for character motion arc changes.
  • The Action PDU now includes an optional offset field and a "use action positioning" flag. These can be used to specify a position correction (offset), and whether the character should be allowed to move from their starting position when transitioning to the given action.
  • Fixed minor UI issues with DI-Guy Scenario.
  • Fixed issue with Time Control Dialog, where changes wouldn't take effect immediately.
  • HLA Connections can now specify RPR FOM Version instead of relying on defaults.
  • Resolved issue where the arm_r_3s_you_know5 gesture affected the left arm instead of the right.
  • Fixed intermittent crash when deleting multiple published characters from a crowd.
  • Fixed bug where embarked entities/particle systems would stop updating if parent was culled.
  • Fixed crash when using head/tail lights on DI-Guy vehicles.
  • Fixed crash in navmesh processing on real-time systems.
  • Fixed foot sliding issue with Javelin character.
  • Fixed mouse input issue with ECOSim lua scripts.
  • Improved appearance of police uniform.
  • Fixed math issue in PBR shaders.

Motion changes and improvements:

  • Character motions are now loaded as needed instead of being loaded when a character is initialized, which allows for faster initial character creation.
  • Improved collision avoidance logic for crowds.
  • Improved motions and transitions for getting into and out of vehicles.
  • Added standing injured head.
  • Improved horse and rider motions.
  • Fixed suspect_09 issue with stand_180_hand_cuffed action causing upside-down flickering.
  • Changed how animation interpolation on locomotion animations work. Locomotion animation now blend between animation cycles but don't change velocity during the cycle, makes them lag slightly but the slider control api did that already. And this makes the necessity of interpolating slider values over the animation cycle superfluous.

Added item/weapons:

  • Binoculars.
  • FAMAS rifle.
  • MPT-76 rifle.
  • M17 pistol (Figure 1), replacing the M9 as a standard.

Added new soldier models:

  • Fighter pilot.
  • Paratrooper.
  • FELIN (France).
  • Countries: Canada, Germany, India, Israel, South Korea, North Korea, Pakistan, Qatar, Saudi Arabia, Singapore, and Turkey. For examples, please see Figure 2, Figure 3, and Figure 4.

DI-Guy 13.3/13.4 Core SDK

DI-Guy 13.2 Core SDK

  • Hand IK system now looks for named joints or connection points to define the target and chain end points. Currently supported point names are "l_grip_1", "l_grip_2", and "l_palm". l_grip_1 and 2 define target points to use when the Motion Arc Hand IK is set to Offset 1 or 2, respectively. These override the target points previously defined in weapon_supplemental_data as offsets from rifle_joint. l_palm defines a new, optional chain end point to be moved to align with the target point. If l_palm does not exist, the IK system falls back to using wrist_1 as it did before. Typically, l_palm would be added as a child of wrist_1, and l_grip_1/2 as children of rifle_joint.

DI-Guy Version 13.2

DI-Guy 13.2.1

  • Embarked entities are now published with proper parenting attributes.
  • Reflected embarked entities are parented to the host entity and rendered as such.

DI-Guy 13.2 Core SDK

  • Fixed significant performance regression with instancing system due to over-aggressive variation texture update.

DI-Guy 13.2 Core SDK

Critical API Changes

Geometry Pipeline:

  • Fixed mesh count calculation for flight file xrefs
  • Delayed mesh count calculation since it's rarely needed by immediate mode apis
  • Improved calculation of bump and transparency bits so they are available to the graphics api.
  • Fixed support for alpha to coverage clip maps.
  • Fix issues with draw pass debugger in character viewer
  • Fix hard crash when optimizing mesh with null textures.
  • Fixed material optimization bug that lead to shininess values of 0 on many flt files.
  • New global ambient material override system, unifies all ambient responses regardless of source per model ambient customization really should be at the per pixel level via ao maps. This gives end users more high level control of the look of their diguy content .

Gesture System:

  • New option for gestures to be done additively based on 1st pose of gesture frame. useful for recoil animations
  • Gestures with no weighted vars now play animation on all bones.
  • diguyCharacter::execute_gesture() now supports playing arbitrary bdm files off disk. this can be useful for end users who aren't concerned with setting up action/transition tables

Performance:

  • Streamlined memory usage of links, lowers the size of every simulated joint diguy manages. Removed underlying static offset matrix, unified data into dynamic matrix and simplified matrix math operations.
  • Streamlined memory usage of pose override system, impacts gazing, pointing, aiming.

Joint Control API:

  • Adding diguyLinkController a new api for doing link control at the link level. Much simpler then pose override class and able to be scripted with features to let it automatically animate.

Particles:

  • Fixed default bounding radius initialization in particle system constructor, could cause effect characters to not update properly due to being mistakenly culled out. (Seen in OSG)
  • Improvements to multi-threading of particle systems
  • Add support for transient fire effects with link offsets.
  • Improvements to support transient particle systems driving external particle systems, and properly timing out
  • Transient particles that are flagged as mergeable will now attempt to move existing emitter and restart the system. Most weapon effects are now flagged as mergeable, allowing many characters to create muzzle smoke, and shell eject casings efficiently.
  • Fixes to collision with world/animated spinning

Munition System:

  • removed diguyCharacter::set_weapon_shell_eject_enabled() get_weapon_shell_eject_enabled() set_weapon_smoke_enabled() get_weapon_smoke_enabled() these now all key off of diguyScenario::get_weapon_fire_effects_enabled()
  • Munitions type effects can now inherit other munitions, makes it easier to author one set of effects and share it with all the various tanks or other weapons with just a different septet.
  • Tanks now have a smoke explosion when firing and a recoil for their barrel.
  • People have an additive kickback gesture that works regardless of the characters aiming direction. Puff of smoke at muzzle point, and shell eject on the right side of most weapons. Tracer fire has been improved as well.

Misc:

  • Adding particle movement animation module, object will move at the exact speed requested via animation_velocity api.
  • Improvements to lod calculation for large objects, fixed bug where motion lod would make a ground clamping car spin through the ground
  • Improved gaze at angle to work better in arbitrary coordinate systems, regardless of movement of character.
  • Adding multi-threaded read/write lock mutex to protect octtree from editing while testing, fixes crashes with moving props.
  • Improved movement visuals to not appear inside of vehicles.
  • Added visualization of angular velocity
  • Improved calculation of angular velocity from vehicles.
  • Regression Fixed ground bounds calculation to work with turreted vehicles again.
  • Changing the character appearance should attempt to retain more of the animation system state.
  • Stationary motions will no longer get scaled by character height. This looked pretty bad/didn't make sense on shorter characters.
  • Switched sound module to openAL-soft, older version was locking up with vc12 on windows 8/10
  • Added support for scale to physics simulation.
  • Added caching for local space bounding box retrieval.
  • Added warning for bad rigging on vehicles.

New API Classes:

  • diguyLinkController - a simple class that allows end users to override a character's animation on a joint level without the complexity of the diguyPoseOverride class.
  • diguyUniformBufferUpdater - a virtual interface class that wraps all uniform buffer management.
  • diguyGraphicsFrameBuffer - a virtual interface class that allows diguy to create frame buffers for shadows and intersection testing.

New API functions:

DI-Guy Scenario Version 13.2

General:

  • Added scene object instancing system that speeds up rendering of xrefs and other duplicated geometry.
  • Between improvements to instancing system, improved renderer and xref instancing Large Scenes can see a 2x speed up in rendering.
  • Action bead can now calculate velocity for locomotion actions when deriving duration.
  • Added scene rendering debugging tools.
  • Added geometry viewing tools for characters and scene objects
  • Added UI for controlling global ambient material values

Networking:

  • Upgraded to vrlink 5.3.0
  • Adding support for multi-threaded publishing.
  • Fixed bug where reflected characters had variation textures on by default.
  • New Networking debugging panel
    • Incoming and outgoing packet info visualization aids
    • Packet indicators pop little spheres over the heads of characters when they either send or receive a new movement packet. Outgoing limited to DIS currently.
  • Support for enabling log messages from VRlink
  • New network adapter chooser that should help set the transmit to IP UI.
  • Fixed bug with sending rotational velocity, was reversed compared with DIS spec.
  • Fixed bug with dead reckoning individual that was moving backwards, led to very incorrect behavior.
  • Better distribute pdu heartbeat events in time.
  • Fixed bug preventing send_xc_ commands from rewinding/resetting remote scenario
  • Added acceleration publishing
  • Vehicles without custom pdus will have rotating wheels.
  • DIGUY_CUSTOM_PDU_ID_CHARACTER_SCALE has been modified to include an additional 4th value for weight scale.

Camera System Changes:

  • Camera zipping is once again triggered by shift-click.
  • A tracked character can only be watched from a stationary position, unless the user puts the camera into orbit mode. If not, the tracking will stop as soon as the camera is moved.
  • Double-clicking on a character will put the camera into orbit mode around it.

DI-Guy Motion Editor Version 13.2

General:

  • New Outliner UI, nicer way to see and edit all the joints in a skeleton, The Joint editor UI buttons now trigger the new Outliner UI.
  • Fixed crashes on processing degenerate animation files.
  • dae animations with static parts are now properly imported into motion editor.
  • Fixed bugs creating collada animation files from diguy motions.
  • Unified advanced and regular export motion dialog box. Made it possible to export blended motion without idealizing.
  • Adding support for a scripting interface to motion editor export process via diguyMotionExporter class.
  • Improved Gesture UI to work with more gesture types
  • Gesture weights UI now just allow editing of a unified rotation weight, more accurately reflect the behavior of the underlying code.

DI-Guy 13.2 Graphics API and Rendering Pipeline Changes

Rendering Pipeline

  • The Core DI-Guy rendering pipeline has been upgraded to use OpenGL 3.2, we have removed deprecated fixed function code from our 2 OpenGL Renderers, all of our programming examples, DI-Guy Scenario, Character Viewer and Motion Editor. You should be able to debug all of our code with Nvidia's NSight as well.
    • Legacy OpenGL 2.1 shaders are now located in geometry/shaders/opengl_21, these are still actively used by OSG reference implementation. Modern Shaders are located in the opengl_32 subdirectory.
    • diguyGraphicsShaderProgram::derive_diguy_shader_source_filename() now takes a subdirectory argument to allow us to have the same shader description with different implementations.
    • All OpenGL 3.2 shaders have been rewritten to use a shared library ( diguy_shared_library.glsl ) this centralizes the use and implementation of uniform buffers, standard uniforms, and attributes. Shared functions that are used by many shaders have also moved there.
    • The built-in fixed function uniforms have been removed from all modern shaders.
    • The various lod shaders and instancing shaders have been cleaned up to remove slight lighting discrepancies between the shader lods.
    • Bump mapping has been streamlined to remove the need for a number of per object uniforms, this has simplified bump map uniform set up in diguyGraphicsLink::begin_character_draw() (ie it's gone) It's also simplified the whole lighting pipeline.
    • Ambient light in shaders now falls off when normals point down, models ambient light mostly coming from the sky.
    • Bump mapped shaders have changed quite a bit, they do more work in the pixel shader but that was the cleanest way to support multiple bump mapped lights as well as improve uniformity between shader stages.
    • Bump mapped and Per Pixel shaders now include improved specular highlight handling including Fresnel and some parts of a Physically Based Shader pipeline. Objects can now specify on a per shape basis if they have been updated to use PBR style lighting. This provides more realistic metal and non-metal specularity and lighting.
  • Long term we intend to remove the libdiguy_graphics_ogl implementation and move all of our Applications (DI-Guy Scenario) and sample code to the diguy_graphics_api, the diguyOglParticleSystemRenderer and the diguyOglUniformBufferUpdater for example are now used by both the diguy_ogl examples and the diguyGraphicsAPI OpenGL examples, and DI-Guy Scenario. The justification for this is many faceted:
    • Eliminate the need to maintain two OpenGL code bases. One closed source and one public source
    • Guarantee that any thing that can be done with the closed source code is doable with the public api and implementation.
    • Recognize the reality that with the removal of the fixed function pipeline and fixed function OpenGL state the closed source libdiguy_graphics_ogl renderer is not going useful for many people.
  • Mesh classes now support rendering additional blend shape data sourced from Collada files. currently used for a weight variation system on some of the characters.
  • glew and glm are now required by all of our OpenGL programming examples.
  • The function prototype for diguyGraphicsMesh::draw() has changed to diguyGraphicsMesh::draw(diguyDrawCallData * data) this allows both our instance and non-instanced code to share a mesh drawing path, and allows us to make further refinements without breaking API compatibility. Your diguyGraphicsMesh implementation is now responsible for binding geometry material and texture state and managing early outing for transparency, diguyOglGraphicsMesh now demonstrates all of that.
  • Instancing system now supports our variation system. The sample code for the variation now combines all variation textures into one large 4096 texture. This avoids creating hundreds of tiny textures. This also allows the instancing system to use it. A uniform for specifying the row of the shared variation texture has been added. And it is now encoded as part of the TBO data that is sent to the video card.
  • Instancing system now has a shadow pass shader.
  • Instancing system supports respacing the data in the TBO, this allows end users to add additional per character data to the tbo.
  • Unlit shader now included variation texture support. (Avoids popping)
  • Instancing now defaults to LOD 4, kicks on much earlier but new variation support makes it less noticeable.
  • Fixed bug where num rendering passes was defaulting to 1 not 2. Caused transparency to look bad. Change requires that diguyScenario::draw_pass1() and then diguyScenario::draw_pass2() are called with different blend settings.
  • Fixed a number of issues with how we loaded and managed specularity from flt and collada files. Some models that were sourced as shiny were loosing that data. This improves the look of a bunch of models, but also calls out for more specular maps.

DirectX 11 Sample

-We've added a very bare bones sample of using diguy with DirectX 11. This is a very rough around the edges proof of concept, but all the major pieces to get a character on the screen are there.

OSG Improvements

  • OSG now demonstrates using the DI-Guy ogl immediate mode particle renderer as an add-on drawable.
  • Fixed scale bug where character scaling was applied 2x.
  • Streamlined mesh loading, added support for blend shapes applied to meshes. Currently limited by OSG's infrastructure.

Cleanups

  • Removed diguyGraphicsLink::get_offset_translation() and diguyGraphicsLink::get_offset_rotation() we no longer have links that combine a static offset matrix and a dynamic matrix, all information is now in the dynamic matrix. Trying to match authoring tools and reduce confusion.
  • Removed DIGUY_GRAPHICS_INDEX_TYPE_D3D_WORD, and some unused vertex array formats
  • Removed bdiGraphicsInitGraphicsAPI.use_array_format_for_vertex_buffer_data
  • Removed bdiGraphicsInitGraphicsAPI.use_linear_traversal_draw
  • Removed bdiGraphicsInitGraphicsAPI.use_shaders
  • Removed bdiGraphicsInitGraphicsAPI.default_vertex_type, this really shouldn't have ever been a preference index data is either a ushort or uint depending on the size of the mesh.
  • bdiGraphicsInitGraphicsAPI.characters_have_world_space_triangle_query now defaults to 1 in gfx api. this allows bounding box calculations to work, this really is only there for historical reasons when we didn't always control our geometry pipeline.
  • Cleaned up bdiGraphicsInitOgl, removing options that no longer made sense:
    • Removed bdiGraphicsInitOgl.texture_unit
    • Removed bdiGraphicsInitOgl.use_multitexture_extension
    • Removed bdiGraphicsInitOgl.use_shaders
    • Removed bdiGraphicsInitOgl.use_VBOs
  • Removed diguyGraphicsShaderProgram::reload() simpler to just require that load() properly handle being called multiple times.
  • Removed diguy_ogl_render_shadow_map() replaced with diguyOglUtils::render_shadow_map()
  • Fixed bug in diguyCharacter::get_link_relative_position(), will no longer include the first link's offset.

DI-Guy Version 13.1

DI-Guy Scenario Version 13.1.0

  • New camera control scheme, uses click-and-drag operations for pan, zoom, and rotate.
  • New aircraft guide demo. Interactive scenario including different air vehicles and a missile launcher. Also demonstrates different ways to use camera.

DI-Guy 13.1 Core SDK

Note that most changes to the DI-Guy API also apply to DI-Guy Scenario.

Version 13.1.0

General

  • Improved UID generation supports larger number of characters with less performance impact.
  • Fixed soldier aiming jitters when targeting a point close to the gun muzzle.
  • Improved RenderGizmo:draw_wedge_with_normal drawing of small-scale wedges.
  • Improved calculation for shadow render frustum so that the edge of the shadow volume is not so easily visible in scene
  • Improved blocked-cell calculations for more reliable nav mesh generation.
  • Fixed issue where diguyScenario::destroy_character did not always remove character from groups immediately
  • More work on supporting alternative coordinate systems via diguyCharacter::set_local_to_world_orientation_matrix()
  • Adding support for general emissive textures in the alpha channel of spec/gloss/ao map.
  • Reference shaders do a nicer job balancing emissive and point lights brightness with general scene ambient.
  • Added bdiScenarioPluginCharacterFunction, this is now used for the plug-in mid_update function instead of bdiScenarioPluginFunction this is potentially called by multiple threads simultaneously.
  • Minimized the number of times shape build and unbuild is run.
  • Update Loop changes:
    • diguyScenario core update loop has been cleaned up to try and yield more stable results when long dt's longer then the simulation frame rate are presented.
    • The diguyScenario::set_max_ticks_behind_until_drop() default value is now 0 in the DI-Guy SDK, In DI-Guy Scenario it is 2, this keeps our application deterministic but the general SDK will try to allow a bit less perfection in scenario playback in exchange for better performance.

Performance Improvements

  • Improved performance of link updates, animation variable are now required to have quaternion layouts (needs rw), allows simplifies code path through our update infrastructure. Custom character types may need to be updated.
  • Removed recursive update of links switched to a simpler linear array traversal.
  • 4x4 Matrix multiplies now use SSE to speed up math.
  • Multi-threaded update pipeline can now use the Intel Threaded Building Blocks parallel scheduler appears to 10% faster then qt parallel for system. Currently we do not provide controls for how many threads it uses and we are using it's recommended defaults.
  • Minimizing updates for culled characters: we've added new logic to diguy to delay updates of culled characters, characters that are drawn the previous frame will get link matrix and shader matrices updates inside the multi-threaded pipeline, otherwise the update of links, shapes and shader matrices will be done on a as needed basis, eg when character is being drawn or code calls diguyCharacter::get_link_position(). This guarantees that characters who are aiming or gazing at off screen entities still do the right thing. This provides massive speed boost for folks that are completely off screen without degrading the quality of the simulation. The following functions will need to be called to enable this system diguyScenario::pre_draw_cull_state_reset() diguyScenario::post_draw_cull_state_save() and in a retained mode render: diguyCharacter::set_is_culled(0)
  • OSG reference sample has a new way of sending uniform arrays that is much faster.

Content Pipeline Improvements

  • A single mesh with more then 65k verts should be handled better, was blowing out ushort index buffer, now converted to uint
  • Procedurally created links from dae models will now get properly destroyed when appearance is changed.
  • Procedurally created links properly set initial translation and initial rotation.
  • Added support for procedurally created links from non skinned dae's, enables collada weapons to specify muzzle location
  • Fixed handling of dae animation translation scale

Vehicle Improvements

  • Added code for damaged and destroyed appearance functionality. Will now auto switch if character is killed, or if diguyCharacter::set_DIS_damage_state() is called. Will go over network, and secondary appearance should load at the same time as initial appearance. Added diguyCharacter::get_damage_state_appearance_name()
  • Vehicle ground clamping system has been improved, uses 4 intersection points and avoids some ugly edge cases
  • Vehicles without articulated skeletons (ie vehicles not vehicle_09s)'s ground footprint is calculated better.
  • Vehicles with articulated skeletons can now be used as vehicles, wheels will rotate automatically. This uses a new physics simulation mode DIGUY_VEHICLE_SIMULATION_MODE_WHEELS.
  • Vehicles can have up to 12 wheels that will automatically rotate. (useful for tanks)
  • Added character guide algorithms for aircraft, missiles, helicopters, and ballistic projectiles. Visit aircraft guide demo in DI-Guy Scenario to see these in action.

Camera Improvements

  • Camera system now organized around base position, base orientation, position offset, and orientation offset. There is lots of flexibility in how these are applied. See class-level notes in diguyViewCamera.
  • Camera can still dolly and track as it did before. Setting a dolly character will cause base position and base orientation to be overridden.
  • Behavior of camera in dollied state is now mathematically correct and consistent. If, for example, camera is attached to wing of aircraft, it will remain in consistent place relative to aircraft, no matter how it turns, pitches, and roll.
  • Restored camera behavior that existed in 12.5. In this version, when both a dolly and track character were set, the camera would move behind the dolly character to keep both in view. This behavior is now called "special track mode", but is turned off by default.
  • Deprecated a number of functions.

Appearance Editor: The character viewer now includes a new appearance editing component that allows for real time editing of Appearance and shape set configuration data.

Particles/Appearance Effects:

  • Many Bug fixes to appearance effects system.
  • Fixed a number of bugs with stopping appearance effects that had been specialized for specific character types.
  • Any particle system in the current scenario can now be used as an appearance effect without modifying any configuration files.
  • Appearance Effects can now be specified as part of appearance configuration data.
  • Appearance Effects list in decision beads are no longer hard coded.
  • Removed legacy Appearance Effects system. Had been unused since diguy 10.x
  • Removed independent particle system dll, code moved into libdiguy.
  • Adding support for the rendering of particle systems to the graphics api see diguyParticleSystem and diguyOglParticleSystemRenderer
  • Adding support to the graphics API retrieving a list of active light sources, OpenGL simple_playback demonstrates.
  • Adding support for the mapping of diguy particle systems to an external particle system renderer see diguyParticleSystem for details.
  • Particle System engine update is now multi-threaded
  • Added support for parsing lights from collada dae. head lights and tail light are automatically hooked up to appropriate networking bits based on names.
  • Particles associated with characters that are flagged as invisible won't draw.

Lighting/Shader Improvements

  • Added support for emissivity maps as the alpha channel of spec/glos/ao maps. These default to on, and for vehicles will respond automatically to the power plant dis flag. - Note: in order to enable this functionality you'll need to update how emissivity is sent to the graphics card, it's now done on a per character basis, not per material.
  • Point and emissivity lights are now balanced against the amount of ambient light in the primary directional light in the shader. This lowers blow out in daytime but still has desired impact at night.

Connection Point System:

Networking

  • Upgraded VR-Link to 5.1.3a.
    • HLA Evolved supports new interactions: AI messaging, appearance effects, gestures, and reset command
    • Reflected characters are properly culled/unculled when they leave/enter the space being simulated locally
    • In HLA Evolved, networked characters referenced by VR-Link global ID string. In practice, this will contain a value such as "66_77_soldier07-0"
    • Attempt is made to choose version-specific FOM file when connecting DI-Guy instances over the network. Will be named DIGuyModule_1310.xml. Also, the search for available FOM files covers both the DIGUY_CUSTOM folder and the base config folder.
    • HLA 1516e FOM Mapper support: FOM Mapper DLLs may be placed in the networking folder alongside the associated FOM file. The FOM Mapper DLL name must match the FOM filename (excluding file extension, ex: MyFOM.xml and MyFOM.dll).
    • Added "Federate Name" and "Federate Type" fields to network properties. These may be set from DIGS Network Settings window, or via API calls to diguyNetInterface::set_federate_name/set_federate_type. NOTE: "Federate Name" replaces auto-generated federate name based on site/host id.
    • Added Aggregate Publishing: Crowds now have option (default FALSE) to Publish as an Aggregate Entity.
    • Improvements to sending and receiving articulated vehicles and steering.
    • Added basic support for visualizing laser designators.
    • Munition type septets now support wildcards in munition_types.cfg, allows mapping many septets to a standard suitable detonation config.

DI-Guy 13.1 Graphics API Changes

OSG Improvements

DI-Guy 13.1.0 API Changes

New Classes

New API functions

Removed Deprecated API functions:

  • diguySceneObject::set_switch_state()
  • diguySceneObject::get_switch_state()
  • diguySceneObject::set_dof_state()
  • diguySceneObject::set_dof_state_flt();
  • diguySceneObject::get_dof_state();
  • diguySceneObject::get_dof_state_flt();
  • diguySceneObject::add_switch_target();
  • diguySceneObject::abort_all_switch_targets();
  • diguySceneObject::add_dof_target();
  • diguySceneObject::add_dof_target_flt();
  • diguySceneObject::abort_all_dof_targets();

Deprecated API functions:

New API callbacks:

- New input mode:

  • DIGUY_SCENARIO_INPUT_MODE_POINT_SELECT_WITH_CAMERA

DI-Guy Version 13.0.x

DI-Guy 13.0.1 API Changes

  • minimized the number of times shape build and unbuild is run.

Version 13.0.1a

  • Fixed hard crash when browsing scene objects

Version 13.0.1

Import Pipeline

  • Improved support for collada mesh data exported from Maya.
  • Fixed issue where capitalized FLT extension could confuse material system.

Animation System:

  • Animation system regression fix to 12.5, restored a while loop that was needed when update loop was fed a long time step.
  • Fixed potential issue in animation system when update loop was fed a long time step.
  • Fixed animation rotation interpolation on joints when imported into motion editor via collada.
  • Fixed calculation of script/decision bead position when multi-arc rep motion instances are used.
  • Regression fix, diguyCharacter::create_and_force_bridge_path() didn't work properly due to action editing improvements.
  • Added diguyCharacter::set_desired_position_double() and get_desired_position_double()
  • Improved guide code to handle large value locations better.
  • Increased precision of positions to better support geocentric coords.
  • Fixed a crash that could occur when a character playing an animation had it's character type changed, (reasonably possible with networking lib)
  • Characters with custom up vectors will move better along the coordinate system that the up vector defines. previously limited to motions with forward direction and other limitations.
  • Fixed bug where characters that had their default hand item set and then the item that the default actually equaled could loose what was in their hand.
  • Fixed bug where ground clamped vehicles weren't following the terrain, (broken in 13.0.0)
  • Calling diguyCharacter::set_speed() while a character is transitioning into a still motion, will now no-op. Previously setting speed to 0 when a character played certain dead transitions could wind up freezing the character in mid fall.
  • Motions that are slowed down will automatically interpolate.
  • Increased the max speed of iguy strafing.
  • Added diguyCharacter::set_local_to_world_orientation_matrix() experimental function allowing a rotated plane to be used for character movement displacement calculations. useful for geocentric rendering and animation.
  • Improved diguyCharacter::force_action() with a speed, to no longer speed warp transition animations.
  • Fixed a number of speed scale and velocity scaling issue. Regressions to 12.5 as well as long standing issues
  • Fixed force action with a non-default speed with a scaled character/or different skeleton then expected (eg female soldier)
  • force action with default speed on a scaled/or different skeleton will now scale the speed of the motion to match the expected action value.
  • Improved IK system to properly handle uniformly scaled characters.
  • Changing character appearance no longer resets a specified hand item, but will still change to a new default if no item is specified.
  • Fixed bug where up vector setting was being ignored on vehicle_09's on reset.
  • Fixed bug where vehicles on reset could have oddly behaving wheels.
  • Improved Vehicle based I-Guy to turn camera better, ground clamp properly and be generally nicer.
  • Fixed bug where changing turreted vehicle's appearances could have incorrect aiming/firing behavior.
  • Regression fix, preloading a character type did not properly preload animation data.
  • Fixed but with reporting initial action for a path with an action that didn't have a transition out.
  • Fixed a number of non-growing memory leaks, and memory access issues.
  • Tweaked anisotropic filtering default to be 1.0 not 0.0 matches OpenGL spec.

Camera:

  • Merged 12.5.4 camera functionality dealing with supporting camera roll into 13.0.1
  • Better handling of camera smoothing, keeps camera motion smooth while resolving jitter when tracking characters.

Networking:

  • Upgraded VR-Link to 5.1.2.
  • Fixed hard crash when networked entity goes on/off-line and changes appearance.
  • Added debugging visuals for received actions.
  • Added culling to debugging visuals to keep performance reasonable.
  • Added diguyCharacter::set_is_network_paused() allows end users to duplicate network paused behavior without using our network layer.
  • Improved warning messages from lua when invoked from script bead, couple other fixes.
  • Fixed hard crash interaction between destroying networked characters and instancing
  • Fixed issue where diguy 12.5 style DIS packets were being sent.
  • Fixed network teleporting on reset and other large discontinuous position updates.
  • Fixed a number of drift and adaptive guide parameter bugs.
  • Networking module will always send out action speed as part of custom PDU, was only happening if it was a non-default speed.
  • Added new z velocity threshold option for forcing a packet update, this can help with
  • up and down movement over the network.
  • Added a new UI for editing packet thresholds.
  • Fixed bug where teleporting vehicles did not have proper orientation.
  • Rewrote data that went out describing human articulated aiming data. Previous solution was world space xyz positions, that wouldn't really work in other coordinate systems. We are now sending more portable azimuth and elevation data that should be cleaner. A similar change was made for gaze descriptions.
  • DI-Guys have marking text set to their names by default

Instancing

  • Updated instancing to respect texture swaps. Can be toggled off for increased performance. Added instancing_respect_graphics_state_switch to bdiGraphicsInitGraphicsAPI struct.
  • Fixed networking sending of velocity of characters playing speed scaled motions.

Rendering

  • Fixed asynchronous texture load shader ugliness when switching between shaders when spec/normal maps haven't been loaded yet.

AI:

  • Fixed issue where dragging an AI could reset their mind and confuse their location.
  • Fixed small nav mesh glitch which caused a failure to detect some impassable polygons.

Sound:

  • Fixed Doppler Effect bugs: improper velocity updates caused stuck/distorted sounds.

Misc:

  • Fixed fatal errors in lqt when dealing with certain widget types.

Draw Passes

  • New draw pass system allows client applications to register draw passes with DI-Guy that are called instead of the native rendering when calling diguyScenario::draw(). Clients can add any number of draw passes each with an optional preDraw() and postDraw() callback.
  • The example programming_examples/diguy_plugin/diguy_plugin_sensor_fusion exercises the draw pass functionality.

DI-Guy 13.0.1 API Changes

New API functions

New API Classes

DI-Guy 13.0.x Graphics API Changes

Version 13.0

  • Fixed issues with diguyGraphicsLinks::get_rotation_euler(), and diguyGraphicsLinks::get_rotation_quat() to return valid values even if the underlying data is still in eulers or quats (currently happens with some vehicles.)

OpenGL reference Code

  • Added nicer support for asynchronous texture loading proxy textures. see diguyOglGraphicsTexture::build_opengl_texture() for updated sample code.

OSG reference Code

  • Large rewrite of culling/lod system, a new custom node early outs culling based on simplified bounding volume. Also short circuits LOD picking and OSG character traversal. drops cost of culling by 90%.
  • Added custom TBO class to remove limitation of instancing only working on OSG 3.2 or greater.
  • Changed diguyOsgGraphicsShape::update() to check for transposed shader matrices before pushing data to OSG instead of via an #ifdef guard.

Version 13.0

Defaulting to VC10

  • DI-Guy Applications are now compiled with Visual Studio 2010 which is now the default compile target.
  • VC10 project files are now available for most programming examples. These make use of property sheets to share variables and configurations between many different examples and configuration targets.

Appearance System

  • New hand item appearance system, reduces the need for hundreds of appearances. Character types now specify information about what hand items are appropriate and configuration information applies that to existing appearances.
  • Fixed bug with decision beads. No head appearances were being shown after revamping the head appearance system.
  • Fixed bug where current body/head/hands appearances weren't restored to defaults on reset.
  • Motion engine is no longer reset when changing heads or hands.

Real time IK system

  • New system for leg and hand/gun real-time adjustments. Feet stick better to terrain/stairs. Hands can now be made to adapt to different weapons without creating new animations.

Core Animation API

  • Quaternion pipeline is now on by default, this can yield a 10-15% update speed up. If this causes any issues it can be turned off by calling diguyApp::set_precompute_quaternions_enabled(0).
  • Rewrote portions of spline interpolation code to give consistent velocity results regardless of number of segments used. Most notable on vehicles with long paths that could exhibit sawtooth velocities in the past.
  • Fixed bug in set orientation that could allow > 2 PI orientations.
  • Modified action lookup to return closer speed based action if alternative variant is specified.
  • Waypoint segment changes should now affect visuals.
  • Large internal rewrites of systems to support blend tree system, animations play back in normalized time, position accumulation works off of dt instead of absolute animation time. Please report any regressions to DI-Guy.

Blend Tree system

  • New animation blend tree system. Enables new multi-direction locomotion animations, aiming while running, and using one action to map to multiple animations. For example 1 character type can now have a stand_ready action that maps to a number of different animations based on what's in their hand. Available animation nodes include 1D blender, 2D blender, 2 Animation priority weight masker, motion selector.
  • Added demoing tools for locomotion, aiming and tool use to DIGuyCharacterViewer.
  • New Node graph editor in Motion Editor.
  • New system for triggering events from within animations, scripts and decisions are available.

Motion Editor

  • Fixed many motion export issues.
  • Added Collada Dae animation file import to Motion Editor.
  • Added bdm2dae, a new bdm to Collada converter to allow animations to be edited in 3ds Max or Maya.
  • Added animation blend tree node editor for authoring animation nodes.
  • Added new DI-Guy extras window includes tools for evaluating different DI-Guy appearances (hand/head) with motions, turning on/off IK and visualizing.
  • Fixed hard crash in Motion Editor when reversing short motions.
  • Fixed Motion Editor mirroring functionality.
  • Added new editor for adding script/decision events to animations (experimental).

Aiming

  • Slowed down aim tracking when character is on top of target. Aiming could oscillate badly before.
  • Fixes to aiming deflection code. Fixes bug where character could sometimes ignore extreme aim at azimuths.
  • Cleaned up aim converge code, only takes one argument on/off now.
  • diguyCharacter::force_action() will no longer reset aimer.

DI-Guy AI

  • Removed DIGUY_DYNAMIC_AVOIDANCE_METHOD_SIMPLE. It wasn't being used.
  • Added diguyDynamicAvoidanceMethod DIGUY_DYNAMIC_AVOIDANCE_METHOD_REPULSION_ZONES_AND_PROJECTED_FORCES, a new algorithm that incorporates facing direction and character velocity into influence calculations. Crowds with repulsion_zone set in dss get automatically upgraded to the new force model.
  • Influence forces are now visualized by increasing red amount in influence disk to represent strength of force on character.
  • Desired force heading line is now green-to-red to better differentiate from repulsion force.
  • Fixed bug where repulsion zone on/off didn't actually work.
  • Fixed bugs in 'teleport at end of path' travel option.
  • The velocity of the current action no longer affects the strength of the force contribution. This makes running characters less likely to plow through crowds.
  • Added smoothing to accumulated crowd forces. Lowers the amount of jittering from the new force model.

Networking

  • Upgraded VR-Link to 5.0.1.
  • HLA configuration files now live in $DIGUY/config/diguy/networking you may need to update your RTI_CONFIG environment variable.
  • Added support for HLA Evolved.
  • Added new DI-Guy HLA Evolved module.
  • New HLA FOM for 1.3 and 1516, adding support for head and hand appearances. Older FOMs will default to sending 12.5 compatible appearances.
  • DIS custom pdu DIGUY_CUSTOM_PDU_ID_SET_CHAR_APPEARANCE now contains 3rd string for hand appearance.
  • DIS custom pdu DIGUY_CUSTOM_PDU_ID_SET_SHAPE_VARIATION has been deprecated see DIGUY_CUSTOM_PDU_ID_SET_SHAPE_VARIATION_2 for a hardened version of this pdu.
  • Characters now publish angular velocity every frame.
  • Most of the math in the drift guide has been rewritten:
    • Now integrates the desired position forward based on desired velocity.
    • Uses desired angular velocity to modify the orientation over time.
    • Uses desired angular velocity to modify desired velocity.
    • Faster non asymptotic drifting to desired location/orientation.
    • Removed course error concept from guide.
  • Fixed bug with new female casuals with skin tones getting sent over network.
  • Fixed logic bug with DIGUY_CUSTOM_PDU_ID_SET_SHAPE_VARIATION handling and multiple variation textures.
  • Updated sample code demonstrating processing DIGUY_CUSTOM_PDU_ID_SET_SHAPE_VARIATION packet.
  • Use transition time and velocity ramping to better slow down decelerating characters who are transitioning to stationary motions.
  • We now only sync speed for characters that don't have custom PDUs being sent, we rely on the initial speed from the action PDU. Fixes issues with crawling, and transition speed.
  • Change publishing code to send the desired action instead of the current action. Lets transitions go out over the network at the start of transition instead of after it's completed.
  • Published velocity is now the average velocity for characters performing most simple actions, this avoids slow or fast packets and yields better dead reckoning results. Character's transitioning or colliding with objects should send raw velocity.
  • Guide example has been heavily rewritten.
  • Tweaked network guide defaults a bit.
  • network.cfg now saves to disk when going on line not off-line.
  • Added adaptive guide value to network.cfg.
  • Added code to better handle characters playing locomotion animations over the network.

DI-Guy For Unity

  • Added support for material swaps to renderer, (used by most skinned characters)
  • Added support for gloss and spec maps to renderer.
  • Textures needed by scenario should now unlz4 and place themselves into the resource directory on the fly.

DI-Guy General API

  • Improvements to changing character types while on a path, still not well supported.
  • Fix bug where diguyCharacter::CALLBACK_ID_CURRENT_ACTION_CHANGED would not go off for characters on paths.
  • Fixed Collada files to use short indices for index buffer, 10% memory/disk improvement.
  • Improved index buffer ordering to better make use of vertex cache, provides frame rate speedup.
  • Intersection callbacks will now test DI-Guy props after calling out to C++ user level code.
  • Improved speed and memory usage of octtree generation.
  • Fixed issues with intersecting non-uniformly scaled props.
  • Fixed issues loading xrefs with multiple "../" in path names, and a number of other xref transform issues.

DI-Guy Graphics API Changes

  • diguyGraphicsLink::get_transformation_matrix_4x4_ptr() now returns a matrix that has scale incorporated in. Removes need for calling glScalef and diguyCharacter::get_scale(), simplifies rendering code and helps support instancing system, please update your code.
  • virtual overridable calls diguyGraphicsLink::attach_to_link() and diguyGraphicsLink::detach_from_link() have been removed, were only used by OSG and architecture improvements have meant that parented object are managed the same way as non-parented objects, this should fix parenting in OSG.
  • diguyGraphicsShape sample code no longer uses get_offset_translation/rotation/scale(), code has been deprecated.
  • Support for Recursive Link Drawing has been removed.

DI-Guy 13.0.x Content Data

Version 13.0.1

  • Restored visibility of javelin, at4 soldiers.
  • Changed character type usmc_smaw to soldier_smaw replaces an older deprecated model
  • Modified medic to default to standing

Version 13.0

  • Removed vast majority of unneeded appearances that have been replaced by hand item system.
  • Upgraded Male/Female Bikers, Cameraman and Wheelchairs, Flight deck crew to be skinned character compatible.
  • Configuration setup for characters with secondary items (hoses, bikes, wheelchairs) has been simplified to not require additional actors.
  • New car appearances authored via modern pipeline, skinned objects needing only 2 draw calls with bump/spec/AO/variation.
  • New Female casual appearances.
  • New Male casual appearances.
  • New Opfor appearances.
  • New Construction Worker character type.
  • Animation blend tree functionality is now used in soldier_07/mideast_soldier_07 character types, this adds support for:
    • multi-directional movement is now supported via new actions upright_movement, crouched_movement and prone_movement.
    • all moving aim animations now support aiming different directions by combining original motion with stand_aim data.
  • Added movement locomotion action to all vehicle character types as well as bikers and wheelchairs, can use diguyCharacter::set_animation_local_velocity() to go at any speed, not just quantized values in the past.
  • All character animation configuration files have been upgraded to support quaternion pipeline.

DI-Guy 13 API Changes

New API functions

DI-Guy Networking

DI-Guy AI

DI-Guy Graphics API

New API Classes

API's functions modified

Deprecated the following functions:

  • diguyGraphicsShape offset api, was never actually used in modern models.
  • diguyGraphicsShape::get_has_offset_translation()
  • diguyGraphicsShape::get_offset_translation()
  • diguyGraphicsShape::get_has_offset_rotation()
  • diguyGraphicsShape::get_offset_rotation()
  • diguyGraphicsShape::get_has_offset_scale()
  • diguyGraphicsShape::get_offset_scale()

Deprecated functions Removed

  • Removed the following deprecated functions (see diguyCharacter.h for recommended replacements):
    • diguyCharacter::get_base_link()
    • diguyCharacter::set_apply_actor_scale_to_action_bead_xy_travel()
    • diguyCharacter::get_apply_actor_scale_to_action_bead_xy_travel()
    • diguyCharacter::set_default_weapon_sound()
    • diguyCharacter::get_default_weapon_sound()
    • diguyCharacter::set_default_weapon_sound_gain()
    • diguyCharacter::get_default_weapon_sound_gain()
    • diguyCharacter::set_weapon_munition_type()
    • diguyCharacter::get_weapon_munition_type()
    • diguyCharacter::set_weapon_horizontal_error()
    • diguyCharacter::get_weapon_horizontal_error()
    • diguyCharacter::set_weapon_vertical_error()
    • diguyCharacter::get_weapon_vertical_error()
    • diguyCharacter::set_shader_program()
    • diguyCharacter::get_recommended_appearance_shader_program_name()
    • diguyCharacter::merge_asset()
    • diguyCharacter::set_DIS_smoke_trail_state()
    • diguyCharacter::get_DIS_smoke_trail_state()

DI-Guy Version 12.5

DI-Guy Core SDK

Note that most changes to the DI-Guy API also apply to DI-Guy Scenario.

Version 12.5.4

  • Fixed hard crash when receiving a variation network packet from DI-Guy 13 that didn't match character's expected layout.
  • Orientations assigned to the camera will be applied in the order of yaw, pitch, and roll (from the perspective of an imaginary "pilot" interacting with control sticks inside the camera), starting with the camera facing along the +x world axis
  • If the camera is attached to a dolly entity and set_orientation_offset_is_relative() has been called, the orientation setting will actually be relative to the direction in which the dolly entity is facing. Otherwise, the orientation will be applied relative to the world axes, as it is normally.
  • The camera attempts to maintain the roll setting given to it through the API. Thus, the camera could be tracking a character, but tilted to one side or another.
  • Added set_orientation_offset_is_relative()
  • turned on LARGEADDRESSAWARE flag for 32-bit DI-Guy Scenario allows a larger memory footprint.

Version 12.5.3

  • Fixed a bug in diguyApp::set_num_rendering_passes() where it would not effect rendering in the graphics API.
  • Added support for two pass transparency rendering in the Graphics API
  • Fixed appearances not instantly broadcasting a PDU when character appearance changed.
  • Fixed position pop when character appearance changed.
  • Fixed hard crash when preloading appearances with legacy character types.
  • Fixed bug with handling of uppercase extensions on geometry data.

Version 12.5.2

Version 12.5.1

  • Fixed bug where customer sourced dds files failed to load because we assumed they were lz4'ed.
  • Fixed bug where files with capitalized extensions eg "FLT" failed to load.
  • Fixed bug where invalid xrefs caused parent bounding boxes to fail to register as possibly valid.
  • Fixed hard crash when drawing empty octtree.
  • Fixed matrix state glitch when drawing octtree and scene object bounds
  • Fixed path planning bug in funnel code when far above the z origin.
  • Fixed bug where browsing for a new scene object file name didn't force octtree recreation.
  • Fixed logic bug in check visibility code.
  • Fixed bug where changing appearances could cause single frame muzzle flashes and loss of character skinning matrices.
  • Fixed bug where flt files were unable to have their material edited by the character viewer
  • Fixed bug where changing character type caused all action beads to collapse on a path.
  • Added additional guide example showing differences between similar and dissimilar character types.
  • Fixed bug in built-in OpenGL renderer where fixed function mode didn't properly bind textures. Fixes textureless segmented characters rendering in Motion Editor.
  • Fixed joystick not properly loading in I-Guy mode.
  • Fixed ray testing against scaled scene objects.
  • Fixed off by one error in link combo in character viewer.
  • Fixed bug in Lua debugger. "Step over" and "Step out" buttons were not working correctly
  • General improvements to code that tests get_enabled() and get_dead() on a character, the code will now also test the character's t_out compared to current time
  • Added diguyAgentParams:set_influence_box_enabled() (and get)
  • Fixed bug with ground clamping on large scenarios.
  • Fixed performance issue with receiving props over the network.
  • Improved shadow pass rendering performance.
  • Shader cleanup.
  • Changed Graphics API shader samples to default point light #define to off.
  • Fixed crash when executing gesture that wasn't made for a character.
  • Fixed crash when loading degenerate flt file xrefs.
  • Improved memory use when decompressing many dds files.
  • diguyCharacter::set_orientation() now checks if the character has a vehicle controller and if so, it now allows the caller to hard-set the vehicle's orientation. Previously, only the vehicle controller determined this.
  • diguyCharacter::find_path() now checks if the character_type contains the substring 'vehicle' and if so, the path produced will be wide enough to allow the character to pass, based upon character's bounding-box's width.
  • Added a number of try/catch blocks to deal with running out of memory while loading extremely large scenarios.
  • Added code/UI to allow DI-Guy Scenario to unload textures when not used for a long time. Off by default.
  • Added a number of experimental diguyApp memory management functions:

Version 12.5.0

CRITICAL api changes

  • C++ callback:
    float AltitudeFunction( diguyScenario* scenario, float x, float y, float old_z);
    has been replaced with
    float AltitudeFunction( diguyScenario* scenario, float x, float y, float old_z, int * valid);
     code will need to be updated before recompiling.
  • Graphics API

New Features

DI-Guy Scenario

Version 12.5.0

  • New lighting system triggered by particle effects and weapons fire.
  • Improvements to 3d visuals for path editing.
  • Merged some subwidgets in character page.
  • Improved interactive Face Expression Editing.
  • Improved determinism of fast forward, and setting current time via the VCR UI.
  • Streamlined performance settings. Crowd Load Manager, Load Manager tabs have been phased out, settings are now located in the performance page.
  • Changing camera settings will now force a motion update on all characters.
  • Property tree UI's now have slider widgets, easier to change values interactively.
  • Labels above character's heads now autoscale and draw z-sorted.
  • Right click menu now contains a shortcut to turning on the debug label.
  • Right click on log window selection can now go to package selected or Character selected.
  • Shader UI includes the ability to edit character variation texture colors.
  • Physx library has been rewritten to use Physx 3.2, this is upgraded from version 2.8, Physx installer should no longer be needed.
  • Fixed a number of sound looping issues.

DI-Guy AI

Version 12.5.0

Graphics API Changes

Version 12.5.3

  • Fix for automatic graphics LOD switching not working in graphics api.

Version 12.5.2

  • Fix in OpenSceneGraph implementation for leaking nodes when using variation textures.

Version 12.5.1

Version 12.5.0

DI-Guy Networking

Version 12.5

DI-Guy Version 12.0

DI-Guy Scenario

Version 12.0.1

  • Added visualization option for gaze vectors.
  • Restored missing default face expressions and chain settings libraries to new.dss.
  • Added display of more callback information to the Event Mapper User Interface.
  • Fixed bugs with water shader.

DI-Guy API

Note that most changes to the DI-Guy API also apply to DI-Guy Scenario.

Version 12.0.3

  • Updated network model map for vehicles and also resolved issue with vehicles stuttering on paths.
  • Made fire and detonation PDUs use matching event ids. Added velocities to Fire PDUs. M16 velocity is used by default for all weapons but can be overridden in munition config file.
  • Fixed DI-Guy Scenario bugs in copy/paste paths, action spreadsheet.
  • Fixed minor content bugs involving missing torso on insurgent.

Version 12.0.2

Version 12.0.1

Version 12.0.0

  • In API programs shadow disks are off by default. Now the "set_draw_character_shadow_disks" setting in .dss files will be ignored. To turn shadow disks on or off an explicit call to diguyScenario::set_draw_character_shadow_disks() needs to be made.
  • Fixed diguyCharacter::agent_set_current_params_from_profile() so arguments are in proper order. Note: If you have existing calls to agent_set_initial_params_from_profile(), verify that you are getting proper behavior.
  • Added the following functions:
  • Removed the following experimental functions; should use minds instead:
    • diguyCharacter::add_state_machine_instance()
    • diguyCharacter::remove_state_machine_instance()
    • diguyCharacter::remove_all_state_machine_instances()
    • diguyCharacter::find_state_machine_instance()
    • diguyScenario::get_num_state_machines()
    • diguyScenario::create_state_machine()
    • diguyScenario::destroy_state_machine()
    • diguyScenario::get_state_machine_at_index()
    • diguyScenario::find_state_machine()
    • diguyScenario::get_num_state_machine_instances()
    • diguyScenario::add_state_machine_instance()
    • diguyScenario::remove_state_machine_instance()
    • diguyScenario::get_this_state_machine_instance()
    • diguyCrowd::all_members_add_state_machine_instance()
    • diguyCrowd::all_members_remove_state_machine_instance()
  • Removed the following deprecated functions:
    • diguyApp::set_student_log_callback()
    • diguyApp::student_log_print()
    • diguyApp::set_user_query_yes_no_callback()
    • diguyApp::user_query_yes_no()
    • diguyApp::set_user_query_text_callback()
    • diguyApp::set_user_query_item_callback()
    • diguyApp::user_query_item()
    • diguyApp::set_user_inform_callback()
    • diguyApp::user_inform()

DI-Guy AI

Graphics API Changes

  • See the 11-12 transition guide in the SDK user manual for a complete overview of the changes between 11 and 12

DI-Guy Version 11

DI-Guy API

Note that most changes to the DI-Guy API also apply to DI-Guy Scenario.

Version 11.6.0

Graphics API Changes

Version 11.6.0

Version 11.0.x

  • Added ability to hear sounds when history is enabled and time is rewound to a point midway in the sound. Note that the function diguyScenario::set_history_max_sound_instances() lets users set how many sound instances to be remembered; default is 100.
  • Updated where DI-Guy looks for its license file. It is looked for in this order:
    • file specified by the environment variable DIGUY_LICENSE_FILE
    • file specified by the environment variable BDILM_LICENSE_FILE
    • file specified by the environment variable LM_LICENSE_FILE
    • license.dat in DI-Guy installation flexlm subdir
  • Turned off character shadow disks by default when using SDK; they're still on by default in DI-Guy Scenario.

Version 11.0.4

  • Resolved issues with wheeled vehicles on paths, force_action, and resume_path
    • Problem with vehicles not resuming their path and remaining motionless after force_action("still")
    • Problem with vehicles resuming path and wheels not spinning
    • Problems with position discontinuities when force_action("still") is applied to a vehicle on a path

Version 11.0.2

  • Updated where DI-Guy looks for its license file. It is looked for in this order:
    • file specified by the environment variable DIGUY_LICENSE_FILE
    • file specified by the environment variable BDILM_LICENSE_FILE
    • file specified by the environment variable LM_LICENSE_FILE
    • license.dat in DI-Guy installation flexlm subdir
  • Turned off character shadow disks by default when using SDK; they're still on by default in DI-Guy Scenario.
  • Removed use of glCallList in materials for the Graphics API sample code and the internal OpenGL renderer. Call lists are deprecated and have more overhead then just calling material functions directly.
  • Added early out sample code for materials to graphics API; end users should now have the tools to skip unnecessary material binds.
  • Added a new geode/mesh merge as part of the bdg creation; should cut number of meshes and draw calls in half for most of the non- skinned characters.
  • Added new draw stats profiler to improve feedback on pipeline bottlenecks. Profiler now available in Character Viewer. (Press Ctrl-P a few times.)
  • Added linear draw pipeline init argument.
  • Updated Benchmark sample program with new options and statistics.
  • Fixed bug where get link positions would not take character scale into effect.
  • Added the following functions to DI-Guy Graphics API:
  • Added sample code to the OpenGL graphics API reference implementation demonstrating the use of the link local transformation matrix to simplify the number of OpenGL function made.
  • Added sample code to the OpenGL graphics API reference implementation to demonstrate using diguyGraphicsTexture::get_last_bound_texture() to minimize state changes.
  • Added the following functions to DI-Guy OpenGL rendering API:

Version 11.0.1

Version 11.0.0

Version 10.5.1

  • Removed deprecated functions:
    • diguyScenario::set_tin()
    • diguyScenario::get_tin()
    • diguyScenario::trigger_script_event()
    • diguyScenario::add_custom_appearance()
    • diguyScenario::add_custom_appearance_based_on_existing_appearance()
    • diguyScenario::add_named_callback()
    • diguyScenario::remove_named_callback()
    • diguyScenario::call_named_callback()
    • diguyScenario::set_iguy_character()

Version 10.1.7

Version 10.1.6

Version 10.1.4

Version 10.1.3

Version 10.1.1

Version 10.1.0

DI-Guy Scenario

Version 11.5.1

  • Fixed intersection test issue with scene objects
  • Fixed bogus fog changed notification
  • Improved sound history recording and playback

Version 11.0.1

  • Fixed crash with using qt_invoke without lqt loaded.

DI-Guy Motion Editor

Version 11.0.1

  • Fixed Motion Arc extended info handling.
  • Fixed issue with the poser not being available on some skinned character links.

Version 11.0.0

  • Initial support for handling skinned characters.

DI-Guy Character Viewer

Version 11

  • Added Shadow and normal previewer.
  • Added LOD picker.

DI-Guy for Vega Prime

Version 11.5.1

  • Initial support for vegaPrime 5.x.
  • fixed crash on exit using some modules.
  • Changed setScriptPerlEnable default from true to false.

Version 11.0.1

  • Initial support for vegaPrime 4.x.

DI-Guy Networking

Version 11.0.1

  • Fixed a number of bugs with transmitting gazing and aiming behavior over network.
  • Improvements to log messages.