Pages

Monday, December 05, 2016

An Overdue Post

Hey everyone.

I've neglected this blog for a while and have been focusing on my mods and content tools.

My UDK/Unreal Engine game was on hold for most of the year while I've been modding Fallout 4 and now Skyrim SE (as well as learning the ins and outs of UE4).

I'm planning to release a lot of the stuff I did for the UDK version of my game over the next few weeks since I've mostly switched to UE4 by now. I didn't plan to, but the number of things that can be accomplished using C++ and Blueprints blows what I was doing with UDK out of the water.

My Vector Field and Flowmap Editors will be getting updates in the near future to add a different way to visualize the things the tools are doing. I'm also planning to clean up the import/export functions of my vector field editor to make it a bit more robust.

My AmmoTweaks mod for Fallout 4 is almost feature-complete now. It's the most finished of my current Fallout 4 mods. At this point, it adds dozens of ammo types from previous Fallout games, weapon condition, melee attack types, and a simple crafting system for the new ammo types. The ultimate plan with this mod is to re-create most weapon-related features that were in one Fallout game or another in the past.

Personal Pack Animal for Fallout 4 will be getting an update in the near future to add support for the major DLCs and some more pack types. I'm also planning to create a 'port' of the mod for Skyrim SE.

On a final note, this blog's layout will be getting an update this month or next month or two to make it easier for me to categorize and share my work more easily.

Wednesday, December 02, 2015

Fallout 4 Ammo Crafting/Tweaks Mod

I've been spending way too much time on Fallout 4 recently, and made a mod for it over the weekend. It adds ammunition crafting and optional tweaks to base ammo types, loot and vendor lists.

Check it out here.

Tuesday, September 15, 2015

September 2015 Progress

I haven't posted anything in a while, so it's probably that time again. (I'm still at it)

After spending a few months working on tools to make creating the last bit of my UDK game prototype, Ludhermia easier, I'm back at creating content for it. Mostly weapon and armor variations and finishing up the main map at this point. There are still a couple of systems I haven't finished yet, but they are also almost there.

I've decided to treat the UDK version of Ludhermia as a feature test / prototype instead of full release, as it's taking a lot longer than expected to finish, and will begin work on a Unreal Engine 4 version by the end of the year.


UDK Game:

The crafting system still needs work, since I currently have only two crafting materials (iron and wood). The crafting system Bethesda showed off for Fallout 4 at E3 this year inspired me to expand it a bit to include a sort of modular weapon system that allows you to craft different blades and hilts (on the melee-side) and combine them. Arrow and bullet crafting is also coming along nicely, and will include the ability to place magical enchantments on them.

The melee fighting system still needs a few tweaks to make animations look more fluid (and animations for some of the newer weapon types like spears and staves), but it's mostly finished at this point. I've greatly simplified the original damage and force calculations to allow for much larger-scale fights involving dozens of AIs.

The magic system has also received a full overhaul and should be pretty entertaining after a few more tweaks. Characters need to create or find grimoires to allow the to cast different levels of spells, and each grimoire can be used to contain a limited number of spells up to a certain level. All magic is very powerful, but is balanced by having high skill and attribute requirements to cast anything. A spell crafting system that allows players to combine different spells is also in the works.

My implementation of GGX specular shading in UDK is pretty much finished, as well, and I will share it when I get a chance. It's pretty useful if you're still working on projects in UDK but don't want to fall behind on the current content creation methods (roughness and metalness(?) maps mostly).


Tools:

I spent a lot of time on my new Blender normals editor, and added a few new features like the ability to use a rotating arrow object to adjust normals manually, and a new auto-generation method that weighs normals based on the area of their surrounding faces (weighted normals). Its performance is also a lot better than the original few releases.
The Normals Editor is available here

I'm also working on an overhaul of my vector field editor for Blender, and intend to release it in the next couple of weeks.
The Vector Field Editor is available here


Hopefully it won't take me as long to write my next post. :)

Thursday, March 12, 2015

March 2015 Progress

What I'm working on at the moment:

Blender Tools:

UE4 Vector Field Editor:

The tool is pretty much finished, and I've been working on documentation over the last week. I'm hoping to have the documentation ready by the weekend, but it may stretch into next week.
I'm also considering adding presets for the particle physics settings on vector fields (water, thick fluid, and smoke for now), but may wait for a later release on that.


The tools available here, WIP documentation here. (both on Github)

Example files: (Mediafire)
    .blend
    .fga pack


Normals Editor + FBX Exporter:

I haven't integrated the changes to my normals editor with the master branch yet, but the testing branch now includes support for Mont29's excellent Blender build with custom split normals (info here).
I'm currently also testing it with the current Blender 2.74 test build, which is also working and will be included on Github soon.

Documentation for the normals editor is next on my to-do list after the documentation for the vector field editor. It will also get renamed and separated from the exporter before Blender 2.74 is out (hopefully).

Downloads:
    Master branch
    Testing branch


New project: Flowmap Editor:

Another thing I've started working on is a flowmap editor that works with hair particles in Particle Edit mode (and regular particles with forces). I'm using concepts from my vector field editor on this tool. (It's nowhere near finished yet, btw)


Game-related Stuff:

UDK:

I'm still working on the UDK version of Ludhermia, and am currently in the process of creating a new magic system with the ability to create and modify spells. I've also switched to models based on MakeHuman and created a nice IK rig to use for animating the new characters. All clothing/armor is still custom-made, but using MakeHuman to fit them to some modified body meshes.


UE4:

Still learning... and greatly enjoying the fact that it's free now :D



ArmA 2 / DayZ:

I've written a new horde system to go along with my zombie overhaul, which I may end up releasing in the near future. After lowering the polycount and texture resolution on the zombies in addition to my AI tweaks, I'm able to push 300 zombies per client without much loss to framerate (to be fair, with only 2 clients connected), which makes hordes and large cities pretty intense.


Sunday, February 15, 2015

Blender Normals Editor and FBX Exporter Progress

I'm getting close to releasing another update for my UE FBX Tools addon, and created a new branch on GitHub with my current WIP version.

Lots of work went into the new UI to remove clutter and make the tool a bit more coherent, as well as some performance improvements for auto-generation and displaying normals as 3D lines. Most of the addon also works in Object Mode now and normals can now be applied to the mesh to alleviate most of the guesswork that came with my 3D lines display approach. The copy/paste functions have been replaced by a call to vrav's Transfer Vertex Normals addon (which is required to use this feature).

I've also updated and tweaked the old 6.1 exporter and added an exporter for the FBX 2013.3 (7.3) format based on it. The new 7.3 exporter currently doesn't support animations (something I want to finish before final release) but should export everything mesh-related. (Cameras, Lights and Null objects are also not exporting at the moment). The new exporter can be selected in the export menu by checking 'Use FBX 2013'.

Both exporters also have a new feature, 'Merge Vertex Colors'. Enabling this on export will combine your vertex color layers into one in the exported file, which is pretty useful when using vertex colors as inputs for wind or other effects that can be influenced by specific colors.


The new test release is available here (Github).

Monday, November 10, 2014

Test Release - Blender UE4 Vector Fields (FGA) Tools

I've been working on this off and on for a couple of weeks and think it's ready for a public test release. It's an addon for Blender with scripts that allow creating, exporting and importing Vector fields for UE4 using the fga file format. It's my first attempt at an exporter/importer from scratch, but seems to work surprisingly well :D

The editor allows the velocities of particles in a volume to be saved after influencing the system with the different force fields available in Blender. Any type of particle simulation Blender can do can be used for this (smoke, fluid, any force field).

I'll be writing the documentation this week, but a basic how-to is available in the Readme on Github. Performance is surprisingly good considering this is written in Python and the amount of particles that the scripts can interact with. I plan to post a link on the UE4 forum after some more testing and polishing.


Download here (Github)

Usage instructions

Example .blend File

Monday, October 27, 2014

October 2014

It's been a while since my last update. I got access to Unreal Engine 4 this weekend, and spent most of it (or maybe all of it :D ) figuring out how things work. I'm still planning to release Ludhermia using UDK initially, but after looking through the new engine, I'm seeing a large amount of new possibilities for the game (I'd go as far as saying 'a mind-blowing amount of possibilities').


Some random progress updates:

Ludhermia: - It's almost fully prototyped now, and I will be showing some of the features in videos soon. Here's some stuff I got done in the last couple of months.

    * - AI faction are now able to take over areas from each other and defend their own areas.
    * - New loot system with RPG-style color coding and mostly randomized stats for each weapon/item depending on the material it's crafted from.
    * - completely reworked the inventory system, all weapons are based on 3 base classes that are parametrized to create unique stats.
    * - Dynamic pickable plants
    * - Dropped Scaleform menus/hud in favor of canvas since authoring Flash files without Flash is not economical (time-wise). Also seemed like a good idea given that Scaleform isn't included in UE4.
    * - Multi-world, multi-character, JSon-based save system is now mostly integrated. I still need to set up the player npc group mechanics to allow your other characters to join you.
    * - Treating the save system more like a database allowed me to make all loot in containers persistent. It's currently set up to generate all loot on the map on initial world save creation.
    * - Fixed an old melee attack timing issue that allowed interrupting melee attacks too quickly.
    * - Fully integrated a custom lighting material based on GGX (with metalness), created an alternative to Subsurface Scattering with better performance and DX9 support. I will be releasing the base material in the near future. The basic material setup is: (Lambert Diffuse + SSS) + GGX Specular distribution. It's close enough that when I imported my roughness/metal/etc maps to UE4, it looked good without changes.
    * - Finished lots of meshes, including some better swords, a new revolver, torches, lots of scenery props and my first batch of trees.


Blender:
    Vector Fields:
    - After playing around with cascade in UE4, I made myself a set of python scripts to allow Blender to edit and export .FGA Vector fields. They still need some tweaks, but should be finished (and uploaded somewhere) soon. It's currently based on altering particle systems with forces and saving the offsets between frames.

    Normals Editor:
    * - I'm adding some tree-specific options to my normal editor addon, as well as some general performance tweaks/bug fixes.


Arma2:
    I haven't had much time to work on my DayZ AI addon recently, but will be getting back on it before the end of the year.


I'm most likely forgetting something, but this should give you a general idea of what I've been up to and what to expect in the near future


On a side-note: I just deleted my first spam comment of this blog... I must be doing something right (or wrong, depending on how you look at it) :D

Friday, August 08, 2014

UDK Spreading Fire Actor Tutorial

NOTE: Feb 2015: I'm working on an updated version of this tutorial with better performance and flipbook-based particles.
March 2015: Updated Example Files link. 



I've been working on this off and on for a while now and think it's ready to share (but still not completely finished). It's an Actor-based class written in Unrealscript that simulates fire spreading based on a map's wind direction and the flammability of surrounding materials. It's not really a physically accurate simulation, but the effect is fun to watch and can be used strategically in gameplay.

This version works with a WindDirectionalSource actor to provide it with wind variables. In my project's version, it ties in with a weather system actor to handle cleanup and make it respond to rain, as well.

I'm including a long description of the logic for anyone that wants to implement something like this in other languages/engines.


Older video showing what this does:
Youtube

Requirements
  • DynamicEmitter_Spreading and DynamicParticleEmitter_Fire classes provided in this tutorial
  • a custom physical material property class with a variable representing flammability
  • a WindDirectionalSource actor on your map
  • a custom light function class to be assigned to the LightComponent this uses (a basic flickering effect like this (link) works)
  • a particle system for the actual fire and smoke with a parameter for the smoke's velocity over time (instructions at the end of this tutorial)
  • a looping fire SoundCue with a high radius


Code + Assets




NOTES:

- You will need to assign a PhysicalMaterial with a custom PhysicalMaterialProperty (example class is included) that includes a flammability variable to surfaces you want the fire to be able to spread to.

- By default, debug lines will be drawn to represent the path the fire is taking. This can be disabled by setting bShowDebug in LudEmitter_Spreading to false.

- The emitter is not currently placeabe in the editor, so it must be spawned in code and initialized with a call to InitSpreadingEmitters. I did it this way because the functions the emitter uses to spread and grow are not available in editor mode.

- I haven't gotten around to making the flames climb walls, but this is a planned feature that I will be adding to the tutorial when I get around to it.

- It's not currently working in multiplayer but includes some of the functions required for replication. I haven't focused much on this since my game has no multiplayer modes for now.

Logic

LudEmitter_Spreading.uc:

This actor consists of the logic required to spawn and pool the particle systems, a PointLightComponent and an AudioComponent. The light component is offset upwards a little bit to lower the chance that it will intersect with the landscape or ground meshes.

In order to start a fire, the actor needs to be spawned and initialized with a call to its InitSpreadingEmitters function to give it a Controller it will use as the instigator for any damage it causes and to initialize the variables it needs to function. The function also creates a reference to the WindDirectionalSource it finds on the map.

Once initialized, the main actor starts three timers:
ContinueSpreading – The 'main loop' that checks if another particle system needs to be created, spawns a new one if required, and calculates the new center point to move the main actor to.
RemoveFireTimer – This one will only execute once fTotalTime has been reached and starts the cleanup procedure.
UpdateWindTimer – Updates the wind direction and speed for each particle system in the pool.

The fire finds new locations to spread to with the GetNewSpreadLoc function, which is called in ContinueSpreading. This function performs traces in each direction specified in vTraceDirections and gathers the variables associated with the found spot. Before the traces are actually performed, the dot product of the next trace direction and the wind direction (with Z for both set to 0.0) is calculated. The actual traces are only performed if the dot product >= 0 to lower the amount of traces that need to be run (also to limit the spread direction to within 90 degrees of the wind's direction). If the wind's strength is high enough, a spark jump is simulated by increasing the trace distance. This is determined by a floating point variable that stores the maximum strength the wind can reach on the map (fMaxwindStrength).


The physical material of each spot is queried for its fFlammability variable, which is used in the following formula if it is greater than 0 to determine the probability of the spot being picked:

((WindDirection . SpreadDirection) + fFlammability) / 2.0

This increases the chance of fire spreading in a direction depending on how close it is to the wind's direction and is also scaled by the flammability of the spot's material.

Here are some example fire spreading distributions under different conditions. The first image represents the base chances per direction when there is no wind and the materials surrounding the actor have equal flammability ratings. The second one shows the distributions when the wind facing to the north-east and the surrounding materials have an equal flammability rating. The last one shows a more typical scenario with variable flammability on surrounding materials and NE-facing wind. In these images, the green dots represent the spot that would be picked if no simulated sparks are launched from the fire by high wind, and the blue dots represent the spot picked if a spark is launched. The wind strength in the second and third image is assumed to be at maximum.

No Wind, Uniform Material
NE Wind, Uniform Material
NE Wind, Different Materials

Each time a new spot is found, a custom particle system actor is spawned and the new center point for the current cluster is calculated (function GetNewCenterPoint). Since the main actor includes the sound and light components for the system, the actor's location is set to the new center point to line up the effect with the particle systems. As more particle systems are spawned, the sound's volume and the brightness of the light are scaled, as well. This is calculated at the end of the function CreateEmitter.


LudDynamicParticleEmitter.uc:

The custom particle system actor contains the logic to change the parameters required for the smoke's wind direction and the size of the particles emitted over time to simulated the fire's growth. The whole idea is that the particle system actor only handles the essentials for displaying the fire, all math that comes up with the values is done in the main actor.

Fire damage is handled by a collision cylinder in this class that is set to receive only touch events. A timer function damages any touching actors. My project uses a damage over time system to make damage more consistent, which I won't share at this time since it's outside of the scope of this tutorial.


 
Particle System Setup:

Dynamic changes to the particle systems used in this are handled by Particle Parameters (UDN link) that are altered in real-time by Unrealscript.

Note on Materials:
There is a strange bug that was causing particles to disappear at some viewing angles that I could only partially fix by enabling Screen Door Fade on the materials for the flames and embers, and disabling it on the smoke. This would happen on any other combination of the two, including when it was disabled on both. Changing the sorting modes of the emitters also didn't help with this.
This is not fully fixed, so you may see the flame emitters flickering when looking at them from certain angles.

The particle system I'm using for this uses four emitters, but only the first two are actually required for the wind and growing effects:


- Flames

I decided to use a different approach than the commonly used floating red smoke effect seen in most games. Since real fire is a constantly shifting, flickering mass, I decided to create particles for it that mimic this by growing and shrinking throughout their (short) lifespans. At any time, there are about 4-8 of these particles overlapping to simulate the shifting effect. Earlier versions used a custom depth bias effect to blend the flames with their surroundings, but that approach proved too expensive for larger fires with lots of flame emitters.

The material for this particle is a basic emissive sprite with a texture that contains four (in this example) fire shapes handled by the particle emitter's SubUVs. The blend mode for this material is set to Additive to create a fluid-like effect of flames being blended into one mass.

The particles should be created with a slight upwards Initial Velocity. A particle parameter (named 'ParticleSpawnSize') for Initial Size that will be altered in script throughout the emitter's lifespan (grow, then shrink) should also be included. Size by Life should be set up for the particles to grow/shrink throughout their own lifespans. Color Over Life is optional, and can be used as a multiplier to increase the intensity of the flames' color.


- Smoke Column

This emitter is going to be visible most of the time, and will have the biggest performance impact. It's also the only one that's affected by the wind's direction and strength using a particle parameter (named 'SmokeVelocity') applied to the Initial Velocity module. A Velocity/Life module speeds up the particles' X and Y axis movement while scaling down movement along the Z axis to allow the smoke to become more dense at the top of the column. The sort mode I'm using for this one is Age_NewestFirst, which gives the smoke a better illusion of volume.

The material I'm using for the smoke effect is a bit heavier on performance since it's using a custom depth biased alpha effect to blend it with the environment. The smoke's opacity is subtractive to make it look like it's dissipating instead of fading out. The material also creates a rounded black border, which is multiplied into the alpha channel to smooth out the particles' edges. The lighting model for the smoke is Unlit and the Blend mode is set to Translucent.

The texture was created by generating some tiling greyscale cloud textures with Gimp, and placing them into the RGB channels of a new texture. Only the R and G components are used in the material, and are set to pan slowly in opposite directions to add more variety.


NOTE: The following two are best limited to the first LOD since they can be pretty performance-intensive when a large fire with lots of particles from these emitters is on screen.


- Embers

This emitter creates embers flying in random directions that spin around and fade from a bright red to dark grey. It uses a very basic unlit material with a 32x32 black texture with a white streak in the center. It also uses an orbit module to create curved paths for the particles.


- Ground Smoke

This one uses the same material as the smoke column emitter, but spawns particles at a slower rate and in different directions. Particle are spawned with a random velocity on the X/Y axis and a low positive Z velocity. Size by Life is also set up to make the particles grow as they are fading.


Thursday, July 17, 2014

Ludhermia Progress July 2014 + Other Stuff I'm Working On

I'm still hard at work on my UDK project, Ludhermia.

The time cycle and weather systems are mostly finished, and I will be uploading some demonstrations of them shortly. Time and weather now play a large role in the kind of encounters created by the world, and influence characters' abilities (both player and AI).

The faction system is also getting close to finished. My AI is currently able to prioritize between taking over sections of the map, defending owned sections, and patrolling to find new areas for it to conquer. On the group level, AIs are now able to pick from different formations to use depending on the situation they encounter. On the individual level, I still need to create a cycle for different idle activities and tie it into the time/city management systems.


I'm also working on a tutorial for a spreading fire actor, as I demonstrated in a couple of videos earlier this year.

Other stuff:

My vertex normals editor for Blender is still in development, and I will be releasing more detailed documentation and some performance fixes for it soon.



I've also started work on a mod project for DayZ (ArmA 2 mod version) that aims to replace the zombie AI and visuals. All of it is based on the Walking Dead comics and Romero's zombie films, so sound and 'herding' play much larger roles. A pretty cool new feature i've implemented with this mod is giving the zombies the ability to 'smell' players based on the current wind direction and the player's wounds. Other features include a larger spawning radius, many more zombies thanks to some AI tweaks, and the ability to clear cities. It's my own (rewritten from scratch) version of a now abandoned mod I helped on a couple of years ago. More on this in the next couple of weeks when more models are finished.

Sunday, June 01, 2014

Blender FBX Tool Test Release 1


I'm almost finished with my fbx support addon for Blender. Here's an overview of features and a download link to a test release.


*Note: The normals and smoothing groups will not affect your displayed mesh in Blender, only in the exported file


*Performance Note: I've tested this on meshes with between 6 and 15000 polys. On my mid-range system (Intel i5-2500 with 8GB of RAM and a Geforce 560ti),
real-time display of normals and my custom angle-based generation algorithm are very slow on anything past 8000 or so polys, depending on the mesh's
density. Checking "Selected Only" in the display section of each tool helps, but will slow things down more as you approach higher counts. I have a
pretty good idea of why it's doing this and will try to optimize things some more soon.


I'll upload some comparison screenshots and full documentation within the next few days. More updates coming soon.



Download Link (Github)

NOTE: Feb 2015: An updated work in progress version of the editor/exporter with new features and much better performance is available in the testing branch. The documentation hasn't been updated with the changes in this build.



Features:

Editor for Vertex Normals:

    - Manual editing per poly or vertex
    - Automatic generation with several presets for different scenarios
        -- presets:
            --- Smooth (Blender default)
            --- Angle-Based (slow but customizable algorithm) - *still buggy on complex meshes
            --- Up-Vector
            --- Bent (facing away from 3d cursor)
            --- Ground Foliage (selected ground based vertices point up, everything else bent from cursor)
            --- (TBD: Edge-Based and Smoothing Group-Based)
    - Allows calculating normals for selected faces or the whole mesh *(selected is slightly bugged when using default (smooth) normals)
    - Normals can be displayed as lines for visual editing
    - copy/paste selected normals between meshes with identical vert locations (buggy/wip, but fixes modular mesh seams when it works)
    - Real-time in Edit Mode


Editor for Smoothing Groups:


    - Manual editing of smoothing groups per face
    - Groups can be displayed as numbers on corresponding faces
    - Real-time in Edit Mode


Customized FBX Exporter:


    - Can export everything from the above addons
    - Can calculate and export tangents and binormals
    - Optional support to export normals generated by asdn's Recalc Vertex Normals addon
    - UDK-specific optimiztions:
        -- b_root is now exported as root bone instead of the exporter creating a new one
        -- limited axis flip settings to things that make sense and labeled them
        -- tangents are very close to what UDK automatically generates



       
       
Installation:

drop the Blender_UDK_FBX_Tools folder into your addons folder and find it as "FBX Normals & Smoothing Tools" in the Addon manager (in the mesh category).






Usage: (for now just descriptions of what each button does

UDK FBX Tools Panel:


Export        - opens custom fbx export menu
Initialize Data - creates custom properties required for the tools to work
        - this changes into two buttons once mesh data has been created:
    - Reset - Resets custom mesh data properties to default
    - Clear - Deletes custom mesh data, disabling the editors
        - enables toggle buttons for sg and vn editors
        - which show/hide editors' menus
Match Grid     - changes the grid scale and grid subdivisions to match it to UDK's units
Debug         - Shows some mesh statistics in console (will be replaced/removed soon)



Smoothing Groups Editor:


Set  - sets selected face to the smoothing group number selected in the text box
Select Group     - selects all faces corresponding to the group number
Show Groups     - Displays group numbers overlay
Selection Only - only display numbers for selected faces



Vertex Normals Editor:

Reset - Resets custom normals to match the mesh's (Typically Blender's auto-generated normals)


    Manual Edit:
X, Y, Z     - normal direction

Face         - face index for selected vertex normal

Show         - sets above x, y, z to the current selection's normal

Set         - sets selection's normal to x,y,z

Real-Time Edit    - changing the values above will update them on selection in real time

Edit All     - moves all normals for selected vertex instead of using face index


    Transfer Normals: (buggy, don't select overlapping verts for this)


Copy     - copies selected vertices' normals to a buffer,

Paste     - pastes buffered normals to the current mesh


    Auto Generation:
Modes:
    Smooth (Default)     - uses Blender's default generated normals
    Up Vector        - every normal points up
    Bent            - every normal points away from 3d cursor location
    Ground Foliage        - selected normals (ground base) point up, the rest point away from cursor location
    Custom (Angle-Based)    - (slow) custom algorithm that calculates normals based on face angles
                - settings:
                    - Face: dot product threshold for face smoothing pass
                    - Vertex: dot product threshold for vertex smoothing pass
*currently disabled:
    Edges            - generate normals based on edges marked as sharp
    Smooth Groups        - generate normals per smoothing group

Reset First     - resets mesh data list to defaults (same as reset button) before calculating normals
Selected only     - calculates normals for selected faces only
        - Note: This works differently with Smooth (default) mode, and may be slower


    Display:

Show/Hide Normals     - enables/disables normals display and display settings buttons

Scale             - length of lines representing normals
Color             - change color of the lines
Selection only         - only display normals for selected faces


Exporter:


Axis flip -     - static mesh is default (Y up -Z forward),
        - skeletal mesh is flipped for UDK character import (Z up Y forward)

Smoothing -    - Off :     - no smoothing is written (probably not a good thing for game-related meshes)
        - Edges:     - edge smoothing - (part of defaultss, also not good for games)
        - Face (Default) - Blender's default smoothing approach is used (0=flat,1=smooth)
        - Groups     - export smoothing groups created by this addon

Normals        - From Editor     : Writes normals generated by Vertex Normals Editor
        - asdn's Addon     : Writes normals generated by asdn's Recalc Vertex Normals addon
        - Default    : Blender's automatically generated normals

Tangents + Binormals - calculates and exports tangents + binormals from provided normals
        - * triangulating the mesh before editing and exporting may make these more accurate, but is not required


(the rest are the same as the default exporter)



Settings for proper importing into UDK and xNormal:

UDK:

Skeletal Mesh with Custom normals:
    export with Tangents + Binormals
    check Import Tangents
   
Static Mesh with custom normals + udk-generated tangents:
    export with or without Tangents + Binormals,
    uncheck Import Tangents,
    check Use Explicit Normals

Static mesh with custom normals + tangents:
    export with both,
    check import tangents
    Explicit normals not required

Either one with Smoothing groups - UDK generated normals:
    export with Smoothing set to Groups,
    uncheck import tangents,
    (if static) uncheck Explicit Normals
    *Note: smoothing groups from this addon currently don't work with xNormal, so this part of the addon is currently experimental.



xNormal:

With custom normals:
    - smooth the mesh (or set 1 in smoothing group editor if using it),
    - export with Tangents + Binormals checked,
    - smoothing set to 'Groups' or 'Face'

With Smoothing groups:
    - set up the groups
    - export with Smoothing set to Groups
    - any normals setting will work for this




NOTE:
Exporting tangents requires matched uv coordinates for each vertex (or there will be an error message), so if you made any changes to the mesh after unwrapping uvs (splitting edges, merging verts, etc), do the following in Blender's UV editor:

Select all UVs, then use
UVs -> Seams From Islands
UVs -> Pin
UVs -> Unwrap
UVs -> Unpin

Thursday, May 29, 2014

Blender FBX Tool Progress #2

Looks like I somehow managed to sync my addon's calculated tangents to UDK (and by extension, xNormal)  :D

I'm adding a couple of more features to the vertex normal editor part of the addon and optimizing things here and there, but it's pretty much finished. Hopefully, I'll have a test version on Github within the next day or two.

Sunday, May 25, 2014

Blender FBX Tool Progress

Here are some screenshots of the smoothing groups and vertex normals support addon I'm creating for Blender optimize its fbx support for UDK:


Vertex Normals Editor:






Smoothing Groups Editor:



FBX Exporter:




I'm still ironing out some bugs, but it should be done pretty soon. Then can get back to working on my game (with improved workflow :D ).

Thursday, May 22, 2014

Blender - UDK Smoothing Groups Support test release

-- EDIT (Nov. 2014): The smoothing groups addon had some problems with most applications besides UDK, and I ended up removing it. I'll probably revisit the idea at some point. The FBX exporter is still being updated. --


old post:

I've spent the last couple of days working on this and I think it's mostly ready for testing. This version if from last night, I've actually added some more features and fixed some things since my initial upload, but here's an initial testing version:

-- link removed --

The other addon is an fbx exporter with UDK optimizations and support for smoothing groups created by the above plugin and custom vertex normals as described in my last post:

Github - Blender UDK FBX Exporter


Proper documentation and updates will be up soon.