Can .FBX model fully support?


I want to know that , Can Jmonkey SDK, fully support a “some.fbx” mean .fbx format.

Please reply.

without any error,

Unity , UDK and other game engines use a .fbx format model.

No, the FBX format is not supported in jME3.

I expect there are tools around to convert FBX to a supported format though.

How i import a fbx model into jmonkey,perfect answer anyone,

mean Anyone in this forumn solve this, or if jmonkey not include a fbx format model,than it’s drawback…

If possible than good for future .

You are welcome to implement a converter. Remember this is open source and you can check out the code and write a converter for one of the many, many, model formats.

1 Like

If you created it in an Autodesk product (which might be a safe bet since this is a proprietary ADSK format) then just bring it into Maya or 3ds and export as an OBJ.

Otherwise, Blender’s FBX toolset keeps getting better and better.

@mkbluesky513 said:

Anyone in this forumn solve this, or if jmonkey not include a fbx format model,than it’s drawback…

You got your answer already ;)

@kwando said:
No, the FBX format is not supported in jME3.
1 Like

Ok than I implement it,

Thanks friends and mostly persons,if anyone solve than reply must,and i try to make a model format loader API,GUI base.

1 Like

Thanks Sploreg

@Sploreg said:
You are welcome to implement a converter.

@mkbluesky513 said:
Ok than I implement it,

More exactly an importer, theres examples for that in the contributions repository and of course in the engine in form of the existing ogre and obj loaders.

Not impossible,it’s possible but its take some time,every development take sometime,but its possible,

1 Like


import java.util.ArrayList;

import com.jme.math.Vector3f;

import com.sbook.fbx.schema.Properties;

import com.sbook.fbx.schema.Properties.PropertyParent;


  • @author Skye Book



    public class FBX_Properties {

    private PropertyParent propertyParent = null;

    private String propertyName = null;

    //private String Model_RotationOffset = “RotationOffset”;

    //private String Model_RotationPivot = “RotationPivot”;

    //private String Model_ScalingOffset = “ScalingOffset”;

    //private String Model_ScalingPivot = “ScalingPivot”;

    //private String Model_TranslationActive = “TranslationActive”;

    //private String Model_TranslationMin = “TranslationMin”;

    //private String Model_TranslationMax = “TranslationMax”;

    //private String Model_TranslationMinX = “TranslationMinX”;

    //private String Model_TranslationMinY = “TranslationMinY”;

    //private String Model_TranslationMinZ = “TranslationMinZ”;

    //private String Model_TranslationMaxX = “TranslationMaxX”;

    //private String Model_TranslationMaxY = “TranslationMaxY”;

    //private String Model_TranslationMaxZ = “TranslationMaxZ”;

    //private String Model_RotationOrder = “RotationOrder”;

    //private String Model_RotationSpaceForLimitOnly = “RotationSpaceForLimitOnly”;

    //private String Model_RotationStiffnessX = “RotationStiffnessX”;

    //private String Model_RotationStiffnessY = “RotationStiffnessY”;

    //private String Model_RotationStiffnessZ = “RotationStiffnessZ”;

    //private String Model_AxisLen = “AxisLen”;

    private Vector3f Model_PreRotation = null; // Vector3f

    private Vector3f Model_PostRotation = null;// Vector3f

    //private String Model_RotationActive = “RotationActive”;

    private Vector3f Model_RotationMin = null;// Vector3f

    private Vector3f Model_RotationMax = null;// Vector3f

    //private String Model_RotationMinX = “RotationMinX”;

    //private String Model_RotationMinY = “RotationMinY”;

    //private String Model_RotationMinZ = “RotationMinZ”;

    //private String Model_RotationMaxX = “RotationMaxX”;

    //private String Model_RotationMaxY = “RotationMaxY”;

    //private String Model_RotationMaxZ = “RotationMaxZ”;

    //private String Model_InheritType = “InheritType”;

    //private String Model_ScalingActive = “ScalingActive”;

    private Vector3f Model_ScalingMin = null;// Vector3f

    private Vector3f Model_ScalingMax = null;// Vector3f

    //private String Model_ScalingMinX = “ScalingMinX”;

    //private String Model_ScalingMinY = “ScalingMinY”;

    //private String Model_ScalingMinZ = “ScalingMinZ”;

    //private String Model_ScalingMaxX = “ScalingMaxX”;

    //private String Model_ScalingMaxY = “ScalingMaxY”;

    //private String Model_ScalingMaxZ = “ScalingMaxZ”;

    private Vector3f Model_GeometricTranslation = null;// Vector3f

    private Vector3f Model_GeometricRotation = null;// Vector3f

    private Vector3f Model_GeometricScaling = null;// Vector3f

    //private String Model_MinDampRangeX = “MinDampRangeX”;

    //private String Model_MinDampRangeY = “MinDampRangeY”;

    //private String Model_MinDampRangeZ = “MinDampRangeZ”;

    //private String Model_MaxDampRangeX = “MaxDampRangeX”;

    //private String Model_MaxDampRangeY = “MaxDampRangeY”;

    //private String Model_MaxDampRangeZ = “MaxDampRangeZ”;

    //private String Model_MinDampStrengthX = “MinDampStrengthX”;

    //private String Model_MinDampStrengthY = “MinDampStrengthY”;

    //private String Model_MinDampStrengthZ = “MinDampStrengthZ”;

    //private String Model_MaxDampStrengthX = “MaxDampStrengthX”;

    //private String Model_MaxDampStrengthY = “MaxDampStrengthY”;

    //private String Model_MaxDampStrengthZ = “MaxDampStrengthZ”;

    //private String Model_PreferredAngleX = “PreferredAngleX”;

    //private String Model_PreferredAngleY = “PreferredAngleY”;

    //private String Model_PreferredAngleZ = “PreferredAngleZ”;

    //private String Model_LookAtProperty = “LookAtProperty”;

    //private String Model_UpVectorProperty = “UpVectorProperty”;

    //private String Model_Show = “Show”;

    //private String Model_NegativePercentShapeSupport = “NegativePercentShapeSupport”;

    //private String Model_DefaultAttributeIndex = “DefaultAttributeIndex”;

    private Vector3f Model_Lcl_Translation = null;// FBX calls this a type “Lcl Translation”, but it looks to simply be a vector3d(jme:vector3f with A+ added before it where vector3d would have an empty string

    private Vector3f Model_Lcl_Rotation = null;// FBX calls this a type “Lcl Rotation”, but it looks to simply be a vector3d(jme:vector3f with A+ added before it where vector3d would have an empty string

    private Vector3f Model_Lcl_Scaling = null;// FBX calls this a type “Lcl Scaling”, but it looks to simply be a vector3d(jme:vector3f with A+ added before it where vector3d would have an empty string

    //private String Model_Visibility = “Visibility”;

    //private String Model_Color = “Color”;// Looks like a ColorRGBA with no alpha channel.

    private Vector3f Model_BBoxMin = null;// Vector3f

    private Vector3f Model_BBoxMax = null;// Vector3f




    public FBX_Properties(PropertyParent parent, String rawPropertyLine) {

    propertyParent = parent;

    propertyName = rawPropertyLine.substring(rawPropertyLine.indexOf(""")+1,

    rawPropertyLine.indexOf(""", rawPropertyLine.indexOf(""")+1));

    System.out.println(“PROPERTY: " + propertyName);


    if(propertyName.equals(Properties.Model_Lcl_Translation)) Model_Lcl_Translation = createVector3f(rawPropertyLine);

    else if(propertyName.equals(Properties.Model_Lcl_Rotation)) Model_Lcl_Rotation = createVector3f(rawPropertyLine);

    else if(propertyName.equals(Properties.Model_Lcl_Scaling)) Model_Lcl_Scaling = createVector3f(rawPropertyLine);

    else if(propertyName.equals(Properties.Model_GeometricTranslation)) Model_GeometricTranslation = createVector3f(rawPropertyLine);

    else if(propertyName.equals(Properties.Model_GeometricRotation)) Model_GeometricRotation = createVector3f(rawPropertyLine);

    else if(propertyName.equals(Properties.Model_GeometricScaling)) Model_GeometricScaling = createVector3f(rawPropertyLine);


    else if(parent.equals(PropertyParent.SCENEINFO)){


    else if(parent.equals(PropertyParent.MATERIAL)){


    else if(parent.equals(PropertyParent.GLOBALSETTINGS)){


    else if(parent.equals(PropertyParent.OBJECT)){



    public void addProperty(PropertyParent parent, String rawPropertyLine) {


    private Vector3f createVector3f(String propertyLine){

    ArrayList xyz = new ArrayList();

    String commaSplits[] = propertyLine.split(”,");

    for(int i = 0; i<commaSplits.length; i++){




    commaSplits.startsWith(“9”)||commaSplits.startsWith("-") &&





    System.out.println(“found a number”);




    return new Vector3f(xyz.get(0), xyz.get(1), xyz.get(2));


    private double createDouble(String propertyLine){

    return 0;


    public Object getPropertyValue(PropertyParent parent, String propertyName){



    return Model_Lcl_Translation;

    else if(propertyName.equals(Properties.Model_Lcl_Rotation))

    return Model_Lcl_Rotation;

    else if(propertyName.equals(Properties.Model_Lcl_Scaling))

    return Model_Lcl_Scaling;

    else if(propertyName.equals(Properties.Model_GeometricTranslation))

    return Model_GeometricTranslation;

    else if(propertyName.equals(Properties.Model_GeometricRotation))

    return Model_GeometricRotation;

    else if(propertyName.equals(Properties.Model_GeometricScaling))

    return Model_GeometricScaling;

    else return null;


    else if(parent.equals(PropertyParent.SCENEINFO)){

    return null;


    else if(parent.equals(PropertyParent.MATERIAL)){

    return null;


    else if(parent.equals(PropertyParent.GLOBALSETTINGS)){

    return null;


    else if(parent.equals(PropertyParent.OBJECT)){

    return null;


    else return null;



This looks kinda useless :stuck_out_tongue:

The issue with fbx really is not importing it anyway… loads of tools can convert fbx to obj which JME3 can import.

Where it really becomes a problem is that fbx is the most widely used format for animated characters, and getting the models into JME with animations is currently a real pain (in my opinion). This code you pasted won’t help with the anims.

The only way I’ve found that works to get animated FBX models in so far is to use fragmotion to open the fbx, export it to Ogre XML format, then use the Ogre command line tools (recompiled from source in 64 bit to avoid memory limit issues) to produce the binary mesh and skeleton from the XML and then import that mesh to JME with the ogre importer.

I would love to see someone contribute an FBX plugin to JME3, but I think it’s a huge job.


Can you tell me about , can fbx importer make in java for JMonkey,

and it’s development is gr8 than OGre or other,

Any day JMonkey is superior than others…

Is this possible or not?

@mkbluesky513 said:
Is this possible or not?

It's possible... but you'd have to write it yourself, or pay someone to do it for you.

I would love to see an FBX importer too because its not easy to get shop-bought animated models into Ogre format. It would be a great addition to the engine. Its a *big* job though and as far as I know the devs and contributors are all focused on other things right now so I doubt there will be one any time soon.
@mkbluesky513 said:

* @author Skye Book
public class FBX_Properties {

That's my "code" and it's incomplete and untouched for the last three years for a reason :)

As I, and others have said above, there are probably better avenues to go down.
1 Like

i am research on your code…

thanks for this and for your mind,

because it is publically used,but name is your on this code,due to i am honesty.

@mkbluesky513 said:
i am research on your code.........
thanks for this and for your mind,
because it is publically used,but name is your on this code,due to i am honesty.

Yes use it for whatever you want.. My only point was that it doesn't do anything ^^

I came up with the names there by generating an FBX ASCII file from Maya. Being that the format is proprietary and undocumented I'd recommend checking out the code in Blender that loads it.

But I think , AutoDesk fbx file management give me a full information,

and it is successfull in c/c++,

I try to import into JME …mean n Java Code…

Yes the Autodesk SDK gives you access but that is only through C++ (and some functionality available in Python if you have Maya installed). That isn’t open source or redistributable, however, so it doesn’t really work for this purpose :slight_smile:

Porting some code to Java isn’t especially difficult, but you’d need the code to port first… If you’re willing to learn a bit about the Blender scenegraph then the exporter/importer scripts (Python) would be something to look at

Can this is possible to import in java or write a code in java , for FBX …Is it possible or not?

According to your view…