Note: The following tutorial guide was created by Supercool/SuperFromND. Full credits to him for this. I'm just reposting for you all to use here:

As I'm sure some of you are aware by now, Ikemen GO recently started experimenting with support for 3D-model-based stages. If you're reading this, then that means 3D stage support has now been made available in the nightly builds! This is something I'm very excited about (if the sheer length of this post is any indication) and I'm eagerly anticipating to see what bonkers things the community can create with it. However, I also imagine many of you aren't very familiar with anything 3D, so I figured it'd be a great idea to share some of my knowledge and advice with Blender, hence this guide.

This guide is intended to help people get to grips with this new way of making stages, covering both how 3D stages work in Ikemen and a crash-course on how to use Blender to create them from scratch. My explanations on Blender are not going to be as comprehensive as many others available online, but hopefully it's good enough to get you folks started!

Table of Contents

• 
  Background Information
  
• 
  Limitations
  
• 
  Getting Started
  
• 
  How to Blender
  
  • 
    Object Mode
    
  • 
    Edit Mode
    
  • 
    Materials
    
  • 
    Textures
    
  • 
    UV Mapping
    
  • 
    Modifiers
    
  • 
    Animation
    
  • 
    Vertex Colors
    
  
  
  
• 
  Preparing for Ikemen
  
• 
  Baking Animations
  
• 
  Skyboxes
  
• 
  Baking Lightmaps
  
• 
  Exporting to GLTF
  
• 
  Using GLTFs in stages
  
• 
  Troubleshooting & Common Blender Questions
  
• 
  Miscellaneous Tips
  
• 
  Further Reading
  
• 
  Special Thanks
  

Background Information
Since the dawn of M.U.G.E.N, stages have been made using two formats: a .DEF file, and a .SFF file. The .SFF contains 2D graphics data, while the .DEF specifies stage boundaries and dictates where these graphics are to be placed in a 2D space. While you could always use parallax to give stages a sense of depth, and some very clever tricks have been devised over the years to give the illusion of 3D, stages have always ultimately remained as two-dimensional images.

Recently, Ikemen GO introduced the ability to use a 3D model instead of placing 2D graphics. These 3D models use a format called GLTF (extension either .gltf or .glb); this format is relatively new, but it's completely open-source, standardized, and easy to create and export to using programs like Blender. GLTF is already being adopted by many other projects, including the Godot game engine, and its nature means you can have the entirety of a model: mesh, textures, animations, everything: all in one file, just like a .SFF would, making it ideal for stage distribution.

3D stages come with quite a few inherent benefits. On top of just looking really nice, 3D stages are not restricted to one particular resolution, and can look nice and crisp whether you play at 480p or 4K. Depending on the scene, 3D stages can also potentially offer massive reductions in file size compared to a 2D-conversion-of-a-3D-stage; I was able to make a conversion of a Marvel vs. Capcom 2 stage that can fit on a floppy disk. Naturally, this also opens up a whole planet of possible new stage ports from other games that wouldn't have been easy or possible otherwise; I've already experimented with porting areas from a few different Dreamcast and GameCube/Wii games, and I'm sure others will follow suit porting from other games shortly after this guide goes live.

Limitations
Ikemen's implementation of GLTF is fairly simple at the moment, and lacks support for some common elements that might be found in other implementations. Specifically:

• 
  There is no direct support for light objects or environment maps. However, you can get around this by pre-rendering (or "baking") your lights beforehand and creating a skybox respectively; we'll touch on this later.
  
• 
  Related to the above, Ikemen does not currently use any part of a material other than the color map, so no roughness, metallic, specular, normal, emission, etc. are displayed.
  
• 
  Armature deformations/weights are not supported. This means that, while models with armatures will be drawn, they won't animate and will most likely default to their base pose.
  

It's entirely possible these limitations can be addressed in the future. If you happen to know 3D graphics programming and how to program in Go, and want to help improve our 3D support in Ikemen, consider visiting our Github and making a pull request!

Getting Started
As of the writing of this guide, the latest stable version of Ikemen GO is version 0.99. Future stable versions should include 3D stage support by default, but for now, you'll need to download the latest nightly builds of Ikemen GO to get support for 3D stages. The nightly build changes every day whenever code changes are made to Ikemen, so it's not as stable or as widely-tested as release versions like 0.99 and features may change or break at any time. Please keep this in mind when designing stages with it!

If you're looking for 3D stages to try this out with (or you just want a complete example), I've created a stage titled Third Heights and I'm releasing it under MIT, same as Ikemen GO itself. I've already submitted a PR for this stage to be included in future versions of Ikemen GO, so it should be available directly from there soon. I'm also planning to create a releases thread for any future 3D stages I create, same as many others here on the forums, so keep your eyes out for that!

Now for creating 3D models; there's quite a lot of programs out there to create and edit with. Here's what I recommend:

• 
  Blender: A very well-known free and open-source 3D modelling program. This is what I'm going to be using for this guide, and it's most likely what you'll want to use unless you happen to have a copy and familiarity with other programs like Maya or 3Ds Max. I'm using version 3.4 here, but the general workflow should be more or less the same across all versions past 2.8. [Editor's note: Blender 4.0 released right in the middle of me writing this guide, so if the UI looks slightly different for you than what I'm showing here, that's why!]
  
• 
  Rodzilla's Material Maker: Also free and open-source, this program makes it easy to create procedural, seamless textures for use with 3D models. I used it to create the textures in my original stage, Third Heights.
  
• 
  If you don't want to make your own textures from scratch, ambientCG.com has thousands of textures available as CC0/public domain, mostly photoreal ones. Ditto for polyhaven.com. I'd still recommend making your own if you can though!
  
• 
  Either GIMP, PhotoShop, Paint.net, or some other image editing program. Not strictly necessary, but it's very handy to have on hand for editing textures.
  

Note that if you're wanting to rip a stage model from an existing game, that is well beyond the scope of this guide and I won't be covering it in much detail (as it varies wildly from game to game and requires some pretty intricate technical knowledge). You'll want to check The Models Resource or search for ripping tools for the game or the system(s) it was released on for info on that, if you're up for it.

How To Blender
If you already know how to use Blender, you can skip ahead to the section Preparing for Ikemen, as the next several sections are going to cover the basics of how to do basic, common things in Blender.
For the rest of you... get ready for the mother of crash courses.

I originally had a giant section here explaining how to use Blender but it turns out MFG kept rejecting my post presumably due to length.
You can find the How to Blender sections split into two parts here and here in that order. Sorry for the inconvenience

Preparing for Ikemen
Okay, now that I've given all the newcomers a crash course on how to use Blender (or at least a subset of it), I can FINALLY start talking about the fun stuff specifically for Ikemen. As will become evident in a second, from this point on I'm assuming you have decent knowledge of how Blender works, beyond what I've covered here already.

First off, make sure that the origin of the world (coordinates {0, 0, 0}, where the grid axis lines all intersect) is aligned with where you want the fighters to be standing. If you need to adjust the position of the scene, hit A to select everything, then G to move it into place. This part is pretty crucial, so make sure to get it right!

Next, make sure the scene itself is oriented properly. If you press Numpad 1, you'll be looking in the direction that Ikemen's 3D camera will be looking towards. Make sure your scene looks correct when viewed from this direction, rotating the mesh if necessary I recommend pressing A, then R, then Z to lock rotation to the Z axis, then rotating it until it looks how you'd like.

Finally, and this isn't as important (as you can adjust the scale of the model in the .DEF later), I'd also recommend scaling the stage to a reasonable size when possible. "Reasonable" is subjective here, but I generally like to keep stages within a roughly 8x8 grid of Blender's "large" grid squares when viewed from above and at a medium-distance zoom. This isn't a hard and fast rule, but it's something I like to do for consistency's sake across various stage models and to make it easier to adjust stage size. The procedure's pretty similar to rotating and moving: A to select all, S to scale up and down, hopefully you get the idea.

Here's an example of what it should look like when its aligned properly and scaled to a reasonable degree:



Baking Animations
For the most part, animations should just work as-is, but I've ran into some interpolation issues when exporting animations involving keyframes beyond the start or end of Blender's animation frame range. The solution (warning: this is not reversible, so make sure your animation's how you want it first!) is to go to the Animation workspace, select your keyframes, and then press Shift+Alt+O to sample the keyframes. This essentially "bakes" their animation data by creating a keyframe on every single frame (indicated by blue dots), which allows it to export properly. You may need to manually remove keyframes beyond the animation frame range if you're still having problems, but other than that, it should work after doing this!



Skyboxes
As mentioned above, Ikemen does not directly support light objects, and that also includes the environment map. This means, if we don't want a pure black background, we must simulate an environment map using an old-school approach: the skybox (or skysphere if you want to be fancy and use a sphere, but most people still call it a skybox either way). A skybox is a big mesh (usually a cube for performance reasons, but a sphere works great too) that goes around your entire scene and typically has flipped normals, allowing you to look through it on the outside.



To create a skybox, press Shift+A to create a new cube or sphere, then switch to Edit Mode and scale it up to fit over the entirety of the scene. Now press Alt+N (or use the F3 search menu) and look for an option called Flip; click it to flip the mesh's normal direction. Assign it a new material, give it a sky texture, unwrap it so it looks nice, and then here's the important part: in the Material Properties panel, scroll down until you see the Settings section. In there should be a checkmark toggle labelled "Backface Culling"; enable it and you should now have a functioning skybox!

Optimizations
Performance is something I value quite a bit, and user-made 3D content in other games have a reputation for not being optimized very well at all (see: VRchat), so I wanted to share some tips for optimizing your scenes for Ikemen, whether to improve performance or cut down on file size. I strongly recommend taking these into consideration if you want to create 3D stages, as the better optimized your stages are, the more people that can actually use them on lower-end hardware. You can use a site like gltf.report to analyze your exported file and see what portions contribute to file size and performance.

One big one is to combine your textures into what's called a texture atlas: basically one gigantic texture (or rather material, thus muitple textures) that all of your meshes use at once. This performs much better since the engine (not just Ikemen, but *any* 3D engine) doesn't have to sift through tons of different materials one-by-one. Blender doesn't have a native way of doing this, but there's an add-on that I've used for doing this, and it's really easy to use. After installing it, just press N, head to its respective tab in the sidebar, then click Generate Material List, then Save Atlas To.... Your mileage may vary depending on the scene, though it usually works fine.

Another one is texture resolutions: Don't be afraid to lower the resolution! Textures are by far the largest contributor to file size, so reducing the texture size is pretty much always worth a try, especially if the percieved difference in quality is minimal. I would recommend removing your roughness and metallic maps before exporting as well, since Ikemen doesn't actually read them at this point in time; thus, including them with an exported model will do nothing other than increase its file size with no real benefit.

If you're using a lightmap and your exported file comes out absolutely gigantic, you may want to strongly consider exporting the lightmap's texture and converting it into a JPG file. This will create some minor visual artifacts, but it will also DRAMATICALLY reduce file size on busier lightmaps. (Case in point: I had a roughly 100MB lightmap file in PNG format that, after converting to JPG, only took up less than eight MB!) Blender itself can do this format conversion automatically on export by going to Data -> Material -> Images and setting the texture export format to JPG.

Another tip: the actual mesh geometry itself is pretty tiny already in terms of file size, but it's probably a good idea to try removing any geometry that would not be visible to begin with: the backside of objects that are always facing the camera and the faces of a skybox behind the camera are good candidates for this. This has the added bonus of giving you some precious UV space for baking lightmaps. Speaking of which...

Baking Lightmaps
I want to stress: this part is entirely optional, and as you're about to find out, potentially very tedious and time-consuming to do, but worth it for the improved visual quality in my personal opinion (a great saying I heard in the 3D community and also just a good tip for art in general is "90% of art is in the lighting"). I would only recommend doing this if you are paitient and are savvy enough with Blender that you know how to use the node editor and how UV maps work.



Baking your lights means to pre-render your lights onto a new texture map, which is then applied back onto the models, giving you the visual benefits of lighting without having to require the computer to actually calculate said light in real time, which saves a ton on performance. This technique is very common in games, used in everything from Half Life Alyx to Quake to Mario Kart. It's also the only way to get lighting detail out of Ikemen right now, as there's no support for light objects directly at this point in time. Unfortunately, as you're about to find out, it's a pain to do in Blender.

The following instructions are an abbreviated version of this article on Blender Knowledgebase, which is where I learned how to bake lightmaps. If you run into issues, check that page.

So first, you'll need to open the Node Editor tab and add a new Image Texture node to an object's material, with the node not being connected to anything else. Create a new image (the name doesn't matter but I usually call it "Lights" or "Lightmap"), and set the resolution of the texture to a high power of two (I usually use 8192x8192 as that's a good compromise between quality and performance). In the Object Data properties (that's the green triangle tab), create a second UV map and connect that second UV map to the Image Texture node using a UV Map node. Make sure to also select said second UV map if it isn't already, as this will become important in a second.



Now you need to add that same Image Texture node to every single material whose lighting you want to bake, along with creating a second UV map for each object whose lighting you want to bake. You can make this process slightly less tedious by converting all your materials into an atlas (see Optimizations), but it'll probably still take quite some time.

Once you've done that, select all the objects you want to bake, switch to the UV Editing workspace, and enter Edit Mode. Press A to select the entirety of the meshes for all the selected objects, then press U to bring up the UV menu. Select Lightmap Pack and set the image size to the same size as your new texture from earlier. The margin value is kinda hard to explain and you might have to trial-and-error it depending on your meshes, but I generally go for 0.15 to 0.2.



Once your lightmap UV is set up, you must now head back to the Node Editor. Make sure the Image Texture node with the lightmap texture is selected, then go to the Render Properties tab (the gray camera icon) and change your render engine to Cycles. Make sure to set the Device to GPU Compute (as this will dramatically reduce the time it takes to bake), and make sure to disable the Denoise options, as not doing so will result in weird artifacts on the edges of every face of your baked lightmap (I found this out the hard way).



Now that ALL of that preamble is done, save a backup file of your Blender scene, then you can finally scroll down to the Bake section and click Bake. Depending on your hardware, the size of the lightmap texture, and the number of objects/materials you're baking... this could take quite a while. My original Third Heights stage took roughly 8 minutes on an RTX 3060 Ti to bake an 8192x8192 lightmap, so if that gives you any idea of how long it'll take on your scenes, there you go.

Once it's done, you'll then need to set the lightmap UV map to the rendered UV map (meaning the little white camera icon should be enabled for it) for every object, connect the Image Texture node to the Material Output (or Principled BSDF, but preferrably Material Output), and then you should be able to export the model with your shiny new baked lightmap. If it still defaults to the old UV map and your exported scene looks like a garbled mess, you might need to delete the old UV map entirely to get it to export properly; I'm still a bit confused on this myself, frankly.

Exporting to GLTF
So now that our model's all prepared and ready to go, it's time to export your creation! To do that, go to File in the menubar at the top of the screen, then under Export, click GLTF 2.0 (.gltf/glb).



A window will pop up asking where you want to save, and on the right will be some parameters you can adjust if desired. If your scene uses Modifiers, make sure to go to Data -> Mesh -> Apply Modifiers and enable it. Aside from that, the default settings are plenty good for most scenes, so navigate to where you'd like to export the file and click Save. The resulting file should, by default, be a self-contained .glb.

It's a good idea to verify everything looks how you'd like first by viewing your exported model file. If you're on Windows 10, you can view the .glb file directly using the built-in 3D Viewer application. Otherwise, you can use web-based tools such as this one from Khronos Group or the aforementioned gltf.report.

Using GLTFs in stages
So now we finally have our model file, it's time to put it to use! I'm not going to go into detail on how stage .DEFs in general are written, as there are countless guides for that already both here on Mugen Fighters Guild and elsewhere online; for the most part, it's identical to how you'd usually make a stage. However, I will highlight the new stuff needed for 3D stages to display.

The first new parameter is called fov, and it goes under the [Camera] section. This controls the field-of-view of the 3D model. I personally set mine to 30 as that's what Blender uses by default for its camera, but you might want to experiment a bit.

Code:

[Camera]

; (insert other camera parameters here)

fov = 30

The next one is in the [BGdef] section, where you would define the SFF file the stage uses. The SFF is still required to be included by spec (although outside of another Ikemen feature, stage portraits, the contents of the SFF don't really matter much). You can use the parameter model to specify the filename of the model, in a similar way to spr for the SFF:

Code:

[BGdef]
;Filename of 3D model file
;Supported file types are gltf and glb. Texture types supported are PNG and JPEG, no DDS.
;Make sure the world origin of the model is at the camera starting point!
model = stage3d.glb

;Filename of SFF file, required by spec (and for stage portraits!)
spr = stage3d.sff

Finally, to actually use the model in a stage, a brand-new [Model] section has been defined, with the following format:

Code:

; Model element definition; this is similar to the [BG] blocks in 2D stages
[Model]

; X, Y, and Z coordinates of the model
; X = horizontal, Y = vertical, Z = depth
offset = 0, -0.25, -1

; Scale of the model
scale = 0.5, 0.5, 0.5

You may need to tweak the position and scale quite a bit to get it looking correct; a pro tip from me is to use Shift+F4 in Ikemen GO to reload the stage's files without having to restart the entire game, making it easier to test changes.  I recommend creating a temporary plane at {0, 0, 0} and rotating it 90 degrees on the X axis (so that its facing towards the camera) to make it easier to set your offset values correctly.

If your stage was aligned correctly in Blender, you shouldn't need to adjust the X offset much at all. The Y offset I usually keep somewhere around -0.2. As for Z offset, I usually set its value between -0.75 and -1.5, though you might need to dial this value in if you notice your model/characters are moving "faster" than they should. Also, quick note: do not set the Z offset to 0, as otherwise the model's geometry will not move at all. Likewise, setting it to a positive value (above 0) will cause the geometry to move inversely to your characters.

Once all of that is done though, congratulations: You now have a 3D stage in Ikemen! :)



Troubleshooting & Common Blender Questions
This part compiles a bunch of common questions I've been asked when helping out others with Blender stuff, and is probably of good value to you folks too!

How do I get transparent textures to display right?
Go to the Node Editor workspace and make sure the Image Texture's Alpha output is connected to the Principled BSDF shader's Alpha input. Then, go to the Material Properties of the material with the transparent texture, and make sure to set Blend Mode to Alpha Clip. You might also need to toggle Backface Culling depending on the model.



How come my model's faces look weird and 'inside-out'-y?
This usually means your model has its normals flipped or otherwise not set correctly. The fastest way to fix it is by selecting the entire mesh in Edit Mode, pressing Alt+N to bring up the Normals menu, and then clicking Recalculate Outside. Blender has a built-in Viewport Overlay option (it's in the down-arrow button next to the icon with the two circles) to display normal orientation as well; blue is facing outside and red is facing inside.



What are some good sizes/model stats for a stage?
In terms of file size: all of the stages I've made so far rarely exceed a .glb size of 20 megabytes. Whether or not that's feasible for your stage depends on what it is and how much detail you want to include; admittedly mine are rather simple in terms of composition, but still. If you feel like your stage's file size is too large, try some of my Optimization tips above.

In terms of geometry/tri counts: I usually try to keep my stages around the 10,000 to 30,000 tris range. That puts it somewhere between a late Gamecube and early Xbox 360 game in terms of mesh detail; this might not sound like much, but a general rule of thumb is that textures carry much more detail than the underlying mesh itself does, so higher poly counts won't really give you much benefit after a certain point.

Speaking of textures, unless you're using a lightmap, my textures for stages don't usually exceed a resolution of 1024x1024. This makes sense as I imagine that most people playing Ikemen are probably not playing at a high-enough resolution for 1024x1024 to seem 'low-quality' (especially since the texture isn't going to be seen at its native size, but rather distorted onto a 3D mesh, thus you'd only be seeing a fraction of its actual resolution).

Why is my 3D stage rendering as solid black?
This can be a few different things. First, make sure you're using a version of Ikemen GO that actually supports 3D models (as of this writing, that means specifically the nightly builds, not 0.99). Secondly, if it's a stage/model that you've created:

• 
  Make sure that, when exporting from Blender, your image texture is connected to the Principled BSDF node's Base Color input, which is in turn connected to Material Output. Any other BSDF input, such as Emission, won't render anything in Ikemen.
  
• 
  Make sure that your stage's position and scale is appropriately set in either Blender or Ikemen GO, preferrably the former.
  
• 
  Make sure your model's normals are facing the correct direction.
  
• 
  Make sure that your .def file is correctly pointing to the filename of the .glb file you exported, and make sure said .glb is in the correct file location.
  
• 
  If you added vertex colors to an object, check and make sure they aren't all set to black, as for some weird reason that's what Blender defaults to for the default vertex color.
  

I'm getting a huge error about nil pointers! What did I do wrong?
As of right now Ikemen GO will crash if a model includes an object that has no materials assigned to it. Make sure that all your objects have at least one material!


Another common cause is when authors erroneously remove or otherwise not include an SFF in addition to the GLTF file. This will cause Ikemen GO to crash due to a missing SFF, so make sure to include one! I'd recommend using the opportunity to make a stage portrait (sprite 9000, 1 in the SFF; you can check Ikemen's included stages as reference for what it should look like).

Miscellaneous Tips
This part is pretty much just some useful tips I've accumulated that might be good to know. I haven't organized this section, so prepare for subject whiplash!

• 
  Pressing Shift+Tilde toggles a mode that lets you control the viewport camera using WASD-style controls like a traditional 3D game. This can be useful for inspecting a scene more easily than the usual camera controls in Blender.
  
• 
  If you're working on a cartoony, vibrant scene (or importing from an existing game) and notice it looks kinda washed out compared to how Ikemen renders it, try going to Render Properties -> Color Management -> View Transform and set it to sRGB instead of the default of Filmic. Filmic is intended for photorealistic scenes, and sRGB is what used to be the standard before Filmic came along. This shouldn't affect the actual exported model's look; just Blender's preview of it.
  
• 
  If you're struggling with UVs, a shortcut you can take is to select the faces whose UV you want to change in Edit Mode, then use Project from View to project the UVs from the viewport back to the UV editor. Depending on the context, this can be a MASSIVE time saver.
  
• 
  If you press Ctrl+A, you can apply the current position, rotation, and scale of the object to the mesh directly. This will also reset the pivot point of the object. If you're getting weird looking results when animating a mesh, try using this first!
  
• 
  Pressing N brings up a sidebar menu in the viewport which has some useful parameters. If you have the Material Combiner add-on installed, this is where you can go to use that addon, which I recommend doing when preparing your scene for exporting!
  
• 
  If you need to select a continuous line of faces in Edit Mode, try Alt+Left Clicking to select an entire loop of edges or faces. This can save you quite a lot of time!
  
• 
  The Edit Mode key for extruding a face is E, but you can also press Alt+E to get a menu to extrude along a face's normals or to extrude all faces individually. Also very handy!
  
• 
  If you're editing a trio of parameters all at once (such as an object's scale), you can click-and-drag across all three of the number sliders and edit all three of them simultaneously.
  
• 
  When you're transforming an object (whether that be rotating, moving, or scaling), you can actually type a value during the transform if you want to quickly dial in an exact value. For example, S -> 0.01 will scale down an object to exactly 1/100th of its size.
  

Introduction to Blender

If you're totally new to Blender, in addition to what I've written here, I would highly recommend either Blender's 2.8 Fundamental series or BornCG's Let's Learn Blender for rundowns and tutorials that cover more and are almost certainly better written than what I've got here. Throughout the next several sections, I'll be walking through the process of creating a basic stage.

First, let's rattle off some basic, useful controls in Blender that you'll be using all the time:

• 
  Left click selects objects, and right click brings up a context menu.[/li]
  
• 
  Hold Middle click to rotate the camera around the pivot point. Add the Shift key to move around the camera. For those on laptops or otherwise lack a middle mouse button, you can use the icons in the top-right to manipulate the camera instead.[/li]
  
• 
  G lets you move an object around, S scales an object, and R rotates an object. In the case of R, pressing it a second time toggles between rotating relative to where you're looking at it from and rotating it track-ball style. Once you're done, Left click to apply your change and Right click to cancel it.[/li]
  
• 
  Pressing X, Y, or Z lets you lock movement to that particular axis. Add the Shift key and you can lock multiple axises at once. For example, G -> X -> Shift+Z locks movement to the horizontal plane.[/li]
  
• 
  Tab switches you between Object Mode and Edit Mode.[/li]
  
• 
  Numpad keys 1-9 will orient the view onto a particular axis. Numpad 5 will toggle between orthographic view and perspective view, and Numpad 0 toggles the render camera view (not useful for our purposes).[/li]
  
• 
  Numpad Period moves the pivot point to the currently selected object; whether that be the actual object or a particular vertex/line/face you have selected.[/li]
  
• 
  A selects everything in the area the mouse is currently hovered over. Usually this selects all objects in the scene, but it depends on context.[/li]
  
• 
  Shift+A brings up a menu to add objects to the scene. We aren't going to use it in this rundown, but it's very useful to know![/li]
  
• 
  F3 brings up a search bar for all kinds of functions, usually relevant to whatever you're currently doing. If you're struggling to find a specific option or setting, try to use this![/li]
  

That was a lot of words just now, but I promise it really isn't that bad once you get used to it. If you're completely new to Blender, I'd recommend spending some time just messing around and getting acquainted.

Object Mode
Blender works off the concept of "modes", and there are two main ones you'll be using.
Object Mode is what you start in by default. In Object Mode, you can manipulate "objects", which can be meshes, lights, cameras, and other things like that. Let's create a platform for our fighters to stand on.

Now, when you start Blender, by default you already get three objects: a Camera, a Light, and a Cube. It'll look like this:



Since it's already there, we're going to manipulate the cube into a platform. Left click the cube to select it; you'll see it gets a bright orange outline and be highlighted in the Outliner on the top-right of the screen. Press G and you should now be able to move the cube around.

We want our platform to be nice and evenly aligned to where the fighters are going to be standing (the grid, or positions [0 ,0 ,0]), so press Z to lock the cube's movement to just the vertical axis (you'll see a blue line appear to indicate this). Move the cube down until it is below the grid and Left click to apply your movement. Don't worry if it's not exactly positioned, you can adjust the values more precisely using the Object Properties pane.



On the middle-to-lower-right side of the screen is a bunch of small tabs of various colors; the orange box with four lines is the Object Properties panel, which you can use to change the exact values of the position, rotation, and scale of a specific object. Click on the Location Z value and set it to -1, and the top of the cube will be exactly aligned to the bottom of the grid.



So now we have a platform, but it's pretty small! Let's fix that by editing the cube.

Edit Mode
Edit Mode is the other main mode in Blender, and it lets you manipulate the vertexes, edges, and faces of objects.

With our cube selected, press Tab and you'll switch to Edit Mode. You should see all eight corners (the vertexes) change to orange, and the entire mesh should be tinted slightly orange as well. We're going to use Edit Mode to make our cube into a wide rectangle, which is far more practical for battles to occur on.

This is the first part where you'll need to be specifically mindful of Ikemen: you'll need to orient your scene in the correct direction. Press Numpad 1 to align the viewport; you should see a red line going horizontally and a blue line going vertically. This is the direction that Ikemen will default to when rendering a 3D stage, so it's best to make your scene with this direction in mind.



Now that we're oriented, make sure that the cube is still selected (you can press A to select all of the cube's verticies if you need to), then press S to begin scaling the cube, in a similar way to how we moved it in Object Mode. This time, we're going to lock scaling in the horizontal axis, so press X to restrict scaling to that axis, then drag out the cube to a decent length and Left click to confirm. A little box will appear in the bottom-left with the values of your change if you want to dial it in, I recommend a value of 4.0, but feel free to adjust it to your liking.



At this point, you should have a rectangle that's wide on the red X axis, and whose top face is aligned to the bottom of the grid. Now it's time to make it look pretty by giving it a material.

Materials
Materials are what tell Blender (and by extension Ikemen) what a given object should look like: what color it is, how "rough" its surface is, what direction light should travel on its surface, whether or not it's metallic, and some other niche prorperties beyond the scope of this guide.

A material consists of one or more textures, a 2D image wrapped around the model like a decal. To define which parts of the texture go where, your model needs to be unwrapped;which is to say its faces (or collections of faces, which Blender calls an island) need to be assigned to different areas of the texture. The way in which these areas are laid out is called a UV map; most of the time, models only have one of these for a given object.

Before you do anything, first go to the top-right of the viewport (the part of the screen that shows your 3D scene) and look for the four ball buttons. Currently, we're viewing our scene in Solid mode, which will show every object in a gray color. In order to see our materials, click the icon with the black-and-white checkerboard ball to switch to Material Preview mode. (Pro tip: you can also pressZ to get a quick menu to switch between these preview modes, which is quite handy!) Your cube should turn from grey to white when doing this.

Over on the right panel where Object Properties was located earlier, there's a red checkerboard ball icon, click it to bring up the Material Properties tab. The cube should already have a material by default, but if for whatever reason it doesn't, click the + button to create a new "material slot", then click the "+ New" button to actually create a new material.



Now you should see a giant wall of sliders and numbers to mess around with. This looks initimidating, but in practice you'll only be using a subset of these options; the rest are for niche edge cases and funkier materials that aren't important for us. For right now, let's just worry about the most important option, which is Base Color.

By default, the cube is colored white. If you click on the white rectangle next to Base Color, a color picker will appear. You can use this to set the color of the material, evenly across its entire surface.



That's cool and all, and sometimes that's all you need, but obviously a material isn't usually one solid color. Time to talk about textures.

Textures

Textures are exactly what they sound like: 2D images that are used to define the colors on the surface of a material. Currently, Ikemen supports PNG and JPEG textures;. PNG is recommended for its high quality and alpha channel support.

Modern game rendering techniques typically follow a format called physically based rendering or PBR; I'll spare you the nerdy details as to why (see this article courtesy of Adobe if you're curious and/or want something long to read and pass time), but this means a material will usually have three textures:

• 
  Base Color is called a lot of different names depending on who you ask, but I'm gonna call it the Color Map for the rest of this guide. Some other common names for it include the Albedo Map, the Diffuse Map, and (confusingly) the Texture Map. Whatever you call it, this the main texture that defines the actual colors on the surface of the material, and the one you want to focus on looking right first.[/li]
  
• 
  Roughness defines how rough a surface is, with lower values giving you a glossier look for things like plastic and glass, and higher values giving you a harder look for substances like concrete. This map is grayscale, where black is interpreted as 0, white is interpreted as 1, and grays are in-between.[/li]
  
• 
  Metallic defines whether a surface is metal or not, and thus reflects light differently than normal, non-metal materials. Like Roughness, this map is also grayscale, but it's sometimes just a single value if there's no reason to have certain areas of the texture be metal or not-metal.[/li]
  

Like I said earlier, Ikemen only supports the Color Map at the moment, and if you don't plan on baking lights (see Baking Lightmaps) then you should only worry about that one (as including the other maps will do little more than unnecessarily bloat your exported model's file size).

There's a lot of different ways textures are created; sometimes they're taken from a library of premade ones (whether that be a public library like ambientCG or an internal one used by a given company), sometimes they're generated procedurally using tools like Substance Designer or Material Maker (see Getting Started), sometimes they're generated from a higher-quality model in tools like Zbrush, sometimes they're painted onto the model directly... the list goes on and on.

For the sake of pacing (and my own sanity), let's just assume you already have texture files ready to go.

You might have already noticed the colored dots next to each of the parameters in the Material Properties tab. These dots are actually part of something in Blender called nodes, which allow you to fine-tune the specifics of how a material's shading works. I won't get into detail on nodes here as they aren't especially important for this guide, but the reason I mention this is because we need to use them very slightly for applying a texture.

Next to the Base Color, you should see a yellow dot. Click it and a menu will appear with a bunch of options; select Image Texture. The cube should turn black, and our solid color will now be replaced with some new buttons. Click Open and select the texture you'd like to use. Your texture should now appear!



The process is pretty much identical for roughness and metallic maps: click dot, select Image Texture, load texture, done.



So we now have a whole material on our platform, hooray! But... it looks a bit stretched and kinda silly, doesn't it? It's time to learn how to UV map.





UV Mapping
oh god im gonna have to explain UV mapping now
Okay, here goes. So remember earlier when I said that textures wrap around like a decal? Well, imagine taking a decal for a round object and then unwrapping it until it's flattened out into a square. Or in other words (and because I like the idea of using this image to explain it), think like the wrappers on Christmas chocolate, such as this:



That image on the left would be the full texture, and the little chocolate on the right is the finished, textured model. Imagine if you drew lines where Santa's face, clothes, hat, arms, legs, etc. start and end on the 3D object, and then unwrapped it back to a flat image; the resulting lines are roughly what a UV map looks like.

...okay, this analogy isn't quite working as well as I'd like. Perhaps doing is better than talking here, so let's unwrap our platform. At the top of the Blender window, you'll see a bunch of different workspace tabs. Click UV Editing to bring up that workspace. You should see the workspace change to show two panels: on the right is the viewport showing our scene, and on the left is our UV Editor.



If you're not already in Edit Mode, press Tab or Z to switch to it. You should see what looks like a wireframe appear in the UV editor, in the shape of a cross. This is actually the UV of the cube that we started with! As you can probably notice, our cube has since turned into a rectangle, but the UV hasn't updated to account for it, which is why our texture looks all stretched and weird.

In order to fix that, we need to tell Blender where the seams of the mesh are. If you think about your mesh like it's a papercraft, the seams would be where you'd originally cut on the paper before folding it in. In this case, we should make one seam horizontally across the long side of the rectangle and three seams on the square corners, creating a kind of Omega-symbol-shape.

In the viewport half of the screen, look at the top-left for three buttons: one with a square and a single dot, one with a square and a line, and one with a filled-in square. Click the one with a square and a line, and you'll now be able to select individual edges of the mesh. Now select one of the edges of the long part of our mesh and press U to bring up the UV Mapping menu. From this menu, select Mark Seam and the edge should turn red.



Now pan over to either end of the platform. Select the edge connected to the seam that we just made, then hold Shift and select the edge connected to that, then the edge connected to that, creating either a C-shape with the top end connecting to the seam from earlier, then press U and Mark Seam again.



Repeat this a third time on the other side. Your mesh should now look like this:



Now that our seams are in place, press A to select the entire mesh, then press U to bring up the menu one more time, and finally click Unwrap. If all of that was done correctly, you should now have a new UV consisting of four long rectangles and two squares appended at the end, like a really wide sideways T shape. Your textures should now look much cleaner on the mesh!



If you want, you can tweak the UV's position and scaling further; manipulating UVs is done pretty much the same as manipulating geometry in Edit Mode, just without a third dimension to worry about.
There's a lot more to UVs than this, of course (shoutouts to Ian Hubert for kickstarting my habit of using "Project from View" all the time), but this is the gist of how they work.

And with that, congratulations! You just created your first object in Blender! I'm proud of you. Give yourself a pat on the back, and then maybe take a quick break.

That's pretty much the basics of how to create objects in Blender. If you want, you can start creating more objects for your stage. The next few sections are not step-by-step tutorials, but they explain some other, very useful fundamental parts of using Blender for making more complex geometry.

Modifiers
Modifiers are something you can apply to an object to, well, modify the model's geometry in a variety of ways. They're pretty much the 3D equivalent of a filter in programs like Photoshop, and they are very useful in a wide variety of ways.

To add a modifier, click on an object and then look to the right side of the screen. Next to where the Object Properties tab was, there should be a blue wrench icon; this is the Modifiers tab.



Click the big + button and you'll get a menu to select modifiers from. There's quite a lot of different modifiers, each one useful for different things. For brevity's sake, here's the ones I use the most:

Subdivision Surface
This divides and then smoothens the mesh, creating a higher-polygon model. You can adjust the Levels value to do multiple iterations of division, creating even more smooth meshes. Be careful not to go too high though, as extremely high-poly meshes can slow down Blender exponentially (not to mention anyone else who wants to view your model).



Mirror
This mirrors the mesh on a selected axis (or multiple axises). This is very useful in a wide variety of situations, particularly if you're modelling something and wanting to keep it symmetrical (such as a building or a car). I would also recommend enabling Clipping and Merge to save on redundant geometry.



Array
This duplicates the mesh a given number of times along a given offset. Also very useful in a wide variety of situations!



The cool thing with modifiers is that they allow for what Blender folks call a non-destructive workflow, which is to say that these modifiers are applied in real-time to the mesh as you edit it; you can adjust your model in real time and see how the modifiers affect it, while keeping the actual underlying mesh itself low-poly and thus easier to edit. If you actually want to apply the modifier to the mesh, you can do so by hovering over the modifier in question and pressing Ctrl+A.

Animation
Animating a 3D model is a big part of making scenes come alive and look pretty. By my own admission, animating in Blender is a bit clunky, but I'll try my best to explain it. You may have noticed the big timeline at the bottom of the scene already. This timeline shows you the selected object's keyframes: the key points in time where your model's in an explicitly defined position, rotation, or whatever other property you're animating, represented as little orange dots.



Let's make a simple animation of a cube jumping up and down. If you press the I key, you'll bring up the Insert Keyframe menu. Click on Location and Blender will create a keyframe wherever the timeline's cursor (the blue bar with a number on top) is located.




Now move the timeline cursor to the end of the timeline (the fastest way to do this is to click the button with a triangle pointing right at a line). Press I and insert a second location keyframe.



We now have two keyframes set with our start and end positions for the cube. Now we need to make one more keyframe: the one where the cube is at the height of its jump. Move the timeline cursor to the middle of the timeline, but don't create a keyframe just yet!

We need to first move the cube vertically; to do that, make sure you're in Object Mode, then press G followed by Z to lock movement to the vertical axis. Move the cube upwards, then left-click to apply. Now you can press I to create a third keyframe.



If you click the Play button at the top of the timeline, you should now see your cube moving up and down. It'll move in a linear fashion by default, but you can change this by changing two things: the keyframes' easing and the easing curve.

To change both of these, select the keyframe(s) you want to edit and then right click to bring up a menu (you can also use the shortcuts T for interpolation and Ctrl+E for easing). The two important sub-menus here are Easing Typeand Interpolation Type.



The fastest way to make a bouncing motion, at least for me, is to hover over the timeline and press A to select all three keyframes. Go to the Interpolation Type menu and click one of the options under Easing (by strength); I recommend Sinosidual or Quadratic, but feel free to experiment and see what looks good to you.

Then, for easing, select just the first keyframe, go to Easing Type, and set it to Ease Out. The second and third keyframe should already be set to Ease In by default, but you might want to explicitly set those keyframes to it anyways just in case. If you hit Play now, your cube should have a much smoother jumping motion!

You can animate more than just location, of course: rotation and scaling can be animated in exactly the same way. If you want to get more advanced with your animation's motion, Blender has a dedicated Animation workspace which gives you more fine-grained control over individual axises of motion, but explaining it in detail is beyond the scope of this section.

Vertex Colors
Vertex colors are something I don't really use in my models much, but they are supported by Ikemen GO, so I figured they were worth a section anyways.

Vertex colors are an optional property you can use to tint your models a given color on a per-vertex basis, which are then applied and blended on top of textures. These used to be really common as a technique for shading models in early 3D games (as calculating lights dynamically is quite expensive to do), but are more-or-less obsolete in modern times thanks to stronger computers and techniques like lightmap-baking becoming commonplace. Still, if you're working with models from older games, knowing how they work is pretty important for accurately replicating that old-school look. They might also be useful for creating gradients without having to use a dedicated texture, saving on file size.



By default, models created within Blender do not include vertex colors, but it's easy enough to add them to an object. Near where the Object Properties and Modifiers tabs are, there's a green triangle tab. This is the Object Data tab, which contains quite a lot of things, mostly not relevant for us. Scroll down until you see a section named Color Properties; click it and you'll get an empty menu. Click the + button next to it and you'll get a popup asking you for some settings. The default settings are fine, but you can adjust the Color setting to set a default color value for every vertex if you like (I highly recommend setting it to pure white (#FFF) if it isn't already).



In order to actually see your vertex colors in the 3D viewport, there's two ways to do it. To see only vertex colors, go to the top of the viewport and change the preview mode to Solid and, in the dropdown menu next to it, set the Color to Attribute.



The second way is by editing the material in the Node Editor. You can use the Color Attribute node and plug both it and the texture into a Color Mix node set to Multiply to preview how the two mix together. It should look like this:







Further reading
This post is really only scratching the surface; 3D modelling is an entire skillset in its own right and I can't possibly cover every little detail in one post. As such, here's some great links to learn more about Blender and 3D stuff in general:

• 
  As mentioned above, Blender's 2.8 Fundamental series and/or BornCG's Let's Learn Blender are really great series that jog through various aspects of Blender, probably even better than my guide does.
  
• 
  ExplainingComputers's modelling introduction is also a pretty good introduction to Blender's modelling tools, though it specifically focuses on modelling for 3D printing rather than general-purpose modelling. Runtime of 35 minutes.
  
• 
  Daniel Kraftt's "Blender Tips You Might Not Know" series. Has multiple installments (I linked the first one), but it's a rapid-fire list of very useful tips and quality-of-life things that might be good to know.
  
• 
  As silly as it might sound, the built-in tutorials for Mario Artist: Polygon Studio on N64DD are surprisingly still pretty applicable to Blender as it uses fairly similar modelling techniques. Might be worth checking out, even if just for novelty's sake.
  
• 
  Blender's official documentation is a good resource to have on hand as well, though admittedly I don't use it as much as I should. If you're confused by a specific aspect of Blender, definitely check there.
  
• 
  There's plenty of communities out there for Blender if you'd like to ask for some help and support with aspects of the program. Blender's website aggregates a bunch of them on this page here.
  

Special Thanks

• Eiton, for implementing 3D stage support in the first place.
  
• Violin Ken and PotS, for proofreading this guide and giving me some feedback.
  
• The Blender Foundation for giving us such an incredible 3D tool for free, and making it open source.
  
• This also applies to its community. Thanks for giving me the resources to get started on 3D stuff myself!
  

Very interesting.
Looks like the hell of a learning curve.
I see most intermediate level mugen stage creators struggling with this.
On the bright side it will raise the benchmark of necessary skill to be a stage creator for sure

HOLLYSHIT

This may be nudge I needed to jump back in creation wise....
Still busy at work so a few more months before I check this out myself.

Man, I've been looking for this for way too long. Thanks a LOT

Thank you, this is very useful

Looks so cool!