Newest questions tagged assimp - Stack Overflow

Animation not animating correctly in assimp [closed]

2025-07-27T13:19:32Z

I'm using assimp in my C game engine (which uses Vulkan) to try and animate a model but it's animating extremely weirdly. The animation implementation is based off the learnopengl.com skeletal animation tutorial. Bone class:

typedef struct skBone
{
    skVector* positions; // skPosition
    skVector* rotations; // skRotation
    skVector* scales; // skScale
    int numPositions;
    int numRotations;
    int numScales;

    mat4 localTransform;
    char name[128];
    int ID;
} skBone;

skBone skBone_Create(const char* name, int ID,
                     const struct aiNodeAnim* channel)
{
    skBone bone = {0};

    strcpy(bone.name, name);
    bone.ID = ID;
    glm_mat4_identity(bone.localTransform);

    // Initialize all keyframes by acessing them through assimp

    bone.positions = skVector_Create(sizeof(skKeyPosition), 5);
    bone.rotations = skVector_Create(sizeof(skKeyRotation), 5);
    bone.scales = skVector_Create(sizeof(skKeyScale), 5);

    bone.numPositions = channel->mNumPositionKeys;
    for (int positionIndex = 0; positionIndex < bone.numPositions;
         ++positionIndex)
    {
        const struct aiVector3D aiPosition =
            channel->mPositionKeys[positionIndex].mValue;
        float timeStamp = channel->mPositionKeys[positionIndex].mTime;
        skKeyPosition data;
        skAssimpVec3ToGLM(&aiPosition, data.position);
        data.timeStamp = timeStamp;

        skVector_PushBack(bone.positions, &data);
    }

    bone.numRotations = channel->mNumRotationKeys;
    for (int rotationIndex = 0; rotationIndex < bone.numRotations;
         ++rotationIndex)
    {
        const struct aiQuaternion aiOrientation =
            channel->mRotationKeys[rotationIndex].mValue;
        float timeStamp = channel->mRotationKeys[rotationIndex].mTime;
        skKeyRotation data;
        data.rotation[0] = aiOrientation.w;
        data.rotation[1] = aiOrientation.x;
        data.rotation[2] = aiOrientation.y;
        data.rotation[3] = aiOrientation.z;
        data.timeStamp = timeStamp;

        skVector_PushBack(bone.rotations, &data);
    }

    bone.numScales = channel->mNumScalingKeys;
    for (int keyIndex = 0; keyIndex < bone.numScales; ++keyIndex)
    {
        const struct aiVector3D scale =
            channel->mScalingKeys[keyIndex].mValue;
        float      timeStamp = channel->mScalingKeys[keyIndex].mTime;
        skKeyScale data;
        skAssimpVec3ToGLM(&scale, data.scale);
        data.timeStamp = timeStamp;

        skVector_PushBack(bone.scales, &data);
    }

    return bone;
}

int skBone_GetPositionIndex(skBone* bone, float animationTime)
{
    for (int index = 0; index < bone->numPositions - 1; ++index)
    {
        skKeyPosition* pos =
            (skKeyPosition*)skVector_Get(bone->positions, index + 1);

        if (animationTime < pos->timeStamp)
            return index;
    }
    assert(0);
}

int skBone_GetRotationIndex(skBone* bone, float animationTime)
{
    for (int index = 0; index < bone->numRotations - 1; ++index)
    {
        skKeyRotation* rot =
            (skKeyRotation*)skVector_Get(bone->rotations, index + 1);

        if (animationTime < rot->timeStamp)
            return index;
    }
    assert(0);
}

int skBone_GetScaleIndex(skBone* bone, float animationTime)
{
    for (int index = 0; index < bone->numScales - 1; ++index)
    {
        skKeyScale* scale =
            (skKeyScale*)skVector_Get(bone->scales, index + 1);

        if (animationTime < scale->timeStamp)
            return index;
    }
    assert(0);
}

float skGetScaleFactor(float lastTimeStamp, float nextTimeStamp,
                       float animationTime)
{
    float scaleFactor = 0.0f;
    float midWayLength = animationTime - lastTimeStamp;
    float framesDiff = nextTimeStamp - lastTimeStamp;
    scaleFactor = midWayLength / framesDiff;
    return scaleFactor;
}

void skBone_InterpolatePosition(skBone* bone, float animationTime,
                                mat4 dest)
{
    if (bone->numPositions == 1)
    {
        skKeyPosition* pos =
            (skKeyPosition*)skVector_Get(bone->positions, 0);
        glm_translate(dest, pos->position);
        return;
    }

    int p0Index = skBone_GetPositionIndex(bone, animationTime);
    int p1Index = p0Index + 1;

    skKeyPosition* key1 =
        (skKeyPosition*)skVector_Get(bone->positions, p0Index);
    skKeyPosition* key2 =
        (skKeyPosition*)skVector_Get(bone->positions, p1Index);

    float scaleFactor = skGetScaleFactor(
        key1->timeStamp, key2->timeStamp, animationTime);

    vec3 finalPosition;
    glm_vec3_mix(key1->position, key2->position, scaleFactor,
                 finalPosition);

    glm_translate(dest, finalPosition);
}

void skBone_InterpolateRotation(skBone* bone, float animationTime,
                                mat4 dest)
{
    if (bone->numRotations == 1)
    {
        skKeyRotation* rot =
            (skKeyRotation*)skVector_Get(bone->rotations, 0);
        glm_quat_mat4(rot->rotation, dest);
        return;
    }

    int p0Index = skBone_GetRotationIndex(bone, animationTime);
    int p1Index = p0Index + 1;

    skKeyRotation* key1 =
        (skKeyRotation*)skVector_Get(bone->rotations, p0Index);
    skKeyRotation* key2 =
        (skKeyRotation*)skVector_Get(bone->rotations, p1Index);

    float scaleFactor = skGetScaleFactor(
        key1->timeStamp, key2->timeStamp, animationTime);

    vec4 finalRotation;
    glm_quat_slerp(key1->rotation, key2->rotation, scaleFactor,
                   finalRotation);

    glm_quat_mat4(finalRotation, dest);
}

void skBone_InterpolateScale(skBone* bone, float animationTime,
                             mat4 dest)
{
    if (bone->numScales == 1)
    {
        skKeyScale* scale =
            (skKeyScale*)skVector_Get(bone->scales, 0);
        glm_scale(dest, scale->scale);
        return;
    }

    int   p0Index = skBone_GetScaleIndex(bone, animationTime);
    int   p1Index = p0Index + 1;
    float scaleFactor = skGetScaleFactor(
        ((skKeyScale*)skVector_Get(bone->scales, p0Index))->timeStamp,
        ((skKeyScale*)skVector_Get(bone->scales, p1Index))->timeStamp,
        animationTime);

    vec3 finalScale;
    glm_vec3_mix(
        ((skKeyScale*)skVector_Get(bone->scales, p0Index))->scale,
        ((skKeyScale*)skVector_Get(bone->scales, p1Index))->scale,
        scaleFactor, finalScale);

    glm_scale(dest, finalScale);
}

void skBone_Update(skBone* bone, float animationTime)
{
    mat4 trans = GLM_MAT4_IDENTITY_INIT,
         rotation = GLM_MAT4_IDENTITY_INIT,
         scale = GLM_MAT4_IDENTITY_INIT;
    skBone_InterpolatePosition(bone, animationTime, trans);
    skBone_InterpolateRotation(bone, animationTime, rotation);
    skBone_InterpolateScale(bone, animationTime, scale);
    glm_mat4_mul(trans, rotation, bone->localTransform);
}

Animator and animation class:

typedef struct skAnimation
{
    skVector* bones; // skBone
    skMap* boneInfoMap; // char*, skBoneInfo
    float duration;
    int ticksPerSecond;
    skAssimpNodeData rootNode;
    mat4 inverseGlobalTransformation;
} skAnimation;

typedef struct skAnimator
{
    skVector* finalBoneMatrices; // mat4
    skAnimation* currentAnimation;
    float currentTime;
    float deltaTime;
} skAnimator;

skAnimation skAnimation_Create(const char* animationPath,
                               skModel*    model)
{
    skAnimation animation = {0};

    animation.bones = skVector_Create(sizeof(skBone), 16);
    animation.boneInfoMap = model->boneInfoMap;

    const struct aiScene* scene = aiImportFile(
        animationPath, aiProcess_Triangulate);

    struct aiMatrix4x4 globalTransformation =
        scene->mRootNode->mTransformation;
    aiMatrix4Inverse(&globalTransformation);
    skAssimpMat4ToGLM(&globalTransformation,
                      animation.inverseGlobalTransformation);

    if (!scene || !scene->mRootNode || !scene->mNumAnimations)
    {
        printf("Error: Failed to load animation file: %s\n",
               animationPath);
        return animation;
    }

    const struct aiAnimation* aiAnim = scene->mAnimations[0];
    animation.duration = (float)aiAnim->mDuration;
    animation.ticksPerSecond = (int)aiAnim->mTicksPerSecond;

    skAnimation_ReadHierarchyData(&animation.rootNode,
                                  scene->mRootNode);

    skAnimation_ReadMissingBones(&animation, aiAnim, model);

    aiReleaseImport(scene);

    return animation;
}

void skAnimation_Free(skAnimation* animation)
{
    if (!animation)
        return;

    if (animation->bones)
    {
        for (size_t i = 0; i < animation->bones->size; i++)
        {
            skBone* bone = (skBone*)skVector_Get(animation->bones, i);
            if (bone)
            {
                if (bone->positions)
                    skVector_Free(bone->positions);
                if (bone->rotations)
                    skVector_Free(bone->rotations);
                if (bone->scales)
                    skVector_Free(bone->scales);
            }
        }
        skVector_Free(animation->bones);
    }

    skAssimpNodeData_Free(&animation->rootNode);

    // boneInfoMap isn't freed here as it belongs to the model

    *animation = (skAnimation) {0};
}

skBone* skAnimation_FindBone(skAnimation* animation, const char* name)
{
    if (!animation || !animation->bones || !name)
        return NULL;

    for (size_t i = 0; i < animation->bones->size; i++)
    {
        skBone* bone = (skBone*)skVector_Get(animation->bones, i);
        if (bone && strcmp(bone->name, name) == 0)
        {
            return bone;
        }
    }

    return NULL;
}

void skAnimation_ReadMissingBones(skAnimation*              animation,
                                  const struct aiAnimation* aiAnim,
                                  skModel*                  model)
{
    if (!animation || !aiAnim || !model)
        return;

    int size = (int)aiAnim->mNumChannels;

    // Process each channel (bone) in the animation
    for (int i = 0; i < size; i++)
    {
        const struct aiNodeAnim* channel = aiAnim->mChannels[i];
        const char* boneNamePtr = channel->mNodeName.data;

        // Check if bone exists in model's bone info map
        if (!skMap_Contains(model->boneInfoMap, &boneNamePtr))
        {
            // Add new bone info to model's map
            skBoneInfo newBoneInfo;
            newBoneInfo.id = model->boneCount;
            glm_mat4_identity(newBoneInfo.offset);

            skMap_Insert(model->boneInfoMap, &boneNamePtr,
                         &newBoneInfo);
            model->boneCount++;
        }

        // Get bone info from map
        skBoneInfo* boneInfo =
            (skBoneInfo*)skMap_Get(model->boneInfoMap, &boneNamePtr);

        // Create bone object and add to animation
        skBone bone =
            skBone_Create(boneNamePtr, boneInfo->id, channel);
        skVector_PushBack(animation->bones, &bone);
    }
}

void skAnimation_ReadHierarchyData(skAssimpNodeData*    dest,
                                   const struct aiNode* src)
{
    if (!dest || !src)
        return;

    // Copy node name
    strncpy(dest->name, src->mName.data, sizeof(dest->name) - 1);
    dest->name[sizeof(dest->name) - 1] = '\0';

    // Convert Assimp matrix to CGLM matrix
    skAssimpMat4ToGLM(&src->mTransformation, dest->transformation);

    dest->childrenCount = (int)src->mNumChildren;

    // Initialize children vector
    dest->children = skVector_Create(sizeof(skAssimpNodeData),
                                     dest->childrenCount);

    for (int i = 0; i < dest->childrenCount; i++)
    {
        skAssimpNodeData childData = {0};
        skAnimation_ReadHierarchyData(&childData, src->mChildren[i]);
        skVector_PushBack(dest->children, &childData);
    }
}

void skAssimpNodeData_Free(skAssimpNodeData* nodeData)
{
    if (!nodeData)
        return;

    if (nodeData->children)
    {
        // Recursively free children
        for (size_t i = 0; i < nodeData->children->size; i++)
        {
            skAssimpNodeData* child = (skAssimpNodeData*)skVector_Get(
                nodeData->children, i);
            if (child)
            {
                skAssimpNodeData_Free(child);
            }
        }
        skVector_Free(nodeData->children);
        nodeData->children = NULL;
    }
}

// Get bone by index
skBone* skAnimation_GetBone(skAnimation* animation, size_t index)
{
    if (!animation || !animation->bones ||
        index >= animation->bones->size)
    {
        return NULL;
    }
    return (skBone*)skVector_Get(animation->bones, index);
}

// Check if animation is valid
int skAnimation_IsValid(skAnimation* animation)
{
    return animation && animation->bones &&
           animation->bones->size > 0 && animation->duration > 0.0f;
}

skAnimator skAnimator_Create(skAnimation* animation)
{
    skAnimator anim = {0};

    anim.currentTime = 0.0f;
    anim.currentAnimation = animation;

    anim.finalBoneMatrices = skVector_Create(sizeof(mat4), 100);

    for (int i = 0; i < 100; i++)
    {
        mat4 ident = GLM_MAT4_IDENTITY_INIT;
        skVector_PushBack(anim.finalBoneMatrices, &ident);
    }

    return anim;
}

void skAnimator_UpdateAnimation(skAnimator* animator, float dt)
{
    animator->deltaTime = dt;
    if (animator->currentAnimation)
    {
        animator->currentTime +=
            animator->currentAnimation->ticksPerSecond * dt;

        animator->currentTime =
            fmod(animator->currentTime,
                 animator->currentAnimation->duration);

        skAnimator_CalculateBoneTransform(
            animator, &animator->currentAnimation->rootNode,
            GLM_MAT4_IDENTITY);
    }
}

void skAnimator_PlayAnimation(skAnimator* animator, skAnimation* anim)
{
    animator->currentAnimation = anim;
    animator->currentTime = 0.0f;
}

void skAnimator_CalculateBoneTransform(skAnimator*       animator,
                                       skAssimpNodeData* node,
                                       mat4 parentTransform)
{
    skBone* bone =
        skAnimation_FindBone(animator->currentAnimation, node->name);

    mat4 nodeTransform;
    glm_mat4_copy(node->transformation, nodeTransform);

    if (bone)
    {
        skBone_Update(bone, animator->currentTime);
        glm_mat4_copy(bone->localTransform, nodeTransform);
    }

    mat4 globalTransformation;
    glm_mat4_mul(parentTransform, nodeTransform,
                 globalTransformation);

    const char* nodeName = &node->name;

    if (skMap_Contains(animator->currentAnimation->boneInfoMap,
                       &nodeName))
    {
        skBoneInfo* info = (skBoneInfo*)skMap_Get(
            animator->currentAnimation->boneInfoMap, &nodeName);

        int index = info->id;

        mat4 bruhMat;
        glm_mat4_mul(globalTransformation, info->offset, bruhMat);

        mat4* boneMat =
            (mat4*)skVector_Get(animator->finalBoneMatrices, index);
        glm_mat4_copy(bruhMat, *boneMat);
    }

    for (int i = 0; i < node->childrenCount; i++)
    {
        skAssimpNodeData* nodeData =
            (skAssimpNodeData*)skVector_Get(node->children, i);

        skAnimator_CalculateBoneTransform(
            animator, nodeData,
            globalTransformation);
    }
}

The animator class has a vector of bone matrices which I then feed to the vertex shader which transforms the vertices by the bone matrices but something is clearly going wrong here. The bone weights and IDs are transferring correctly I'm pretty sure as when I input them into the fragment shader to visualize them, they do have seemingly correct values even though Vulkan does scream at me and says Vertex attribute at location 6 and 7 not consumed by vertex shader even though they clearly are. I don't know what I'm doing wrong here.

Result:

Expected result:

The model is moving slightly and the movements look natural, though it's obviously incorrect.

What is the purpose of the pkey parameter?

2025-07-12T18:02:41Z

I want to read a diffuse texture like this:

aiGetMaterialString(material,
                    AI_MATKEY_COLOR_DIFFUSE, // this is the pkey parameter
                    aiTextureType_DIFFUSE,
                    0,
                    path);

Why is there a pkey parameter? Is it not enough to specify the type?

Anyway, the path string is empty after calling above function. I was expecting to get the filename of the texture.

Reading a 3D model with lwjgl-assimp failes in Clojure

2025-07-03T16:06:35Z

This is my Clojure code:

(ns learnopengl.mesh-model
  (:import [org.lwjgl.assimp Assimp AINode AIMesh]))

(defn read-model
  "read a 3D model from a file"
  [path]
  (let [scene (Assimp/aiImportFile path (bit-or Assimp/aiProcess_Triangulate
                                                Assimp/aiProcess_FlipUVs))]
    (if (= scene nil)
      (println (Assimp/aiGetErrorString))
      (for [index (range (.mNumMeshes scene))]
        (do
          (println index)
          (AIMesh/create (.get (.mMeshes scene) index)))))))

which fails with:

0
Execution error (IllegalArgumentException) at java.nio.Buffer/createCapacityException (Buffer.java:290).
capacity < 0: (-576307456 < 0)

This happens inside AIMesh/create.

Believing I may have encountered a bug, I rewrote the snippet in Java:

import org.lwjgl.assimp.Assimp;
import org.lwjgl.assimp.AIScene;
import org.lwjgl.assimp.AIMesh;

class Test {
    public static void main(String[] args) {
        AIScene scene = Assimp.aiImportFile("backpack/backpack.obj", Assimp.aiProcess_Triangulate);
        if (scene == null) {
            System.out.println(Assimp.aiGetErrorString());
        } else {
            for (int i = 0; i < scene.mNumMeshes(); i++) {
                System.out.println(i);
                AIMesh mesh = AIMesh.create(scene.mMeshes().get(i));
            }
        }
    }
}

The Java code however runs smoothly. I don't understand why, since I believe the two snippets to be essentially the same. Can someone spot where I may have gone wrong in the Clojure code?

This is the 3D model I've been testing with.

Edit: This is my project.clj:

(defproject learnopengl "0.1.0-SNAPSHOT"
  :description "learnopengl book code"
  :url "learnopengl.com"
  :license {:name "EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0"
            :url "https://www.eclipse.org/legal/epl-2.0/"}
  :dependencies [[org.clojure/clojure "1.11.1"]
                 [org.lwjgl/lwjgl "3.3.6"]
                 [org.lwjgl/lwjgl "3.3.6" :classifier "natives-linux"]
                 [org.lwjgl/lwjgl-opengl "3.3.6"]
                 [org.lwjgl/lwjgl-opengl "3.3.6" :classifier "natives-linux"]
                 [org.lwjgl/lwjgl-stb "3.3.6"]
                 [org.lwjgl/lwjgl-stb "3.3.6" :classifier "natives-linux"]
                 [org.lwjgl/lwjgl-glfw "3.3.6"]
                 [org.lwjgl/lwjgl-glfw "3.3.6" :classifier "natives-linux"]
                 [org.lwjgl/lwjgl-assimp "3.3.6"]
                 [org.lwjgl/lwjgl-assimp "3.3.6" :classifier "natives-linux"]
                 [org.joml/joml "1.10.8"]]
  :main ^:skip-aot learnopengl.core
  :target-path "target/%s"
  :profiles {:uberjar {:aot :all
                       :jvm-opts ["-Dclojure.compiler.direct-linking=true"]}})

Edit2:

This is my repository with the full code that breaks for me. read-model is defined in mesh-model.clj, and it is called an line 11 in core.clj.

Edit3:

This is the content from the /tmp/clojure-xxx.edn file produced for the crash, which contains the stack trace:

{:clojure.main/message
 "Execution error (IllegalArgumentException) at java.nio.Buffer/createCapacityException (Buffer.java:290).\ncapacity < 0: (-689151616 < 0)\n",
 :clojure.main/triage
 {:clojure.error/class java.lang.IllegalArgumentException,
  :clojure.error/line 290,
  :clojure.error/cause "capacity < 0: (-689151616 < 0)",
  :clojure.error/symbol java.nio.Buffer/createCapacityException,
  :clojure.error/source "Buffer.java",
  :clojure.error/phase :execution},
 :clojure.main/trace
 {:via
  [{:type clojure.lang.Compiler$CompilerException,
    :message
    "Syntax error macroexpanding at (learnopengl/core.clj:12:1).",
    :data
    {:clojure.error/phase :execution,
     :clojure.error/line 12,
     :clojure.error/column 1,
     :clojure.error/source "learnopengl/core.clj"},
    :at [clojure.lang.Compiler load "Compiler.java" 7665]}
   {:type java.lang.IllegalArgumentException,
    :message "capacity < 0: (-689151616 < 0)",
    :at [java.nio.Buffer createCapacityException "Buffer.java" 290]}],
  :trace
  [[java.nio.Buffer createCapacityException "Buffer.java" 290]
   [java.nio.Buffer <init> "Buffer.java" 253]
   [java.nio.ByteBuffer <init> "ByteBuffer.java" 316]
   [java.nio.ByteBuffer <init> "ByteBuffer.java" 324]
   [java.nio.MappedByteBuffer <init> "MappedByteBuffer.java" 113]
   [java.nio.DirectByteBuffer <init> "DirectByteBuffer.java" 107]
   [java.nio.ByteBuffer allocateDirect "ByteBuffer.java" 360]
   [org.lwjgl.system.Struct __create "Struct.java" 118]
   [org.lwjgl.assimp.AIMesh create "AIMesh.java" 487]
   [jdk.internal.reflect.DirectMethodHandleAccessor
    invoke
    "DirectMethodHandleAccessor.java"
    103]
   [java.lang.reflect.Method invoke "Method.java" 580]
   [clojure.lang.Reflector invokeMatchingMethod "Reflector.java" 167]
   [clojure.lang.Reflector invokeStaticMethod "Reflector.java" 332]
   [learnopengl.mesh_model$read_model$iter__332__336$fn__337$fn__338
    invoke
    "mesh_model.clj"
    66]
   [learnopengl.mesh_model$read_model$iter__332__336$fn__337
    invoke
    "mesh_model.clj"
    63]
   [clojure.lang.LazySeq sval "LazySeq.java" 42]
   [clojure.lang.LazySeq seq "LazySeq.java" 51]
   [clojure.lang.RT seq "RT.java" 535]
   [clojure.lang.RT countFrom "RT.java" 650]
   [clojure.lang.RT count "RT.java" 643]
   [learnopengl.core$eval351 invokeStatic "core.clj" 12]
   [learnopengl.core$eval351 invoke "core.clj" 12]
   [clojure.lang.Compiler eval "Compiler.java" 7194]
   [clojure.lang.Compiler load "Compiler.java" 7653]
   [clojure.lang.RT loadResourceScript "RT.java" 381]
   [clojure.lang.RT loadResourceScript "RT.java" 372]
   [clojure.lang.RT load "RT.java" 459]
   [clojure.lang.RT load "RT.java" 424]
   [clojure.core$load$fn__6908 invoke "core.clj" 6161]
   [clojure.core$load invokeStatic "core.clj" 6160]
   [clojure.core$load doInvoke "core.clj" 6144]
   [clojure.lang.RestFn invoke "RestFn.java" 408]
   [clojure.core$load_one invokeStatic "core.clj" 5933]
   [clojure.core$load_one invoke "core.clj" 5928]
   [clojure.core$load_lib$fn__6850 invoke "core.clj" 5975]
   [clojure.core$load_lib invokeStatic "core.clj" 5974]
   [clojure.core$load_lib doInvoke "core.clj" 5953]
   [clojure.lang.RestFn applyTo "RestFn.java" 142]
   [clojure.core$apply invokeStatic "core.clj" 669]
   [clojure.core$load_libs invokeStatic "core.clj" 6016]
   [clojure.core$load_libs doInvoke "core.clj" 6000]
   [clojure.lang.RestFn applyTo "RestFn.java" 137]
   [clojure.core$apply invokeStatic "core.clj" 669]
   [clojure.core$require invokeStatic "core.clj" 6038]
   [clojure.core$require doInvoke "core.clj" 6038]
   [clojure.lang.RestFn invoke "RestFn.java" 408]
   [user$eval140$fn__144 invoke "form-init15974239925031016013.clj" 1]
   [user$eval140 invokeStatic "form-init15974239925031016013.clj" 1]
   [user$eval140 invoke "form-init15974239925031016013.clj" 1]
   [clojure.lang.Compiler eval "Compiler.java" 7194]
   [clojure.lang.Compiler eval "Compiler.java" 7184]
   [clojure.lang.Compiler load "Compiler.java" 7653]
   [clojure.lang.Compiler loadFile "Compiler.java" 7591]
   [clojure.main$load_script invokeStatic "main.clj" 475]
   [clojure.main$init_opt invokeStatic "main.clj" 477]
   [clojure.main$init_opt invoke "main.clj" 477]
   [clojure.main$initialize invokeStatic "main.clj" 508]
   [clojure.main$null_opt invokeStatic "main.clj" 542]
   [clojure.main$null_opt invoke "main.clj" 539]
   [clojure.main$main invokeStatic "main.clj" 664]
   [clojure.main$main doInvoke "main.clj" 616]
   [clojure.lang.RestFn applyTo "RestFn.java" 137]
   [clojure.lang.Var applyTo "Var.java" 705]
   [clojure.main main "main.java" 40]],
  :cause "capacity < 0: (-689151616 < 0)",
  :phase :execution}}

Failing to load FBX meshes with correct transform. Assimp 5.2.5

2025-05-17T20:14:44Z

I exported a model to fbx format inside 3ds max. Inside Max the scene look like this:

When i import it in my software i get this:
https://youtu.be/WPQnkxzL24g

The meshes transform is wrong. But if I import the max FBX file inside Blender then i export from there I get it right:
https://youtu.be/LBk9CTjSwlo

Here how a model is loaded:

void BaseModel::loadAssimpModel(const std::wstring& path)
{
    // Read file via ASSIMP
    aiPropertyStore* props = aiCreatePropertyStore();
    aiSetImportPropertyInteger(props, AI_CONFIG_PP_SLM_TRIANGLE_LIMIT, MAX_TRIANGLES_PER_MESH);

    const uint32_t flags = aiProcess_Triangulate | aiProcess_CalcTangentSpace;
    const std::string pathStr = Utilities::nativeStringToStdString(path);
    const aiScene* scene = aiImportFileExWithProperties(pathStr.c_str(), flags, NULL, props);

    aiReleasePropertyStore(props);

    // Check for errors
    const nbBool success = scene && scene->mFlags != AI_SCENE_FLAGS_INCOMPLETE && scene->mRootNode;
    assert(success);

    // Process ASSIMP's root node recursively here !!! :)
    processNode(scene, scene->mRootNode, aiMatrix4x4());

    aiReleaseImport(scene);
}

The processNode method is straightforward:

void BaseModel::processNode(const aiScene* scene, aiNode* node, const aiMatrix4x4& transform)
{
    const aiMatrix4x4 accTransform = node->mTransformation * transform;

    // Process each mesh located at the current node.
    if (node->mNumMeshes)
    {
        // Create group.
        DatabaseMeshPtr meshGroup;
        {
            aiMesh* firstMesh = scene->mMeshes[node->mMeshes[0]];

            std::wstring groupName(Utilities::stdStringToNativeString(firstMesh->mName.C_Str()));

            meshGroup = EntityDatabaseSingleton::instance()->createEntity<MeshGroup>();
            meshGroup->setName(groupName);

            meshGroup->m_materialId = m_aiLoadingMaterialIds[firstMesh->mMaterialIndex];

            m_meshGroupIdentifiers.push_back(meshGroup->getIdentifier());
        }

        // Add meshes.
        for (uint32_t i = 0; i < node->mNumMeshes; i++)
        {
            // The node object only contains indices to index the actual objects in the scene. 
            // The scene contains all the data, node is just to keep stuff organized (like relations between nodes).
            aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
            this->addMesh(mesh, accTransform, meshGroup);
        }
    }

    // After we've processed all of the meshes (if any) we then recursively process each of the children nodes
    for (uint32_t i = 0; i < node->mNumChildren; i++)
    {
        this->processNode(scene, node->mChildren[i], accTransform);
    }
}

The addMesh method:

void BaseModel::addMesh(aiMesh* mesh, const aiMatrix4x4& transform, DatabaseMeshPtr meshGroup)
{
    // Data to fill
    VertexArray vertices;
    std::vector<uint32_t> indices;

    // The 3x3 transform.
    const aiMatrix3x3 transform3x3 = aiMatrix3x3(transform);

    // Walk through each of the mesh's vertices
    for (uint32_t i = 0; i < mesh->mNumVertices; i++)
    {
        FullVertex vertex;

        mesh->mVertices[i] = transform * mesh->mVertices[i];

        // Position
        vertex.position.x = mesh->mVertices[i].x;
        vertex.position.y = mesh->mVertices[i].y;
        vertex.position.z = mesh->mVertices[i].z;

        // Normal.
        if (mesh->mNormals)
        {
            mesh->mNormals[i] = transform3x3 * mesh->mNormals[i];

            vertex.normal.x = mesh->mNormals[i].x;
            vertex.normal.y = mesh->mNormals[i].y;
            vertex.normal.z = mesh->mNormals[i].z;
        }

        // Tangent
        if (mesh->mTangents)
        {
            vertex.tangent.x = mesh->mTangents[i].x;
            vertex.tangent.y = mesh->mTangents[i].y;
            vertex.tangent.z = mesh->mTangents[i].z;
        }

        // Bitangent
        if (mesh->mBitangents)
        {
            vertex.bitangent.x = mesh->mBitangents[i].x;
            vertex.bitangent.y = mesh->mBitangents[i].y;
            vertex.bitangent.z = mesh->mBitangents[i].z;
        }

        // Texture Coordinates
        if (mesh->mTextureCoords[0]) // Does the mesh contain texture coordinates?
        {
            // A vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't 
            // use models where a vertex can have multiple texture coordinates so we always take the first set (0).
            vertex.texCoord.x = mesh->mTextureCoords[0][i].x;
            vertex.texCoord.y = mesh->mTextureCoords[0][i].y;
        }

        vertices.push_back(vertex);
    }

    // Now wak through each of the mesh's faces (a face is a mesh its triangle) and retrieve the corresponding vertex indices.
    for (uint32_t i = 0; i < mesh->mNumFaces; i++)
    {
        aiFace face = mesh->mFaces[i];
        // Retrieve all indices of the face and store them in the indices vector
        for (uint32_t j = 0; j < face.mNumIndices; j++)
            indices.push_back(face.mIndices[j]);
    }

    const MeshFlatId meshFlatId = (MeshFlatId)m_flatMeshContainer.size();

    Mesh* nativeMesh = new Mesh(vertices, indices, meshFlatId, meshGroup.get());

    meshGroup->m_meshes.push_back(nativeMesh);
    m_flatMeshContainer.push_back(nativeMesh);
}

Once loading is done vertices are converted to local space. I dont think this is linked to the issue:

for (const EntityIdentifier& entityId : m_meshGroupIdentifiers)
{
    Math::Vec3 center;
    size_t nbVertices = 0u;

    const auto group = getMeshGroupPtr_FromEntity(entityId);

    for (const auto*mesh : group->m_meshes)
    {
        const auto& vertices = mesh->getRealVertices();
        for (auto& vertex : vertices)
            center += vertex.position;

        nbVertices += vertices.size();
    }

    center /= nbVertices;
    for (auto* mesh : group->m_meshes)
    {
        auto& vertices = mesh->getMutableVertices();
        for (auto& vertex : vertices)
            vertex.position -= center;
    }

    group->setPosition(center);
}

The last setPosition call set the worlspace transform of the mesh group. It is used when performing DirectX 12 realtime rendering. This is clearly not the issue:

cbuffer VertexShaderSharedCB : register(b0)
{
    float4x4 vpMat;
};

VS_OUTPUT main(VS_INPUT input, uint instanceID : SV_InstanceID)
{
    VS_OUTPUT output;

    const float4x4 modelMat = meshGroupDatas[instanceID].transform;// transform here!
    const float4 worldPosition = mul(float4(input.position, 1.0f), modelMat);
    output.worldPosition = worldPosition.xyz;
    output.position = mul(worldPosition, vpMat);
    output.texCoord = input.texCoord;
    output.normal = normalize(mul(float4(input.normal, 0.0f), modelMat));
    output.tangent = normalize(mul(float4(input.tangent, 0.0f), modelMat));
    output.bitangent = normalize(mul(float4(input.bitangent, 0.0f), modelMat));

    return output;
}

What am I doing wrong? And especially why the Blender FBX is loaded properly and not the 3ds max one? I am probably missing a transform somewhere. Note that OBJs are always properly loaded ;)

Thanks!
//---------------------------------------------------------------------------------
The 3ds Max FBX file:
https://www.dropbox.com/scl/fi/5rus8jyhz0xbxghrpus67/max_fbx_nope.fbx?rlkey=c2muf2mhcjbizmllqdx0h0wlx&st=6941tiin&dl=0

The Blender FBX file:
https://www.dropbox.com/scl/fi/zv9slsjz41xlx7nanoyy2/blender_fbx_ok.fbx?rlkey=7olvgnbhceik0qm351rj0lbww&st=dwkzsjn6&dl=0

The 3ds Max 2025 native file:
https://www.dropbox.com/scl/fi/pjcv6896uzv6su8992156/native.max?rlkey=yggek65khewpxntm87zchznjc&st=ze7hq6k7&dl=0

Visual Studio 2022 OpenGL Project: 'assimp/Importer.hpp' Not Found Despite Correct Include Path

2025-02-19T14:53:54Z

I keep getting below error during build at #include <assimp/Importer.hpp>
Error: C1083: Cannot open include file: 'assimp/Importer.hpp': No such file or directory

I have tried to clean the solution, rebuild, updated it with the fullpath, nothing is working.

I have been working and building my OpenGL project in Debug-Win32, I wanted to load models, so came across Assimp. Since they do not release the builds anymore, I downloaded the latest release v5.4.3 from GitHub and followed below to build it locally.

Open command promt, and run cmake .\CMakeLists.txt
Once completed, you should be able to see a Assimp.sln
Open the Assimp.sln and selected Debug and it was available for x64 only
Once done, copied the generated lib and bin to my project

Project Setup: Visual Studio 2022
Initially I was using Win32, but since I didnt get latest versions of assimp in win32, I reconfigured project to run on x64 as well, added relevant GLEW, GLFW paths and I was able to run application without any issues.

I added the assimp files to my Dependencies. And then added below configurations:

Include Directory Settings (C/C++ -> General -> Additional Include Directories)

src
src\vendor
Core
$(SolutionDir)Dependencies\GLFW\include
$(SolutionDir)Dependencies\GLEW\include
$(SolutionDir)Dependencies\assimp\include

Verified that $(SolutionDir)Dependencies\assimp\include is actually pointing to correct path.

Library Directories & Linking

Linker -> General -> Additional Library Directories:

$(SolutionDir)Dependencies\GLFW\lib-vc2022
$(SolutionDir)Dependencies\GLEW\lib\Release\x64
$(SolutionDir)Dependencies\assimp\lib\Debug

Linker -> Input -> Additional Dependencies:

assimp-vc143-mtd.lib
glew32s.lib
glfw3.lib
opengl32.lib
User32.lib
Gdi32.lib
Shell32.lib

Why is Visual Studio not finding assimp/Importer.hpp despite it being in the include directory? Is there something wrong with my configuration?

Directory Structure of Assimp


Dependencies/assimp/
├───Debug
├───Dependencies
│   ├───assimp
│   │   ├───bin
│   │   │   └───Debug
│   │   ├───include
│   │   │   └───assimp
│   │   │       ├───Compiler
│   │   │       └───port
│   │   │           └───AndroidJNI
│   │   └───lib
│   │       └───Debug
│   ├───GLEW
│   │   ├───doc
│   │   ├───include
│   │   │   └───GL
│   │   └───lib
│   │       └───Release
│   │           ├───Win32
│   │           └───x64
│   └───GLFW
│       ├───include
│       │   └───GLFW
│       └───lib-vc2022
└───OpenGL
    ├───Core
    ├───res
    └───src (Application.cpp/main)
        ├───tests
        └───vendor
            ├───glm
            ├───imgui
            └───stb_image

Texture mapping issues with Assimp and OpenGL: Some meshes have incorrect UV mapping [closed]

2025-02-03T11:45:12Z

I am trying to load and render 3D models using C++, modern OpenGL (glfw 3.4.0, glad, glm), and the newest Assimp. My model loader is mostly working, but I am encountering an issue where some meshes are not textured correctly.

For example, in this glTF aircraft model, most of the parts are mapped correctly, but the canopy texture is mapped incorrect. Instead of using the correct UV mapping, it appears as if the entire texture for the model is being applied incorrectly. I have disabled blending right now, but the issue persists with or without blending. Also, I only load the diffuse textures right now.

Here is the code of model.cpp:

#include "model.h"

Model::Model(const std::string& file_path) 
{
    load_model(file_path);
}

void Model::load_model(const std::string& file_path) 
{
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(file_path, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs);

    if (!scene || (scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE) || !scene->mRootNode) {
        std::cerr << "Assimp error: " << importer.GetErrorString() << std::endl;
        return;
    }

    directory = file_path.substr(0, file_path.find_last_of("/"));
    process_node(scene->mRootNode, scene);
}

void Model::process_node(aiNode* node, const aiScene* scene) 
{
    for (unsigned int i = 0; i < node->mNumMeshes; i++) {
        aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];

        meshes.push_back(process_mesh(mesh, scene));
    }
    for (unsigned int i = 0; i < node->mNumChildren; i++) {
        process_node(node->mChildren[i], scene);
    }
}

Mesh Model::process_mesh(aiMesh* mesh, const aiScene* scene) 
{
    std::vector<Vertex> vertices;
    std::vector<GLuint> indices;
    std::vector<Texture> textures;

    for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
        Vertex vertex;
        vertex.position = glm::vec3(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z);

        if (mesh->HasNormals()) {
            vertex.normal = glm::vec3(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z);
        }

        if (mesh->mTextureCoords[0]) {
            vertex.tex_coords = glm::vec2(mesh->mTextureCoords[0][i].x, mesh->mTextureCoords[0][i].y);
        } else {
            vertex.tex_coords = glm::vec2(0.0f, 0.0f);
        }

        vertices.push_back(vertex);
    }

    for (unsigned int i = 0; i < mesh->mNumFaces; i++) {
        aiFace face = mesh->mFaces[i];
        for (unsigned int j = 0; j < face.mNumIndices; j++) {
            indices.push_back(face.mIndices[j]);
        }
    }

    aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
    std::vector<Texture> diffuse_maps = load_material_textures(material, aiTextureType_DIFFUSE, "diffuse");
    textures.insert(textures.end(), diffuse_maps.begin(), diffuse_maps.end());
    
    return Mesh(vertices, indices, textures);
}

std::vector<Texture> Model::load_material_textures(aiMaterial* material, aiTextureType type, const std::string& type_name) 
{
    std::vector<Texture> textures;
    
    for (unsigned int i = 0; i < material->GetTextureCount(type); i++) {

        aiString str;
        material->GetTexture(type, i, &str);

        bool skip = false;
        for (const auto& loaded_texture : textures_loaded) {
            if (std::strcmp(loaded_texture.path.data(), str.C_Str()) == 0) {
                textures.push_back(loaded_texture);
                skip = true;
                break;
            }
        }
        if (!skip) {
            Texture texture;
            texture.id = load_texture_from_file(str.C_Str(), directory);
            texture.type = type_name;
            texture.path = str.C_Str();
            textures.push_back(texture);
            textures_loaded.push_back(texture);
        }
    }
    return textures;
}

void Model::render(Shader& shader, Camera& camera) {
    for (auto& mesh : meshes) {
        mesh.render(shader, camera);
    }
}

GLuint load_texture_from_file(const char* file_path, const std::string& directory) 
{
    std::string file_name = directory + "/" + file_path;
    GLuint texture_id;
    glGenTextures(1, &texture_id);

    int width, height, number_of_color_channels;
    unsigned char* data = stbi_load(file_name.c_str(), &width, &height, &number_of_color_channels, 0);
    if (data) {
        GLenum format = (number_of_color_channels == 1) ? GL_RED : (number_of_color_channels == 3) ? GL_RGB : GL_RGBA;
        glBindTexture(GL_TEXTURE_2D, texture_id);
        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        stbi_image_free(data);
    } else {
        std::cerr << "Texture failed to load: " << file_path << std::endl;
        stbi_image_free(data);
    }

    std::cout << file_name << "\n";

    return texture_id;
}

And here is the code of mesh.cpp:

#include "mesh.h"
#include <iostream>

Mesh::Mesh(std::vector <Vertex>& vertices, std::vector <GLuint>& indices, std::vector <Texture>& textures) 
{
    Mesh::vertices = vertices;
    Mesh::indices = indices;
    Mesh::textures = textures;

    GLuint vbo_id, ebo_id;

    glGenVertexArrays(1, &vao_id);
    glGenBuffers(1, &vbo_id);
    glGenBuffers(1, &ebo_id);

    glBindVertexArray(vao_id);

    glBindBuffer(GL_ARRAY_BUFFER, vbo_id);

    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);  

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo_id);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint), &indices[0], GL_STATIC_DRAW);

    glEnableVertexAttribArray(0);   
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);

    glEnableVertexAttribArray(1);   
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, normal));

    glEnableVertexAttribArray(2);   
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, tex_coords));
}

void Mesh::render(Shader& shader_program, Camera& camera) 
{
    shader_program.use();

    unsigned int diffuse_number = 0;
    unsigned int specular_number = 0;
    unsigned int normal_number = 0;

    for (unsigned int i = 0;  i < textures.size(); i++)
    {
        glActiveTexture(GL_TEXTURE0 + i);
        
        std::string number;
        std::string type = textures[i].type;

        if (type == "diffuse")
        {
            number = std::to_string(diffuse_number++);  
        }

        else if (type == "specular")
        {
           number = std::to_string(specular_number++);
        }

        else if (type == "normal")
        {
           number = std::to_string(normal_number++);
        }

        glUniform1i(glGetUniformLocation(shader_program.id, (type + number).c_str()), i);
        glBindTexture(GL_TEXTURE_2D, textures[i].id);
    }

    glBindVertexArray(vao_id);
    glDrawElements(GL_TRIANGLES, static_cast<unsigned int>(indices.size()), GL_UNSIGNED_INT, 0);

    glBindVertexArray(0);
    glActiveTexture(GL_TEXTURE0);
}

Vertex shader:

#version 330 core

layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
layout (location = 2) in vec2 aTexCoord;

out vec3 crntPos;
out vec3 Normal;
out vec2 texCoord;

uniform mat4 view;
uniform mat4 proj;
uniform mat4 model;

void main()
{
    crntPos = vec3(model * vec4(aPos, 1.0f));

    Normal = mat3(transpose(inverse(model))) * aNormal;

    texCoord = aTexCoord;

    gl_Position = proj * view * model * vec4(aPos, 1.0);
}

Fragment shader:

#version 330 core

out vec4 FragColor;

in vec3 crntPos;
in vec3 Normal;
in vec2 texCoord;

uniform sampler2D diffuse0;

uniform vec4 lightColor;
uniform vec3 camPos;

void main()
{
    float ambient = 0.20f;
    vec3 lightDirection = vec3(0.0f, 1.0f, 0.0f);

    vec3 normal = normalize(Normal);

    float diffuse = max(dot(normal, lightDirection), 0.0f);

    FragColor = texture(diffuse0, texCoord) * lightColor * (diffuse + ambient);
}

I have tried to change the flags from assimp like aiProcess_FlipUVs or aiProcess_GenUVCoords, but nothing worked. I also tried GL_CLAMP_TO_EDGE instead of GL_REPEAT. I think that the correct texture files are loaded.

C++/Raylib - Unable to load mesh with Assimp

2024-12-18T00:55:22Z

I want to preload 3d obj files before I run InitWindow from Raylib by preloading with assimp. So I have the following code:

std::vector<Mesh> preloadedMeshes;    // Store preloaded meshes
std::vector<Model> terrainTiles;      // Models created from the preloaded meshes

// Function to load meshes with Assimp
Mesh LoadMeshWithAssimp(const std::string& filePath) {
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(filePath, aiProcess_Triangulate | aiProcess_FlipUVs);

    if (!scene || !scene->HasMeshes()) {
        throw std::runtime_error("Failed to load mesh: " + filePath);
    }

    aiMesh* ai_mesh = scene->mMeshes[0]; // Assume a single mesh for simplicity

    Mesh mesh = { 0 };
    mesh.vertexCount = ai_mesh->mNumVertices;
    mesh.triangleCount = ai_mesh->mNumFaces;

    // Allocate and copy vertex positions (CPU memory)
    mesh.vertices = (float*)MemAlloc(mesh.vertexCount * 3 * sizeof(float));
    for (unsigned int i = 0; i < mesh.vertexCount; i++) {
        mesh.vertices[i * 3 + 0] = ai_mesh->mVertices[i].x;
        mesh.vertices[i * 3 + 1] = ai_mesh->mVertices[i].y;
        mesh.vertices[i * 3 + 2] = ai_mesh->mVertices[i].z;
    }

    // Allocate and copy normals (CPU memory)
    if (ai_mesh->HasNormals()) {
        mesh.normals = (float*)MemAlloc(mesh.vertexCount * 3 * sizeof(float));
        for (unsigned int i = 0; i < mesh.vertexCount; i++) {
            mesh.normals[i * 3 + 0] = ai_mesh->mNormals[i].x;
            mesh.normals[i * 3 + 1] = ai_mesh->mNormals[i].y;
            mesh.normals[i * 3 + 2] = ai_mesh->mNormals[i].z;
        }
    }

    // Allocate and copy texture coordinates (CPU memory)
    if (ai_mesh->HasTextureCoords(0)) {
        mesh.texcoords = (float*)MemAlloc(mesh.vertexCount * 2 * sizeof(float));
        for (unsigned int i = 0; i < mesh.vertexCount; i++) {
            mesh.texcoords[i * 2 + 0] = ai_mesh->mTextureCoords[0][i].x;
            mesh.texcoords[i * 2 + 1] = ai_mesh->mTextureCoords[0][i].y;
        }
    }

    // Allocate and copy indices (CPU memory)
    mesh.indices = (unsigned short*)MemAlloc(mesh.triangleCount * 3 * sizeof(unsigned short));
    for (unsigned int i = 0; i < mesh.triangleCount; i++) {
        mesh.indices[i * 3 + 0] = (unsigned short)ai_mesh->mFaces[i].mIndices[0];
        mesh.indices[i * 3 + 1] = (unsigned short)ai_mesh->mFaces[i].mIndices[1];
        mesh.indices[i * 3 + 2] = (unsigned short)ai_mesh->mFaces[i].mIndices[2];
    }

    return mesh; // CPU-side Mesh, not yet uploaded
}



// Preload meshes before initializing OpenGL
void PreloadMeshes() {
    try {
        preloadedMeshes.push_back(LoadMeshWithAssimp("resources/models/Farabale_0.obj"));
        preloadedMeshes.push_back(LoadMeshWithAssimp("resources/models/Farabale_1.obj"));
        preloadedMeshes.push_back(LoadMeshWithAssimp("resources/models/Farabale_2.obj"));
        preloadedMeshes.push_back(LoadMeshWithAssimp("resources/models/Farabale_3.obj"));
    } catch (const std::exception& e) {
        TraceLog(LOG_ERROR, e.what());
    }
}

// Upload meshes to GPU and create models
void CreateModelsFromMeshes() {
    for (auto& mesh : preloadedMeshes) {
        UploadMesh(&mesh, true);  // Upload the mesh to GPU
        Model model = LoadModelFromMesh(mesh);
        terrainTiles.push_back(model);
    }
}

And if I do the following:

const int screenWidth = 1280;
const int screenHeight = 720;
Vector3 unityPosition = (Vector3){-189.29, 105.66, 68.22};
PreloadMeshes();
InitWindow(screenWidth, screenHeight, "Dear ImGui Raylib(OpenGL) example");
CreateModelsFromMeshes();

I can see very weird obj files loaded. Take a look:

But if I comment out and call loading of obj by the LoadModel function provided from raylib I see the scene perfectly fine:

PreloadMeshes();
InitWindow(screenWidth, screenHeight, "Dear ImGui Raylib(OpenGL) example");
//CreateModelsFromMeshes();

terrainTiles.push_back(LoadModel("resources/models/Farabale_0.obj"));
terrainTiles.push_back(LoadModel("resources/models/Farabale_1.obj"));
terrainTiles.push_back(LoadModel("resources/models/Farabale_2.obj"));
terrainTiles.push_back(LoadModel("resources/models/Farabale_3.obj"));

Produces this:

So as you can see no weird artifacts. Why is that? What am I doing wrong with Assimp ?

Assimp .NET Model Animation went wrong (DEFAULT VALUES?)

2024-12-14T20:28:30Z

I made today a skinned mesh, and i tried out my Blockbench model with a animation and saw that the keyframes of this model that set to 0 not set into the model, so my question is now how can i reproduce the empty positions, roations, scale for my model.

For Blender everything works fine because they even set the default values in the model, but with Blockbench i need to reproduce this values.

This is my Code:

using Assimp;
using Bliss.CSharp.Geometry.Animations.Bones;
using Bliss.CSharp.Geometry.Conversions;
using Bliss.CSharp.Logging;
using AMatrix4x4 = Assimp.Matrix4x4;
using Matrix4x4 = System.Numerics.Matrix4x4;
using AQuaternion = Assimp.Quaternion;

namespace Bliss.CSharp.Geometry.Animations;

public class MeshAmateurBuilder {

    private Node _rootNode;
    private ModelAnimation[] _animations;
    
    private Dictionary<uint, Bone> _bonesByName;
    private Matrix4x4[] _boneTransformations;
    
    /// <summary>
    /// Initializes a new instance of the <see cref="MeshAmateurBuilder"/> class with a root node and animations.
    /// </summary>
    /// <param name="rootNode">The root <see cref="Node"/> representing the hierarchical structure of the mesh.</param>
    /// <param name="animations">An array of <see cref="ModelAnimation"/> objects defining animations for the mesh.</param>
    public MeshAmateurBuilder(Node rootNode, ModelAnimation[] animations) {
        this._rootNode = rootNode;
        this._animations = animations;
    }

    /// <summary>
    /// Constructs a dictionary containing bone information mapped by animation name and frame index.
    /// </summary>
    /// <param name="bonesByName">A dictionary mapping bone identifiers to bone objects.</param>
    /// <returns>A dictionary where keys are animation names, and values are dictionaries that map frame indices to arrays of bone information.</returns>
    public Dictionary<string, Dictionary<int, BoneInfo[]>> Build(Dictionary<uint, Bone> bonesByName) {
        this._bonesByName = bonesByName;
        this._boneTransformations = new Matrix4x4[bonesByName.Count];
        
        Dictionary<string, Dictionary<int, BoneInfo[]>> boneInfos = new Dictionary<string, Dictionary<int, BoneInfo[]>>();
        
        foreach (ModelAnimation animation in this._animations) {
            boneInfos.Add(animation.Name, this.SetupBoneInfos(animation));
        }

        return boneInfos;
    }

    /// <summary>
    /// Generates a dictionary that maps frame indices to arrays of <see cref="BoneInfo"/> for a given animation.
    /// </summary>
    /// <param name="animation">The animation for which bone information is being set up.</param>
    /// <returns>A dictionary with frame indices as keys and arrays of <see cref="BoneInfo"/> as values.</returns>
    private Dictionary<int, BoneInfo[]> SetupBoneInfos(ModelAnimation animation) {
        Dictionary<int, BoneInfo[]> bones = new Dictionary<int, BoneInfo[]>();
        
        for (int i = 0; i < animation.FrameCount; i++) {
            List<BoneInfo> boneInfos = new List<BoneInfo>();
            
            this.UpdateChannel(this._rootNode, animation, i, AMatrix4x4.Identity);

            for (uint boneId = 0; boneId < this._boneTransformations.Length; boneId++) {
                BoneInfo boneInfo = new BoneInfo(this._bonesByName[boneId].Name, boneId, this._boneTransformations[boneId]);
                boneInfos.Add(boneInfo);
            }
            
            bones.Add(i, boneInfos.ToArray());
        }

        return bones;
    }

    /// <summary>
    /// Updates the transformation channel of a specified node based on the animation data and current frame index.
    /// </summary>
    /// <param name="node">The node whose transformation channel is to be updated.</param>
    /// <param name="animation">The animation containing the transformation data.</param>
    /// <param name="frame">The current frame index being processed.</param>
    /// <param name="parentTransform">The transformation matrix of the parent node.</param>
    private void UpdateChannel(Node node, ModelAnimation animation, int frame, AMatrix4x4 parentTransform) {
        AMatrix4x4 nodeTransformation = AMatrix4x4.Identity;

        if (this.GetChannel(node, animation, out NodeAnimationChannel? channel)) {
            AMatrix4x4 scale = this.InterpolateScale(channel!, animation, frame);
            AMatrix4x4 rotation = this.InterpolateRotation(channel!, animation, frame);
            AMatrix4x4 translation = this.InterpolateTranslation(channel!, animation, frame);
            
            nodeTransformation = scale * rotation * translation;
        }

        foreach (uint boneId in this._bonesByName.Keys) {
            Bone bone = this._bonesByName[boneId];
            
            if (node.Name == bone.Name) {
                AMatrix4x4 rootInverseTransform = this._rootNode.Transform;
                rootInverseTransform.Inverse();
                
                AMatrix4x4 transformation = bone.OffsetMatrix * nodeTransformation * parentTransform * rootInverseTransform;
                this._boneTransformations[boneId] = Matrix4x4.Transpose(ModelConversion.FromAMatrix4X4(transformation));
            }
        }

        foreach (Node childNode in node.Children) {
            this.UpdateChannel(childNode, animation, frame, nodeTransformation * parentTransform);
        }
    }

    /// <summary>
    /// Interpolates the translation transformation at a specific frame using the provided animation channel and animation data.
    /// </summary>
    /// <param name="channel">The <see cref="NodeAnimationChannel"/> containing position keys for the node.</param>
    /// <param name="animation">The <see cref="ModelAnimation"/> containing the animation data, including timing information.</param>
    /// <param name="frame">The current frame for which the translation is being interpolated.</param>
    /// <returns>An <see cref="Assimp.Matrix4x4"/> representing the interpolated translation transformation for the given frame.</returns>
    private AMatrix4x4 InterpolateTranslation(NodeAnimationChannel channel, ModelAnimation animation, int frame) {
        double frameTime = frame / 60.0F * animation.TicksPerSecond;
        Vector3D position;
        
        if (channel.PositionKeyCount == 1) {
            position = channel.PositionKeys[0].Value;
        }
        else {
            uint frameIndex = 0;
            for (uint i = 0; i < channel.PositionKeyCount - 1; i++) {
                if (frameTime < channel.PositionKeys[(int) (i + 1)].Time) {
                    frameIndex = i;
                    break;
                }
            }

            VectorKey currentFrame = channel.PositionKeys[(int) frameIndex];
            VectorKey nextFrame = channel.PositionKeys[(int) ((frameIndex + 1) % channel.PositionKeyCount)];

            double delta = (frameTime - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);

            Vector3D start = currentFrame.Value;
            Vector3D end = nextFrame.Value;
            position = start + (float) delta * (end - start);
        }
        
        return AMatrix4x4.FromTranslation(position);
    }

    /// <summary>
    /// Interpolates the rotation transformation for a given node animation channel at a specified frame.
    /// </summary>
    /// <param name="channel">The <see cref="NodeAnimationChannel"/> containing the rotation keyframes for the node.</param>
    /// <param name="animation">The <see cref="ModelAnimation"/> object defining the overall animation data.</param>
    /// <param name="frame">The current frame for which the rotation needs to be interpolated.</param>
    /// <returns>An <see cref="AMatrix4x4"/> representing the interpolated rotation transformation matrix for the specified frame.</returns>
    private AMatrix4x4 InterpolateRotation(NodeAnimationChannel channel, ModelAnimation animation, int frame) {
        double frameTime = frame / 60.0F * animation.TicksPerSecond;
        AQuaternion rotation;

        if (channel.RotationKeyCount == 1) {
            rotation = channel.RotationKeys[0].Value;
        }
        else {
            uint frameIndex = 0;
            for (uint i = 0; i < channel.RotationKeyCount - 1; i++) {
                if (frameTime < channel.RotationKeys[(int) (i + 1)].Time) {
                    frameIndex = i;
                    break;
                }
            }

            QuaternionKey currentFrame = channel.RotationKeys[(int) frameIndex];
            QuaternionKey nextFrame = channel.RotationKeys[(int) ((frameIndex + 1) % channel.RotationKeyCount)];

            double delta = (frameTime - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);

            AQuaternion start = currentFrame.Value;
            AQuaternion end = nextFrame.Value;
            rotation = AQuaternion.Slerp(start, end, (float) delta);
            rotation.Normalize();
        }
        
        return rotation.GetMatrix();
    }

    /// <summary>
    /// Computes the interpolated scale transformation for a given animation channel at a specific frame.
    /// </summary>
    /// <param name="channel">The <see cref="NodeAnimationChannel"/> containing scaling keyframes.</param>
    /// <param name="animation">The <see cref="ModelAnimation"/> associated with the animation data.</param>
    /// <param name="frame">The current frame of the animation for which the scale transformation is calculated.</param>
    /// <returns>An <see cref="AMatrix4x4"/> representing the interpolated scale transformation at the specified frame.</returns>
    private AMatrix4x4 InterpolateScale(NodeAnimationChannel channel, ModelAnimation animation, int frame) {
        double frameTime = frame / 60.0F * animation.TicksPerSecond;
        Vector3D scale;

        if (channel.ScalingKeyCount == 1) {
            scale = channel.ScalingKeys[0].Value;
        }
        else {
            uint frameIndex = 0;
            for (uint i = 0; i < channel.ScalingKeyCount - 1; i++) {
                if (frameTime < channel.ScalingKeys[(int) (i + 1)].Time) {
                    frameIndex = i;
                    break;
                }
            }

            VectorKey currentFrame = channel.ScalingKeys[(int)frameIndex];
            VectorKey nextFrame = channel.ScalingKeys[(int)((frameIndex + 1) % channel.ScalingKeyCount)];

            double delta = (frameTime - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);

            Vector3D start = currentFrame.Value;
            Vector3D end = nextFrame.Value;

            scale = start + (float) delta * (end - start);
        }
        
        return AMatrix4x4.FromScaling(scale);
    }

    /// <summary>
    /// Retrieves the animation channel for a given node from the specified animation.
    /// </summary>
    /// <param name="node">The node for which the animation channel should be retrieved.</param>
    /// <param name="animation">The animation containing the channels to check.</param>
    /// <param name="channel">The output parameter that will hold the retrieved node animation channel if found; otherwise, null.</param>
    /// <returns>True if the channel for the specified node is found in the animation; otherwise, false.</returns>
    private bool GetChannel(Node node, ModelAnimation animation, out NodeAnimationChannel? channel) {
        foreach (NodeAnimationChannel nodeChannel in animation.AnimationChannels) {
            if (nodeChannel.NodeName == node.Name) {
                channel = nodeChannel;
                return true;
            }
        }

        channel = null;
        return false;
    }
}

What am I doing wrong when loading a skeleton and animation?

2024-11-06T12:26:10Z

I am trying to load an animation and skeleton using assimp. Im not sure if im doing the matrix multiplication correct or if I'm missing a Inverse or transpose somewhere. My engine is using a lefthanded coordinate system, using row-major matrices.

Gif of how its currently looking.

Im storing the animation and skeleton in the structure below.

struct Skeleton
{
    struct Joint
    {
        Matrix4x4f BindPoseInverse;
        int ParentIdx;
        std::vector<int> Children;
        std::string Name;
    };

    std::vector<Joint> Joints;
    std::unordered_map<std::string, size_t> JointNameToIndex;
};


struct Animation
{
    struct Frame
    {
        std::unordered_map<
            std::string,
            Matrix4x4f
        > Transforms;
    };
    std::vector<Frame> Frames;
    float Duration;
    float FramesPerSecond;
};

Code from the importer.

Mesh* MeshFactory::LoadMesh(const char* aMeshPath)
{
    static int flags = aiProcess_Triangulate |
        aiProcess_FlipUVs |
        aiProcess_GenSmoothNormals |
        aiProcess_CalcTangentSpace |
        aiProcess_MakeLeftHanded |
        aiProcess_FlipWindingOrder;

    Assimp::Importer importer;
    importer.SetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, false);
    importer.SetPropertyInteger(AI_CONFIG_PP_LBW_MAX_WEIGHTS, 4);

    const aiScene* scene = importer.ReadFile(aMeshPath, flags);


    Mesh* _mesh = new Mesh;
    unsigned int vertexOffset = 0;

    auto myMAtrixToassimp = [](aiMatrix4x4 aiMat) {
        Matrix4x4f mat;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                mat(i + 1, j + 1) = aiMat[i][j];
            }
        }
        return mat;
        };

    if (scene->mNumMeshes == 0 && scene->mNumAnimations > 0)
    {
        Animation* anim = LoadAnimation(scene);
        AnimationFactory::GetInstance()->AddAnimation(anim);
    }
    else
    {
        for (unsigned int i = 0; i < scene->mNumMeshes; ++i)
        {
            aiMesh* mesh = scene->mMeshes[i];

            for (unsigned int v = 0; v < mesh->mNumVertices; ++v)
            {
                aiVector3D vertex = mesh->mVertices[v];

                aiVector3D normal = mesh->HasNormals() ? mesh->mNormals[v] : aiVector3D(0, 0, 0);
                aiVector3D uv = mesh->HasTextureCoords(0) ? mesh->mTextureCoords[0][v] : aiVector3D(0, 0, 0);
                aiVector3D tangent = mesh->HasTangentsAndBitangents() ? mesh->mTangents[v] : aiVector3D(0, 0, 0);
                aiVector3D bitangent = mesh->HasTangentsAndBitangents() ? mesh->mBitangents[v] : aiVector3D(0, 0, 0);

                Vertex vert =
                {
                    {vertex.x, vertex.y, vertex.z, 1.f},
                    {1.f, 1.f, 1.f, 1.f},
                    {normal.x, normal.y, normal.z, 1.f},
                    {tangent.x, tangent.y, tangent.z, 1.f},
                    {bitangent.x, bitangent.y, bitangent.z, 1.f},
                    {0,0,0,0},
                    {0.f,0.f,0.f,0.f},
                    {uv.x, uv.y},
                };

                _mesh->AddVertex(vert);
            }

            for (unsigned int f = 0; f < mesh->mNumFaces; ++f)
            {
                aiFace face = mesh->mFaces[f];
                if (face.mNumIndices == 3)
                {
                    _mesh->AddFace(face.mIndices[0] + vertexOffset, face.mIndices[1] + vertexOffset, face.mIndices[2] + vertexOffset);
                }
            }

            vertexOffset += mesh->mNumVertices;
        }

        if (scene->HasAnimations())
        {
            _mesh->mySkeleton = LoadSkeleton(scene, *_mesh);
            ExtractBoneWeights(scene, *_mesh);
        }
    }

    if (_mesh != nullptr)
    {
        _mesh->SetName(aMeshPath);
        myMeshes[aMeshPath] = _mesh;
    }

    return _mesh;
}



Skeleton* MeshFactory::LoadSkeleton(const aiScene* aScene, Mesh& aMesh)
{
    auto myMAtrixToassimp = [](aiMatrix4x4 aiMat) {
        Matrix4x4f mat;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                mat(i + 1, j + 1) = aiMat[i][j];
            }
        }

        for (int i = 0; i < 3; i++)
        {
            mat(i + 1, 4) = 0;
        }
        mat(4, 4) = 1;


        return mat;
        };

    Skeleton* skeleton = new Skeleton();

    for (unsigned int i = 0; i < aScene->mNumMeshes; ++i) 
    {
        aiMesh* mesh = aScene->mMeshes[i];

        for (unsigned int j = 0; j < mesh->mNumBones; ++j) 
        {
            aiBone* aiBone = mesh->mBones[j];
            std::string boneName = aiBone->mName.C_Str();

            if (skeleton->JointNameToIndex.find(boneName) == skeleton->JointNameToIndex.end()) 
            {
                Skeleton::Joint joint;
                joint.Name = boneName;
                joint.BindPoseInverse = myMAtrixToassimp(aiBone->mOffsetMatrix).GetInverse();

                size_t jointIndex = skeleton->Joints.size();
                skeleton->JointNameToIndex[boneName] = jointIndex;
                skeleton->Joints.push_back(joint);
            }
        }
    }

    std::function<void(aiNode*, int)> processNode = [&](aiNode* node, int parentIndex)
        {
            std::string nodeName = node->mName.C_Str();

            if (skeleton->JointNameToIndex.find(nodeName) != skeleton->JointNameToIndex.end())
            {
                size_t jointIndex = skeleton->JointNameToIndex[nodeName];
                Skeleton::Joint& joint = skeleton->Joints[jointIndex];

                joint.ParentIdx = parentIndex;

                // Set up parent-child relationship
                if (parentIndex != -1)
                {
                    skeleton->Joints[parentIndex].Children.push_back(jointIndex);
                }

                parentIndex = static_cast<int>(jointIndex);
            }

            for (unsigned int i = 0; i < node->mNumChildren; ++i)
            {
                processNode(node->mChildren[i], parentIndex);
            }
        };

    processNode(aScene->mRootNode, -1);

    return skeleton;
}


Animation* MeshFactory::LoadAnimation(const aiScene* aScene)
{
    aiAnimation* aiAnim = aScene->mAnimations[0];

    Animation* animation = new Animation();
    float ticksPerSecond = aiAnim->mTicksPerSecond > 0.0 ? static_cast<float>(aiAnim->mTicksPerSecond) : 24.0f;
    animation->Duration = static_cast<float>(aiAnim->mDuration) / ticksPerSecond;

    animation->FramesPerSecond = ticksPerSecond;

    int totalFrames = static_cast<int>(animation->Duration * animation->FramesPerSecond);
    animation->Frames.resize(totalFrames);

    for (unsigned int channelIndex = 0; channelIndex < aiAnim->mNumChannels; ++channelIndex)
    {
        aiNodeAnim* channel = aiAnim->mChannels[channelIndex];
        std::string jointName = channel->mNodeName.C_Str();

        for (int frameIndex = 0; frameIndex < totalFrames; ++frameIndex) 
        {
            float timeInTicks = (frameIndex / animation->FramesPerSecond) * aiAnim->mTicksPerSecond;


            aiVector3D position;
            if (channel->mNumPositionKeys == 1) 
            {
                position = channel->mPositionKeys[0].mValue;
            }
            else 
            {
                for (unsigned int i = 0; i < channel->mNumPositionKeys - 1; i++) 
                {
                    if (timeInTicks < channel->mPositionKeys[i + 1].mTime) 
                    {
                        aiVectorKey key1 = channel->mPositionKeys[i];
                        aiVectorKey key2 = channel->mPositionKeys[i + 1];
                        float factor = (timeInTicks - key1.mTime) / (key2.mTime - key1.mTime);
                        position = key1.mValue + (key2.mValue - key1.mValue) * factor;
                        break;
                    }
                }
            }


            aiQuaternion rotation;
            if (channel->mNumRotationKeys == 1) 
            {
                rotation = channel->mRotationKeys[0].mValue;
            }
            else 
            {
                for (unsigned int i = 0; i < channel->mNumRotationKeys - 1; i++) 
                {
                    if (timeInTicks < channel->mRotationKeys[i + 1].mTime) 
                    {
                        aiQuatKey key1 = channel->mRotationKeys[i];
                        aiQuatKey key2 = channel->mRotationKeys[i + 1];
                        float factor = (timeInTicks - key1.mTime) / (key2.mTime - key1.mTime);
                        aiQuaternion::Interpolate(rotation, key1.mValue, key2.mValue, factor);
                        rotation.Normalize();
                        break;
                    }
                }
            }


            aiVector3D scale;
            if (channel->mNumScalingKeys == 1)
            {
                scale = channel->mScalingKeys[0].mValue;
            }
            else
            {
                for (unsigned int i = 0; i < channel->mNumScalingKeys - 1; i++)
                {
                    if (timeInTicks < channel->mScalingKeys[i + 1].mTime)
                    {
                        aiVectorKey key1 = channel->mScalingKeys[i];
                        aiVectorKey key2 = channel->mScalingKeys[i + 1];
                        float factor = (timeInTicks - key1.mTime) / (key2.mTime - key1.mTime);
                        scale = key1.mValue + (key2.mValue - key1.mValue) * factor;
                        break;
                    }
                }
            }


            Matrix4x4f translationMat;
            translationMat.SetPosition({ position.x, position.y, position.z, 1.f });

            Matrix4x4f rotationMat;
            {
                float x = rotation.x;
                float y = rotation.y;
                float z = rotation.z;
                float w = rotation.w;

                float xx = x * x;
                float yy = y * y;
                float zz = z * z;
                float xy = x * y;
                float xz = x * z;
                float yz = y * z;
                float wx = w * x;
                float wy = w * y;
                float wz = w * z;

                float r11 = 1.0f - 2.0f * (yy + zz);
                float r12 = 2.0f * (xy - wz);
                float r13 = 2.0f * (xz + wy);

                float r21 = 2.0f * (xy + wz);
                float r22 = 1.0f - 2.0f * (xx + zz);
                float r23 = 2.0f * (yz - wx);

                float r31 = 2.0f * (xz - wy);
                float r32 = 2.0f * (yz + wx);
                float r33 = 1.0f - 2.0f * (xx + yy);

                rotationMat(1, 1) = r11;
                rotationMat(1, 2) = r12;
                rotationMat(1, 3) = r13;
                rotationMat(1, 4) = 0;

                rotationMat(2, 1) = r21;
                rotationMat(2, 2) = r22;
                rotationMat(2, 3) = r23;
                rotationMat(2, 4) = 0;

                rotationMat(3, 1) = r31;
                rotationMat(3, 2) = r32;
                rotationMat(3, 3) = r33;
                rotationMat(3, 4) = 0;

                rotationMat = rotationMat.GetTranspose();
            }

            Matrix4x4f scaleMat;
            scaleMat = Matrix4x4f::CreateScaleMatrix({ scale.x, scale.y, scale.z, 0.f });

            Matrix4x4f finalTransform = translationMat * rotationMat ;


            animation->Frames[frameIndex].Transforms[jointName] = finalTransform;
        }
    }

    return animation;
}

void MeshFactory::ExtractBoneWeights(const aiScene* aScene, Mesh& aMesh)
{
    if (!aScene) return;

    for (unsigned int m = 0; m < aScene->mNumMeshes; ++m)
    {
        const aiMesh* mesh = aScene->mMeshes[m];

        if (mesh->mNumBones > 0)
        {
            for (unsigned int b = 0; b < mesh->mNumBones; ++b)
            {
                aiBone* bone = mesh->mBones[b];

                for (unsigned int w = 0; w < bone->mNumWeights; ++w)
                {
                    unsigned int vertexId = bone->mWeights[w].mVertexId; 
                    float weight = bone->mWeights[w].mWeight; 

                    if (vertexId < aMesh.m_Verticies.size())
                    {
                        Vertex& vertex = aMesh.m_Verticies[vertexId];

                        for (size_t i = 0; i < 4; i++)
                        {
                            if (vertex.BoneWeights[i] == 0)
                            {
                                vertex.BoneIDs[i] = b; 
                                vertex.BoneWeights[i] = weight; 
                            }
                        }
                    }
                }
            }
        }
    }

    for (Vertex& vertex : aMesh.m_Verticies)
    {
        float totalWeight = 0.0f;

        for (int i = 0; i < 4; i++)
        {
            totalWeight += vertex.BoneWeights[i];
        }

        if (totalWeight > 0.0f)
        {
            for (int i = 0; i < 4; i++)
            {
                vertex.BoneWeights[i] /= totalWeight;
            }
        }
        else
        {
            for (int i = 0; i < 4; i++)
            {
                vertex.BoneWeights[i] = 0.0f;
            }
        }
    }
}

Code from the animator.

void Animator::UpdateAnimator(unsigned aJointID, const Matrix4x4f& aParentJointTransform, AnimationBuffer& aOutAnimationBuffer)
{
    const std::string& jointName = mySkeleton->Joints[aJointID].Name;
    const Matrix4x4f& bindPoseInverse = mySkeleton->Joints[aJointID].BindPoseInverse;
    const Matrix4x4f& jointLocalTransform = myCurrentAnimation->Frames[myCurrentFrame].Transforms[jointName];

    Matrix4x4f transform = jointLocalTransform * aParentJointTransform;
    Matrix4x4f globalJointTransform = bindPoseInverse * transform;

    aOutAnimationBuffer.JointTransforms[aJointID] = globalJointTransform;

    for (unsigned childJointID : mySkeleton->Joints[aJointID].Children)
    {
        UpdateAnimator(childJointID, globalJointTransform, aOutAnimationBuffer);
    }
}

Im not sure what im expecting. Expecting it to work? hehe.

But I've tried changing the order of how im multiplying the matricies and tried getting inverse and transpose of them.

Strange relative paths containing "0\0" or "1\0" cutting off the first 3 characters of path while working with Blender, Assimp.NET and FBX files

2024-10-30T13:10:11Z

I am trying to make a program to merge fbx models. Each model have multiple nodes. Some of the nodes have a specific name meaning that those are functioning as connection points for other models.

I already solved pretty much everything regarding the merge, except for the problem of textures. Mesh and material indexes has been updated, but when it come to textures, which are referenced by materials as file paths, I encountered a strange problem. To solve the problem of merging models with different full paths, textures cause a problem, since they are referenced with relative paths to the model file.

When loaded with the basic code below:

// Initialize the Assimp context
AssimpContext importer = new AssimpContext();

// Load the model with desired post-processing flags
Scene model = importer.ImportFile(filePath, PostProcessPreset.TargetRealTimeMaximumQuality | 
                                            PostProcessSteps.Triangulate |
                                            PostProcessSteps.FlipUVs |
                                            PostProcessSteps.EmbedTextures |
                                            PostProcessSteps.GlobalScale |
                                            PostProcessSteps.ValidateDataStructure);

The paths stored by the material looks very strange. For example a relative path of the file "Normal.jpg" in the same folder as the fbx file itself gets stored as "*1\0mal.jpg", another one in a .fbm subfolder named "GPV-2.fbm\BaseColor.jpg" as "*0\0-2 BG.fbm\BaseColor.jpg". To me it looks like the first 3 character gets overwritten at some point during import.

I use the Assimp.NET 5.0.0-beta1 package.

Has someone seen anything like this before? What is the reason the paths look like this and how can I solve it?

Since Assimp.NET has no problem loading the textures I guess the paths are good during the import. Perhaps I could somehow get the fullpath out of assimp?

Path.Combine Does not work. I tried to manually cut the pieces, but the missing characters still cause a problem, and I would try file search if nothing else would work.

I tried to look into Assimp code, but couldn't find exactly how it imports.

I also tried to discuss it with ChatGPT, but couldn't solve it either, neither could it give me pointers where to look.

How can I use assimp's aiMeshMorphKey to animate a character's facial expressions?

2024-08-30T16:19:02Z

I'm trying to implement facial expressions using morph animation in my 3D application. I've been looking into the assimp library and found the aiMeshMorphKey structure within the aiAnimation. Could you provide a code example demonstrating how to use aiMeshMorphKey to create morph animations, such as changing a character's facial expression over time?

    for (int i = 0; i < pAnimation->mNumMorphMeshChannels; ++i)
    {
        if (nodeName + "*0" == pAnimation->mMorphMeshChannels[i]->mName.C_Str())
        {
            std::map<float, glm::mat4> morphMeshKeys;
            for (int j = 0; j < pAnimation->mMorphMeshChannels[i]->mNumKeys; ++j)
            {
                std::cout << pAnimation->mMorphMeshChannels[i]->mName.data << std::endl;
                std::cout << pAnimation->mMorphMeshChannels[i]->mKeys[j].mTime << std::endl;
                std::cout << pAnimation->mMorphMeshChannels[i]->mKeys->mValues << std::endl;
                std::cout << pAnimation->mMorphMeshChannels[i]->mKeys->mWeights << std::endl;
            }
        }
    }

Unfortunately, the official documentation was limited to this statement. C_STRUCT aiMeshMorphAnim ** mMorphMeshChannels The morph mesh animation channels.

Each channel affects a single mesh. The array is mNumMorphMeshChannels in size.

What is aiAnimation in assimp library?

2024-08-23T08:39:43Z

What is aiAnimation in assimp library?

I learned about implementing skeletal animation using assimp at the link below.text

Therefore, I loaded a 3D model file intended to be used in Unity and an FBX file containing only the armature to be applied to that model.

However, the 3D model is not drawn well. When I looked into it, I found that there were multiple aiAnimations. I know that aiAnimation is an array of aiNodeAnim. When there was only one aiAnimation, it was possible to draw properly.

What is the situation when there are multiple aiAnimations, and how should I play the animations?

3D model with multiple aiAnimations enter image description here

3D model with one aiAnimation(plays properly) enter image description here

I tried to play the animation using aiNodeAnim included in all aiAnimation, but it turned out like the top image.

Miscalculating skeleton matrices from assimp

2024-08-08T16:38:58Z

After loading a model with assimp, all the bone data, nodes, etc, I went on a two step task to implement skinning.

If I use just the vertex data with the node hierarchy, I am able to render the model correctly. No skinning, no bone data is sent to the shader, nothing. There are only two meshes but around 60 nodes, specifying parts of the skeleton. The two nodes to which the meshes are attached both have identity matrices, loaded from the file.

After implementing skinning in the vertex shader, without loading any animation, letting it be the default pose, the model appears all deformed.

I checked the matrices that are loaded, and some of them are not identity matrices. Shouldn't they be, for the bind pose?

if I pass an identity matrix for every bone, the model appears correctly once again. What am I doing wrong here?

This is the code I'm using to calculate the node hierarchy

struct MeshTreeNode
    {
    std::string Name;
    glm::mat4 DefaultTransformationMatrix;
    std::vector <uint32_t> MeshIndices;
    std::vector <int> ChildNodes;
    int ParentNode;
    };
void ModelCalcMatrices ( const std::vector <MeshTreeNode> &NodeTree, std::vector <glm::mat4> &OutputMatrices, std::vector <NodeMeshIndexPair> &OutputMeshIndices, const unsigned CurrentNodeIndex = 0, const glm::mat4 &CurrentMatrix = glm::identity<glm::mat4> () );

void ModelCalcMatrices ( const std::vector <MeshTreeNode> &NodeTree, std::vector <glm::mat4> &OutputMatrices, std::vector <NodeMeshIndexPair> &OutputMeshIndices, const unsigned CurrentNodeIndex, const glm::mat4 &CurrentMatrix )
    {
    glm::mat4 NewMatrix = NodeTree[CurrentNodeIndex].DefaultTransformationMatrix * CurrentMatrix;
    OutputMatrices.push_back ( NewMatrix );
    // If there are any meshes to be drawn at this node, add them and their corresponding nodes to the vectors.
    for ( unsigned MeshIterator = 0; MeshIterator < NodeTree[CurrentNodeIndex].MeshIndices.size (); ++MeshIterator )
        {
        OutputMeshIndices.push_back ( NodeMeshIndexPair ( CurrentNodeIndex, MeshIterator ) );
        }
    // Process children
    for ( unsigned ChildIterator = 0; ChildIterator < NodeTree[CurrentNodeIndex].ChildNodes.size (); ++ChildIterator )
        {
        ModelCalcMatrices ( NodeTree, OutputMatrices, OutputMeshIndices, NodeTree[CurrentNodeIndex].ChildNodes[ChildIterator], NewMatrix );
        }
    }

I pass it the vector with all nodes as loaded by assimp, and expect an equal-sized vector of matrices to come out. Also outputs another vector with the nodes that actually have some mesh to render.

CMake: including assimp header files and linking to shared library [duplicate]

2024-07-19T13:34:46Z

I am trying to include the assimp library to import models. When I went to compile the code using CMake I got a series of errors. I followed the build instructions to build a dynamic library on Assimp's Repo and put the compiled library in a lib folder, as well as the assimp header files in my include directory.

My CMakeLists.txt is:

cmake_minimum_required(VERSION 3.20.0)
project(app)

# set(CMAKE_BINARY_DIR ${CMAKE_SOURCE_DIR}/bin)

find_package(glfw3 3.4 REQUIRED)
set(SOURCES main.cpp glad.c shader.h camera.h stb_image.h mesh.h model.h)

include_directories(${CMAKE_SOURCE_DIR}/include)
# link_directories(${CMAKE_SOURCE_DIR}/lib)

# target_include_directories(${PROJECT_NAME} PUBLIC
# ${CMAKE_SOURCE_DIR}/include/
# ${CMAKE_SOURCE_DIR}/include/glad/include
# ${CMAKE_SOURCE_DIR}/include/GLFW/include
# ${CMAKE_SOURCE_DIR}/include/glm/include
# ${CMAKE_SOURCE_DIR}/include/assimp/include
# )



add_executable(${PROJECT_NAME} ${SOURCES})


target_link_libraries(${PROJECT_NAME})
target_link_libraries(${PROJECT_NAME} glfw)
target_link_libraries(${PROJECT_NAME} ${CMAKE_SOURCE_DIR}/lib/libassimp.a)

and my project structure is

Project Directory:

CMakeLists.txt
source files
include:
- assimp
- other includes
lib:
- libassimp.5.4.1.dylib

The errors occur when I run make and I don't get any errors when running cmake

How can I fix my CMakeLists.txt to properly include the compiled assimp library and link to to my project?

I have tried changing my CMakelists.txt to use target include directories, before and after the add_executable line (after research I know it has to go after now), as well as attempting to use a static library target_link_libraries(${PROJECT_NAME} ${CMAKE_SOURCE_DIR}/lib/libassimp.a) with no luck.

I have run into the same problem trying to include ImGui and tried to use GLOB with no success.

I have deleted my CMakeCache and build-files after each change.

ERRORS: This is the first two errors I get when I run make:

[ 33%] Building CXX object CMakeFiles/app.dir/main.cpp.o
In file included from /Users/aag/Documents/code-projects/testcpp/main.cpp:11:
In file included from /Users/aag/Documents/code-projects/testcpp/model.h:9:
In file included from /Users/aag/Documents/code-projects/testcpp/include/assimp/Importer.hpp:58:
In file included from /Users/aag/Documents/code-projects/testcpp/include/assimp/types.h:61:
/Users/aag/Documents/code-projects/testcpp/include/assimp/defs.h:292:1: error: unknown type name 'constexpr'
constexpr ai_real ai_epsilon = (ai_real) 1e-6;
^
/Users/aag/Documents/code-projects/testcpp/include/assimp/defs.h:292:18: error: expected ';' after top level declarator
constexpr ai_real ai_epsilon = (ai_real) 1e-6;

Linker Failing Error when running make:

/opt/homebrew/Cellar/cmake/3.28.1/bin/cmake -S/Users/aag/Documents/code-projects/testcpp -B/Users/aag/Documents/code-projects/testcpp/build --check-build-system CMakeFiles/Makefile.cmake 0
/opt/homebrew/Cellar/cmake/3.28.1/bin/cmake -E cmake_progress_start /Users/aag/Documents/code-projects/testcpp/build/CMakeFiles /Users/aag/Documents/code-projects/testcpp/build//CMakeFiles/progress.marks
/Applications/Xcode.app/Contents/Developer/usr/bin/make  -f CMakeFiles/Makefile2 all
/Applications/Xcode.app/Contents/Developer/usr/bin/make  -f CMakeFiles/assimp.dir/build.make CMakeFiles/assimp.dir/depend
cd /Users/aag/Documents/code-projects/testcpp/build && /opt/homebrew/Cellar/cmake/3.28.1/bin/cmake -E cmake_depends "Unix Makefiles" /Users/aag/Documents/code-projects/testcpp /Users/aag/Documents/code-projects/testcpp /Users/aag/Documents/code-projects/testcpp/build /Users/aag/Documents/code-projects/testcpp/build /Users/aag/Documents/code-projects/testcpp/build/CMakeFiles/assimp.dir/DependInfo.cmake "--color="
/Applications/Xcode.app/Contents/Developer/usr/bin/make  -f CMakeFiles/assimp.dir/build.make CMakeFiles/assimp.dir/build
[ 25%] Linking CXX shared library libassimp.dylib
/opt/homebrew/Cellar/cmake/3.28.1/bin/cmake -E cmake_link_script CMakeFiles/assimp.dir/link.txt --verbose=1
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++  -arch arm64 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.2.sdk -dynamiclib -Wl,-headerpad_max_install_names -o libassimp.dylib -install_name @rpath/libassimp.dylib  -Wl,-rpath,/Users/aag/Documents/code-projects/testcpp/lib/libassimp.5.4.1.dylib 
[ 25%] Built target assimp
/Applications/Xcode.app/Contents/Developer/usr/bin/make  -f CMakeFiles/app.dir/build.make CMakeFiles/app.dir/depend
cd /Users/aag/Documents/code-projects/testcpp/build && /opt/homebrew/Cellar/cmake/3.28.1/bin/cmake -E cmake_depends "Unix Makefiles" /Users/aag/Documents/code-projects/testcpp /Users/aag/Documents/code-projects/testcpp /Users/aag/Documents/code-projects/testcpp/build /Users/aag/Documents/code-projects/testcpp/build /Users/aag/Documents/code-projects/testcpp/build/CMakeFiles/app.dir/DependInfo.cmake "--color="
/Applications/Xcode.app/Contents/Developer/usr/bin/make  -f CMakeFiles/app.dir/build.make CMakeFiles/app.dir/build
[ 50%] Linking CXX executable app
/opt/homebrew/Cellar/cmake/3.28.1/bin/cmake -E cmake_link_script CMakeFiles/app.dir/link.txt --verbose=1
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++  -arch arm64 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.2.sdk -Wl,-search_paths_first -Wl,-headerpad_max_install_names CMakeFiles/app.dir/main.cpp.o CMakeFiles/app.dir/glad.c.o -o app   -L/Users/aag/Documents/code-projects/testcpp/lib  -Wl,-rpath,/Users/aag/Documents/code-projects/testcpp/lib/libassimp.5.4.1.dylib -Wl,-rpath,/opt/homebrew/lib -Wl,-rpath,/Users/aag/Documents/code-projects/testcpp/lib -Wl,-rpath,/Users/aag/Documents/code-projects/testcpp/build /opt/homebrew/lib/libglfw.3.4.dylib libassimp.dylib 
ld: Undefined symbols:
  Assimp::Importer::ReadFile(char const*, unsigned int), referenced from:
      Assimp::Importer::ReadFile(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> const&, unsigned int) in main.cpp.o
  Assimp::Importer::Importer(), referenced from:
      Model::loadModel(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> const&) in main.cpp.o
  Assimp::Importer::~Importer(), referenced from:
      Model::loadModel(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> const&) in main.cpp.o
      Model::loadModel(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> const&) in main.cpp.o
  Assimp::Importer::GetErrorString() const, referenced from:
      Model::loadModel(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> const&) in main.cpp.o
  _aiGetMaterialTexture, referenced from:
      aiMaterial::GetTexture(aiTextureType, unsigned int, aiString*, aiTextureMapping*, unsigned int*, float*, aiTextureOp*, aiTextureMapMode*) const in main.cpp.o
  _aiGetMaterialTextureCount, referenced from:
      aiMaterial::GetTextureCount(aiTextureType) const in main.cpp.o
  _stbi_image_free, referenced from:
      TextureFromFile(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> const&, bool) in main.cpp.o
      TextureFromFile(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> const&, bool) in main.cpp.o
  _stbi_load, referenced from:
      TextureFromFile(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> const&, bool) in main.cpp.o
  _stbi_set_flip_vertically_on_load, referenced from:
      _main in main.cpp.o
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make[2]: *** [app] Error 1
make[1]: *** [CMakeFiles/app.dir/all] Error 2
make: *** [all] Error 2

updated CMakeLists.txt

cmake_minimum_required(VERSION 3.20.0)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_VERBOSE_MAKEFILE ON)
project(app)

set(CMAKE_BUILD_RPATH ${CMAKE_SOURCE_DIR}/lib/libassimp.5.4.1.dylib)

find_package(glfw3 3.4 REQUIRED)


add_library(assimp SHARED ${CMAKE_SOURCE_DIR}/lib/libassimp.5.4.1.dylib)
set_target_properties(assimp PROPERTIES LINKER_LANGUAGE CXX)
set(SOURCES main.cpp glad.c shader.h camera.h stb_image.h mesh.h model.h)

include_directories(${CMAKE_SOURCE_DIR}/include)
link_directories(${CMAKE_SOURCE_DIR}/lib)

add_executable(${PROJECT_NAME} ${SOURCES})


target_link_libraries(${PROJECT_NAME})
target_link_libraries(${PROJECT_NAME} glfw)
target_link_libraries(${PROJECT_NAME} assimp)

Helix Viewport + SharpDX - Loaded models not visible in viewport

2024-05-31T17:17:09Z

For some reason I can't see any of the models I'm importing into this Helix viewport I've set up. I've tried a thousand code combinations, drawing from the examples in the HelixToolkit git as well. Nothing. No errors, no exceptions, no crashes, nothing at all. The models simply aren't visible, even though I know for a fact the program is parsing them because it used to throw exceptions at me. Maybe it's just, you know, something really dumb I'm overlooking, but right now I'm drawing a blank.

(Slightly modified) code from model importer demo with some really simple console outputs for debugging purposes:

// MainViewModel.cs
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using HelixToolkit.Wpf.SharpDX;
using HelixToolkit.Wpf.SharpDX.Animations;
using HelixToolkit.Wpf.SharpDX.Assimp;
using HelixToolkit.Wpf.SharpDX.Controls;
using HelixToolkit.Wpf.SharpDX.Model;
using HelixToolkit.Wpf.SharpDX.Model.Scene;
using Microsoft.Win32;
using MvvmHelpers;
using Point3D = System.Windows.Media.Media3D.Point3D;
using Vector3D = System.Windows.Media.Media3D.Vector3D;
using Color = System.Windows.Media.Color;
using Colors = System.Windows.Media.Colors;
using SharpDX;
using JulMar.Windows.Mvvm;
using System.Linq;

namespace FileLoadDemo
{
    public class MainViewModel : BaseViewModel
    {
        private string OpenFileFilter = $"{HelixToolkit.Wpf.SharpDX.Assimp.Importer.SupportedFormatsString}";
        private string ExportFileFilter = $"{HelixToolkit.Wpf.SharpDX.Assimp.Exporter.SupportedFormatsString}";
        private bool showWireframe = false;
        public bool ShowWireframe
        {
            set
            {
                if (SetProperty(ref showWireframe, value))
                {
                    ShowWireframeFunct(value);
                }
            }
            get
            {
                return showWireframe;
            }
        }

        private bool renderFlat = false;
        public bool RenderFlat
        {
            set
            {
                if (SetProperty(ref renderFlat, value))
                {
                    RenderFlatFunct(value);
                }
            }
            get
            {
                return renderFlat;
            }
        }

        private bool renderEnvironmentMap = true;
        public bool RenderEnvironmentMap
        {
            set
            {
                if (SetProperty(ref renderEnvironmentMap, value) && scene != null && scene.Root != null)
                {
                    foreach (var node in scene.Root.Traverse())
                    {
                        if (node is MaterialGeometryNode m && m.Material is PBRMaterialCore material)
                        {
                            material.RenderEnvironmentMap = value;
                        }
                    }
                }
            }
            get => renderEnvironmentMap;
        }

        public ICommand OpenFileCommand { get; set; }
        public DefaultEffectsManager EffectsManager { get; }
        public OrthographicCamera Camera { get; }
        public ICommand ResetCameraCommand { get; set; }
        public ICommand ExportCommand { private set; get; }
        public ICommand CopyAsBitmapCommand { private set; get; }
        public ICommand CopyAsHiresBitmapCommand { private set; get; }

        private bool isLoading = false;
        public bool IsLoading
        {
            private set => SetProperty(ref isLoading, value);
            get => isLoading;
        }

        private bool isPlaying = false;
        public bool IsPlaying
        {
            private set => SetProperty(ref isPlaying, value);
            get => isPlaying;
        }

        private float startTime;
        public float StartTime
        {
            private set => SetProperty(ref startTime, value);
            get => startTime;
        }

        private float endTime;
        public float EndTime
        {
            private set => SetProperty(ref endTime, value);
            get => endTime;
        }

        private float currAnimationTime = 0;
        public float CurrAnimationTime
        {
            set
            {
                if (EndTime == 0)
                { return; }
                if (SetProperty(ref currAnimationTime, value % EndTime + StartTime))
                {
                    animationUpdater?.Update(value, 1);
                }
            }
            get => currAnimationTime;
        }

        public ObservableCollection<IAnimationUpdater> Animations { get; } = new ObservableCollection<IAnimationUpdater>();

        public SceneNodeGroupModel3D GroupModel { get; } = new SceneNodeGroupModel3D();

        private IAnimationUpdater selectedAnimation = null;
        public IAnimationUpdater SelectedAnimation
        {
            set
            {
                if (SetProperty(ref selectedAnimation, value))
                {
                    StopAnimation();
                    CurrAnimationTime = 0;
                    if (value != null)
                    {
                        animationUpdater = value;
                        animationUpdater.Reset();
                        animationUpdater.RepeatMode = AnimationRepeatMode.Loop;
                        StartTime = value.StartTime;
                        EndTime = value.EndTime;
                    }
                    else
                    {
                        animationUpdater = null;
                        StartTime = EndTime = 0;
                    }
                }
            }
            get
            {
                return selectedAnimation;
            }
        }

        private float speed = 1.0f;
        public float Speed
        {
            set
            {
                SetProperty(ref speed, value);
            }
            get => speed;
        }

        private Point3D modelCentroid = default;
        public Point3D ModelCentroid
        {
            private set => SetProperty(ref modelCentroid, value);
            get => modelCentroid;
        }
        private BoundingBox modelBound = new BoundingBox();
        public BoundingBox ModelBound
        {
            private set => SetProperty(ref modelBound, value);
            get => modelBound;
        }
        public TextureModel EnvironmentMap { get; }

        public ICommand PlayCommand { get; }

        private SynchronizationContext context = SynchronizationContext.Current;
        private HelixToolkitScene scene;
        private IAnimationUpdater animationUpdater;
        private List<BoneSkinMeshNode> boneSkinNodes = new List<BoneSkinMeshNode>();
        private List<BoneSkinMeshNode> skeletonNodes = new List<BoneSkinMeshNode>();
        private CompositionTargetEx compositeHelper = new CompositionTargetEx();
        private long initTimeStamp = 0;

        public MainViewModel(DefaultEffectsManager effectsManager)
        {
            EffectsManager = effectsManager;
            this.OpenFileCommand = new DelegateCommand(this.OpenFile);
            Camera = new OrthographicCamera()
            {
                LookDirection = new System.Windows.Media.Media3D.Vector3D(0, -10, -10),
                Position = new System.Windows.Media.Media3D.Point3D(0, 10, 10),
                UpDirection = new System.Windows.Media.Media3D.Vector3D(0, 1, 0),
                FarPlaneDistance = 5000,
                NearPlaneDistance = 0.1f
            };
            ResetCameraCommand = new DelegateCommand(() =>
            {
                (Camera as OrthographicCamera).Reset();
                (Camera as OrthographicCamera).FarPlaneDistance = 5000;
                (Camera as OrthographicCamera).NearPlaneDistance = 0.1f;
            });
            ExportCommand = new DelegateCommand(() => { ExportFile(); });

            CopyAsBitmapCommand = new DelegateCommand(() => { CopyAsBitmapToClipBoard(); });
            CopyAsHiresBitmapCommand = new DelegateCommand(() => { CopyAsHiResBitmapToClipBoard(); });

            EnvironmentMap = TextureModel.Create("Cubemap_Grandcanyon.dds");

            PlayCommand = new DelegateCommand(() =>
            {
                if (!IsPlaying && SelectedAnimation != null)
                {
                    StartAnimation();
                }
                else
                {
                    StopAnimation();
                }
            });
        }

        private void CopyAsBitmapToClipBoard()
        {
            var bitmap = ViewportExtensions.RenderBitmap((Viewport3DX)Application.Current.MainWindow.FindName("view"));
            try
            {
                Clipboard.Clear();
                Clipboard.SetImage(bitmap);
            }
            catch (Exception e)
            {
                Debug.WriteLine(e);
            }
        }

        private void CopyAsHiResBitmapToClipBoard()
        {
            var stopwatch = new Stopwatch();
            stopwatch.Start();

            var bitmap = ViewportExtensions.RenderBitmap((Viewport3DX)Application.Current.MainWindow.FindName("view"), 1920, 1080);
            try
            {
                Clipboard.Clear();
                Clipboard.SetImage(bitmap);
                stopwatch.Stop();
                Debug.WriteLine($"creating bitmap needs {stopwatch.ElapsedMilliseconds} ms");
            }
            catch (Exception e)
            {
                Debug.WriteLine(e);
            }
        }

        private void OpenFile()
        {
            if (isLoading)
            {
                Console.WriteLine("Loading");
                return;
            }
            string path = OpenFileDialog(OpenFileFilter);
            if (path == null)
            {
                Console.WriteLine("Null path");
                return;
            }
            StopAnimation();
            var syncContext = SynchronizationContext.Current;
            IsLoading = true;
            Task.Run(() =>
            {
                var loader = new Importer();
                var scene = loader.Load(path);
                scene.Root.Attach(EffectsManager); // Pre attach scene graph
                Console.WriteLine("Attached scene graph");
                scene.Root.UpdateAllTransformMatrix();
                Console.WriteLine("Transform matrix updated");
                if (scene.Root.TryGetBound(out var bound))
                {
                    /// Must use UI thread to set value back.
                    syncContext.Post((o) => { ModelBound = bound; }, null);
                }
                if (scene.Root.TryGetCentroid(out var centroid))
                {
                    /// Must use UI thread to set value back.
                    syncContext.Post((o) => { ModelCentroid = centroid.ToPoint3D(); }, null);
                }
                return scene;
            }).ContinueWith((result) =>
            {
                IsLoading = false;
                Console.WriteLine("Completed");
                if (result.IsCompleted)
                {
                    scene = result.Result;
                    Animations.Clear();
                    var oldNode = GroupModel.SceneNode.Items.ToArray();
                    GroupModel.Clear(false);
                    Task.Run(() =>
                    {
                        foreach (var node in oldNode)
                        { node.Dispose(); }
                    });
                    if (scene != null)
                    {
                        if (scene.Root != null)
                        {
                            foreach (var node in scene.Root.Traverse())
                            {
                                if (node is MaterialGeometryNode m)
                                {
                                    //m.Geometry.SetAsTransient();
                                    if (m.Material is PBRMaterialCore pbr)
                                    {
                                        pbr.RenderEnvironmentMap = RenderEnvironmentMap;
                                        Console.WriteLine("pbr");
                                    }
                                    else if (m.Material is PhongMaterialCore phong)
                                    {
                                        phong.RenderEnvironmentMap = RenderEnvironmentMap;
                                        Console.WriteLine("phong");
                                    }
                                }
                            }
                        }
                        GroupModel.AddNode(scene.Root);
                        if (scene.HasAnimation)
                        {
                            var dict = scene.Animations.CreateAnimationUpdaters();
                            foreach (var ani in dict.Values)
                            {
                                Animations.Add(ani);
                            }
                        }
                        FocusCameraToScene();
                    }
                }
                else if (result.IsFaulted && result.Exception != null)
                {
                    MessageBox.Show(result.Exception.Message);
                }
            }, TaskScheduler.FromCurrentSynchronizationContext());
        }

        public void StartAnimation()
        {
            initTimeStamp = Stopwatch.GetTimestamp();
            compositeHelper.Rendering += CompositeHelper_Rendering;
            IsPlaying = true;
        }

        public void StopAnimation()
        {
            IsPlaying = false;
            compositeHelper.Rendering -= CompositeHelper_Rendering;
        }

        private void CompositeHelper_Rendering(object sender, System.Windows.Media.RenderingEventArgs e)
        {
            if (animationUpdater != null)
            {
                var elapsed = (Stopwatch.GetTimestamp() - initTimeStamp) * speed;
                CurrAnimationTime = elapsed / Stopwatch.Frequency;
            }
        }

        private void FocusCameraToScene()
        {
            var maxWidth = Math.Max(Math.Max(modelBound.Width, modelBound.Height), modelBound.Depth);
            var pos = modelBound.Center + new Vector3(0, 0, maxWidth);
            Camera.Position = pos.ToPoint3D();
            Camera.LookDirection = (modelBound.Center - pos).ToVector3D();
            Camera.UpDirection = Vector3.UnitY.ToVector3D();
            if (Camera is OrthographicCamera orthCam)
            {
                orthCam.Width = maxWidth;
            }
        }

        private void ExportFile()
        {
            var index = SaveFileDialog(ExportFileFilter, out var path);
            if (!string.IsNullOrEmpty(path) && index >= 0)
            {
                var id = HelixToolkit.Wpf.SharpDX.Assimp.Exporter.SupportedFormats[index].FormatId;
                var exporter = new HelixToolkit.Wpf.SharpDX.Assimp.Exporter();
                exporter.ExportToFile(path, scene, id);
                return;
            }
        }

        private string OpenFileDialog(string filter)
        {
            var d = new OpenFileDialog();
            d.CustomPlaces.Clear();
            d.Filter = filter;

            if (!d.ShowDialog().Value)
            {
                return null;
            }
            return d.FileName;
        }

        private int SaveFileDialog(string filter, out string path)
        {
            var d = new SaveFileDialog();
            d.Filter = filter;
            if (d.ShowDialog() == true)
            {
                path = d.FileName;
                return d.FilterIndex - 1; // This is starting from 1. So must minus 1
            }
            else
            {
                path = "";
                return -1;
            }
        }

        private void ShowWireframeFunct(bool show)
        {
            foreach (var node in GroupModel.GroupNode.Items.PreorderDFT((node) => node.IsRenderable))
            {
                if (node is MeshNode m)
                {
                    m.RenderWireframe = show;
                }
            }
        }

        private void RenderFlatFunct(bool show)
        {
            foreach (var node in GroupModel.GroupNode.Items.PreorderDFT((node) => node.IsRenderable))
            {
                if (node is MeshNode m)
                {
                    if (m.Material is PhongMaterialCore phong)
                    {
                        phong.EnableFlatShading = show;
                    }
                    else if (m.Material is PBRMaterialCore pbr)
                    {
                        pbr.EnableFlatShading = show;
                    }
                }
            }
        }
    }
}

The code I'm attempting to call previous code from:

using System;
using System.Windows.Forms;
using System.Windows.Forms.Integration;
using HelixToolkit.Wpf.SharpDX.Controls;
using FileLoadDemo;
using HelixToolkit.Wpf.SharpDX;

namespace Intelligencecasinos_Animation_Maker
{
    public partial class Form3 : Form
    {
        private Viewport3DX viewport;
        private MainViewModel viewModel;
        private DefaultEffectsManager effectsManager;

        public Form3()
        {
            InitializeComponent();
            this.Load += Form3_Load;
        }

        private void Form3_Load(object sender, EventArgs e)
        {
            InitializeEffectsManager();
            InitializeHelixViewport();
            InitializeViewModel();
        }
        private void CreateGrid()
        {
            var grid = new AxisPlaneGridModel3D();
            viewport.Items.Add(grid);
        }
        private void InitializeEffectsManager()
        {
            effectsManager = new DefaultEffectsManager();
        }

        private void InitializeHelixViewport()
        {
            viewport = new Viewport3DX
            {
                Name = "view",
                EffectsManager = effectsManager,
                Camera = new PerspectiveCamera
                {
                    LookDirection = new System.Windows.Media.Media3D.Vector3D(0, -10, -10),
                    Position = new System.Windows.Media.Media3D.Point3D(0, 10, 10),
                    UpDirection = new System.Windows.Media.Media3D.Vector3D(0, 1, 0),
                    FarPlaneDistance = 5000,
                    NearPlaneDistance = 0.1f
                },
                BackgroundColor = System.Windows.Media.Color.FromRgb(30, 30, 30) // Dark background
            };

            // Create a WindowsFormsHost to host the WPF control
            var host = new ElementHost
            {
                Dock = DockStyle.Fill,
                Child = viewport
            };

            // Add the WindowsFormsHost to the existing viewportPanel
            CreateGrid();
            viewportPanel.Controls.Add(host);
        }

        private void InitializeViewModel()
        {
            viewModel = new MainViewModel(effectsManager);
            viewport.DataContext = viewModel;
            viewport.Items.Add(viewModel.GroupModel);
            Console.WriteLine("Viewmodel initialized");
        }

        private void openToolStripMenuItem_Click(object sender, EventArgs e)
        {
            viewModel.OpenFileCommand.Execute(null);
        }
    }
}

How to convert UTextureRenderTarget2D to Assimp embaded texture?

2024-05-30T17:46:59Z

I'm using Assimp to export FBX with embedded textures. Reading an image from a png file (into the built-in aiTexture*) works fine. But when I try to convert UTextureRenderTarget2D to aiTexel* pcData I always get wrong data.


static FName ImageWrapperName("ImageWrapper");
IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(ImageWrapperName);

FTextureRenderTargetResource* RTResource = RenderTarget->GameThread_GetRenderTargetResource();
FIntPoint                     DestSize(RenderTarget->GetSurfaceWidth(), RenderTarget->GetSurfaceHeight());

TUniquePtr<TImagePixelData<FColor>> PixelData;
PixelData = MakeUnique<TImagePixelData<FColor>>(FIntPoint((int32)DestSize.X, (int32)DestSize.Y));
PixelData->Pixels.SetNumUninitialized(DestSize.X * DestSize.Y);
RTResource->ReadPixelsPtr(PixelData->Pixels.GetData());

FImagePixelData* Data = PixelData.Get();
FImageView Image = Data->GetImageView();

TArray64<uint8> CompressedFile;
ImageWrapperModule.CompressImage(CompressedFile, EImageFormat::PNG, Image, (int32)EImageCompressionQuality::Max);

aiTexture* texture = new aiTexture;
texture->mHeight = 0;
texture->mWidth = CompressedFile.Num();
texture->pcData = new aiTexel[1ul + static_cast<unsigned long>(CompressedFile.Num()) / sizeof(aiTexel)];

for (int i = 0; i < CompressedFile.Num(); i += 4)
{
    int32 index = i / 4;
    texture->pcData[index].b = CompressedFile[i + 0];
    texture->pcData[index].g = CompressedFile[i + 1];
    texture->pcData[index].r = CompressedFile[i + 2];
    texture->pcData[index].a = CompressedFile[i + 3];
}

texture->achFormatHint[0] = 'p';
texture->achFormatHint[1] = 'n';
texture->achFormatHint[2] = 'g';
texture->achFormatHint[3] = '\0';

scene.mTextures[0] = texture;

Getting a lot of "Duplicate class ... found in modules assimp.jar"

2024-05-21T00:07:35Z

I'm creating an Android app using Kotlin to read PLY files and render them using OpenGL. I found about the Assimp library and tried some approaches like building from its source (had issues creating the JNI bindings), using different packages on MavenCentral (different options available, some of them are not complete or caused some random issue), and ended up getting the JAR file from this GitHub repo to give it a try.

I've added it to build.gradle.kts using:

implementation(files("libs/assimp.jar"))

This is one of the JAR files I've tried: https://github.com/kotlin-graphics/assimp/releases/download/v4.0/assimp-all.jar.

But I'm getting a lot of errors like this:

Duplicate class kotlin.ArrayIntrinsicsKt found in modules assimp.jar -> assimp (assimp.jar) and kotlin-stdlib-1.9.0.jar -> kotlin-stdlib-1.9.0 (org.jetbrains.kotlin:kotlin-stdlib:1.9.0)
Duplicate class kotlin.Deprecated found in modules assimp.jar -> assimp (assimp.jar) and kotlin-stdlib-1.9.0.jar -> kotlin-stdlib-1.9.0 (org.jetbrains.kotlin:kotlin-stdlib:1.9.0)
Duplicate class kotlin.DeprecationLevel found in modules assimp.jar -> assimp (assimp.jar) and kotlin-stdlib-1.9.0.jar -> kotlin-stdlib-1.9.0 (org.jetbrains.kotlin:kotlin-stdlib:1.9.0)
Duplicate class kotlin.DslMarker found in modules assimp.jar -> assimp (assimp.jar) and kotlin-stdlib-1.9.0.jar -> kotlin-stdlib-1.9.0 (org.jetbrains.kotlin:kotlin-stdlib:1.9.0)
Duplicate class kotlin.ExceptionsKt found in modules assimp.jar -> assimp (assimp.jar) and kotlin-stdlib-1.9.0.jar -> kotlin-stdlib-1.9.0 (org.jetbrains.kotlin:kotlin-stdlib:1.9.0)
Duplicate class kotlin.ExceptionsKt__ExceptionsKt found in modules assimp.jar -> assimp (assimp.jar) and kotlin-stdlib-1.9.0.jar -> kotlin-stdlib-1.9.0 (org.jetbrains.kotlin:kotlin-stdlib:1.9.0)
Duplicate class kotlin.ExtensionFunctionType found in modules assimp.jar -> assimp (assimp.jar) and kotlin-stdlib-1.9.0.jar -> kotlin-stdlib-1.9.0 (org.jetbrains.kotlin:kotlin-stdlib:1.9.0)
Duplicate class kotlin.Function found in modules assimp.jar -> assimp (assimp.jar) and kotlin-stdlib-1.9.0.jar -> kotlin-stdlib-1.9.0 (org.jetbrains.kotlin:kotlin-stdlib:1.9.0)
Duplicate class kotlin.InitializedLazyImpl found in modules assimp.jar -> assimp (assimp.jar) and kotlin-stdlib-1.9.0.jar -> kotlin-stdlib-1.9.0 (org.jetbrains.kotlin:kotlin-stdlib:1.9.0)

I thought about excluding the duplicates using proguard-rules.pro, but did not find how to do it.

Using rapidjson and assimp together causes rapidjson to behave unpredictably

2024-02-28T08:59:05Z

I have the following test program (test.gltf is a file containing just "{}"):

#include "assimp/Importer.hpp"
#include "assimp/postprocess.h"
#include "assimp/scene.h"

#include "rapidjson/document.h"

#include <iostream>

int main()
{
    std::cout << "reading test" << std::endl;
    Assimp::Importer importer;
    const aiScene *scene = importer.ReadFile("test.gltf", {});
    std::cout << "SUCCESS" << std::endl;

    std::cout << "testing document" << std::endl;
    rapidjson::Document document;
    std::cout << document.HasMember("product") << std::endl;

    return 0;
}

When I run this I get an error on the ReadFile call:

main: /home/sanderv/dev/twikbot-core/external/assimp/code/../contrib/rapidjson/include/rapidjson/document.h:1336: rapidjson::GenericValue::MemberIterator rapidjson::GenericValue<rapidjson::UTF8<>>::FindMember(const GenericValue<Encoding, SourceAllocator> &) [Encoding = rapidjson::UTF8<>, Allocator = rapidjson::MemoryPoolAllocator<>, SourceAllocator = rapidjson::MemoryPoolAllocator<>]: Assertion `IsObject()' failed.

This is odd because ReadFile should work, and just return nullptr. When I remove the call to document.HasMember in the above program this does work. Stepping through the code shows that something very odd is going on, on stepping into the actual FindMember function the *this object looks corrupt.

PyAssimp error for any loaded file - Scene has not attribute meshes, materials or textures

2024-02-08T18:19:30Z

I am trying to get any sample (including the ones found in the Assimp repo) to work. Using pyassimp 5.2.5 with Python 3.11.6. Below there is an example for a very basic call. I am loading an OBJ of a cube, which one can even write manually. :D

import pyassimp
import pyassimp.postprocess

def main(filename=None):

    scene = pyassimp.load(filename, processing=pyassimp.postprocess.aiProcess_Triangulate)
    
    
    print("Meshes:" + str(len(scene.meshes)))
    pyassimp.release(scene)

The cube

# Blender v2.61 (sub 0) OBJ File: ''
# www.blender.org
mtllib bigger-cube.mtl
o Cube
v 0.700000 -0.700000 -0.700000
v 0.700000 -0.700000 0.700000
v -0.700000 -0.700000 0.700000
v -0.700000 -0.700000 -0.700000
v 0.700000 0.700000 -0.700000
v 0.700000 0.700000 0.700000
v -0.700000 0.700000 0.700000
v -0.700000 0.700000 -0.700000
vt 0.000000 0.000000
vt 1.000000 0.000000
vt 1.000000 1.000000
vt 0.000000 1.000000
vn 0.000000 -1.000000 0.000000
vn 0.000000 1.000000 0.000000
vn 1.000000 0.000000 0.000000
vn -0.000000 -0.000000 1.000000
vn -1.000000 -0.000000 -0.000000
vn 0.000000 0.000000 -1.000000
usemtl Material.001
s off
f 1/1/1 2/2/1 3/3/1 4/4/1
f 5/1/2 8/2/2 7/3/2 6/4/2
f 1/1/3 5/2/3 6/3/3 2/4/3
f 2/1/4 6/2/4 7/3/4 3/4/4
f 3/1/5 7/2/5 8/3/5 4/4/5
f 5/1/6 1/2/6 4/3/6 8/4/6

The trace is

INFO:pyassimp:Adding Anaconda lib path:/home/user/miniconda3/envs/computergraphics/lib/
MODEL:bigger-cube.obj
SCENE:
Traceback (most recent call last):
  File "/home/ale56337/Projects/cgi/playground.py", line 83, in <module>
    main(sys.argv[1])
  File "/home/user/Projects/cgi/playground.py", line 24, in main
    print("  meshes:" + str(len(scene.meshes)))
                                ^^^^^^^^^^^^
AttributeError: '_GeneratorContextManager' object has no attribute 'meshes'

I also tried calling materials and textures but the result is the same. There is an issue in the official repo, which was fixed two years or so ago. Yet with the current version the issue is still there (perhaps regression or another source of the problem leading to the same outcome?).

Any ideas how to make PyAssimp work?

Converting local space normals into world space

2024-01-13T20:01:19Z

I need to convert a local space mesh into global space. The resulting normal vectors don't seem to be correct.

I got the world transform matrix for the vertex (Which works, because the position of the vertex is correct). Then I get the transform matrix for the normals by getting the transposed matrix of the inverse matrix of the world transform matrix. Which I use for transforming the local space normal vector.

Which results in: Calculation Result

But the result should be more like this: Expected Result

Used code for the current result (Look where the "// TODO: Fix normals (Buggy)" is)

        FMeshData &MeshData = ModelData.Meshes[MeshIndex];
        aiMesh *Mesh = Scene->mMeshes[MeshIndex];
        aiNode *Node = GetParentNode(Scene->mRootNode, MeshIndex);

        // Get world transform
        FMatrix PositionMatrix = GetWorldTransformOfNode(Node);
        FMatrix NormalMatrix =   UKismetMathLibrary::Matrix_GetTransposed(PositionMatrix.Inverse());

        // Material id
        MeshData.MaterialId = Mesh->mMaterialIndex;

        // Lod Data
        GetLodData(LodFilePath, FString(Mesh->mName.C_Str()), MeshData.LodData);

        // Vertices
        for (uint32 VertexIndex = 0; VertexIndex < Mesh->mNumVertices; VertexIndex++)
        {
            // Position
            aiVector3D &aiVertex = Mesh->mVertices[VertexIndex];
            FVector PositionVertex = PositionMatrix.TransformFVector4(FVector(
                aiVertex.x,
                aiVertex.y,
                aiVertex.z));

            FVector3f Position(
                PositionVertex.X,
                PositionVertex.Y,
                PositionVertex.Z);

            // Normal
            FVector3f Normal = FVector3f::ZeroVector;
            if (Mesh->HasNormals())
            {
                //TODO: Fix normals (Buggy)
                aiVector3D &aiNormal = Mesh->mNormals[VertexIndex];
                FVector NormalVector = NormalMatrix.TransformFVector4(FVector(
                    aiNormal.x,
                    aiNormal.y,
                    aiNormal.z));

                Normal = FVector3f(
                    NormalVector.X,
                    NormalVector.Y,
                    NormalVector.Z);
            }

            // Tangent
            FVector3f Tangent = FVector3f::ZeroVector;
            if (Mesh->HasTangentsAndBitangents())
            {
                aiVector3D &aiTangent = Mesh->mTangents[VertexIndex];
                Tangent = FVector3f(
                    aiTangent.x,
                    aiTangent.y,
                    aiTangent.z);
            }

            // Linear Color
            FLinearColor LinearColor = FLinearColor::White;
            if (Mesh->HasVertexColors(0))
            {
                aiColor4D &aiColor = Mesh->mColors[0][VertexIndex];
                LinearColor = FLinearColor(
                    aiColor.r,
                    aiColor.g,
                    aiColor.b,
                    aiColor.a);
            }

            // UVs
            FVector2f UV0 = FVector2f::ZeroVector;
            FVector2f UV1 = FVector2f::ZeroVector;
            FVector2f UV2 = FVector2f::ZeroVector;
            FVector2f UV3 = FVector2f::ZeroVector;
            for (uint32 ChannelIndex = 0; ChannelIndex <= 3; ChannelIndex++)
            {
                if (Mesh->HasTextureCoords(ChannelIndex))
                {
                    aiVector3D &aiCoordinate = Mesh->mTextureCoords[ChannelIndex][VertexIndex];
                    FVector2f Coordinate(aiCoordinate.x, -aiCoordinate.y);

                    switch (ChannelIndex)
                    {
                    case 0:
                        UV0 = Coordinate;
                        break;
                    case 1:
                        UV1 = Coordinate;
                        break;
                    case 2:
                        UV2 = Coordinate;
                        break;
                    case 3:
                        UV3 = Coordinate;
                        break;
                    }
                }
            }

            // Create vertex
            FVertexData Vertex;
            Vertex.Position = Position;
            Vertex.Normal = Normal;
            Vertex.Tangent = Tangent;
            Vertex.Color = LinearColor;
            Vertex.UV0 = UV0;
            Vertex.UV1 = UV1;
            Vertex.UV2 = UV2;
            Vertex.UV3 = UV3;

            // Save vertex
            MeshData.Verticies.Push(Vertex);
        }
    }

UV texture mapping issue in .X file using assimp

2024-01-03T06:03:16Z

Describe the bug UV texture mapping issue in .X file, sometimes it loads perfectly but in some rare cases it happens.

To Reproduce Steps to reproduce the behavior:

Try loading Land_Objects_WareHouse.zip .x FIle.

Expected behavior It should load perfectly in all cases.

Screenshots If applicable, add screenshots to help explain your problem. warehouse texture issue

Platform (please complete the following information):

OS: WIndows Version 5.0.1 enter image description here

It should load perfectly in all cases , what is the possible solution to apply

Assimp::Importer imp;
fiuint loadHierarchy = 0;
if (false == _bLoadHierarchy)
{
loadHierarchy |= (aiProcess_PreTransformVertices | aiProcess_OptimizeGraph);
}
//else
// loadHierarchy |= aiProcess_GenSmoothNormals; //for quality /not performance
imp.SetPropertyInteger("AI_CONFIG_PP_RVC_FLAGS", aiComponent_CAMERAS | aiComponent_COLORS | aiComponent_LIGHTS);
//imp.SetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, false);

    const aiScene* pScene = imp.ReadFile(newfile.c_str(),
        aiProcess_ConvertToLeftHanded
        | aiProcess_RemoveComponent
        | aiProcess_LimitBoneWeights
        | aiProcess_Triangulate
        | aiProcess_JoinIdenticalVertices
        | aiProcess_ValidateDataStructure
        | aiProcess_ImproveCacheLocality
        | aiProcess_RemoveRedundantMaterials
        | aiProcess_FindInvalidData
        | aiProcess_GenUVCoords
        //| aiProcess_GenNormals
        
        //| aiProcess_TransformUVCoords
        | aiProcess_FindInstances
        | aiProcess_OptimizeMeshes
        | aiProcess_SortByPType
        | aiProcess_CalcTangentSpace
        | aiProcess_SplitLargeMeshes
        | loadHierarchy
        /*  aiProcessPreset_TargetRealtime_Quality*/
        );

Issue Linking Assimp Windows 11

2023-12-27T03:59:50Z

I am having issues with linking assimp in c++ for windows 11. I am working the the LearnOpenGL tutorial however I cannot get assimp to link correctly. I am able to make, and generate the assimp .dll and .lib, and grab the include files without error. I am also able to compile without issue, with just including some assimp headers. However whenever I attempt to use anything from an assimp file, I receive an 'undefined reference to ...' error. My g++ version is 13.2.0 and I am using this command to compile my project, with {project_dir} replaced as the path to the project directory.

g++ -g -std=c++17 -I./include -L./lib {project_dir}\*.cpp {project_dir}\*.c -lglfw3dll -lassimp-vc143-mtd -o myprogram

Here is an picture of the project directory layout.

The exact error results from these lines and the error message given by g++ is: {terminal_exe_location} {file_path} undefined reference to `Assimp::Importer::~Importer()'

I have tried multiple versions of g++, through differing versions of mSys2 and mingw. With no noticeable change in the error message asides from the terminal filepath.

It would be amazing if someone could help me understand what it is I have done wrong in attempting to build / link assimp it would be greatly appreciated. I am fairly inexperience with c++ and building my own binaries so I may not have provided all necessary information, and I can provide any logs / information that is not included upon request.

DirectX12 Problems with skeletal animation and Assimp library

2023-12-15T00:37:25Z

I'm trying to implement skeletal animation in my game engine but I'm running into problems when animating the bones in C++. The character animates but the torso and arms appear twisted. I'm following this OpenGL tutorial and expect the model to look like this but instead it looks like the video below. The vertices and bones are being parsed and uploaded properly but when I apply animations to the bones this happens.

I've assembled all the bones into an array and saved their parents to work through the bone hierarchy as was demonstrated in this tutorial. I believe the problem is somewhere in here because the model renders find in T-pose when I multiply the m_LocalMatrix instead of the AnimatedTransform in the first for loop. However, when I do this I must also multiply the Offset matrix for that bone when calculating the FinalTransformation matrix in the last for loop. Here is my code to animate the model:

std::vector<FMatrix> LocalTransforms( m_SkeletalMesh->Joints.size() );
std::vector<FMatrix> ModelTransforms( m_SkeletalMesh->Joints.size() );

for (uint32 i = 0; i < m_SkeletalMesh->Joints.size(); i++)
{
    FJoint& joint = m_SkeletalMesh->Joints[i];

    if (m_anim->m_KeyFrames.find( joint.m_Name ) != m_anim->m_KeyFrames.end())
    {
        uint32 KeyIndex = 0;
        uint32 NextKeyIndex = 0;
        for (uint32 i = 0; i < m_anim->m_KeyFrames[joint.m_Name].size() - 1; i++)
        {
            if (AnimationTimeTicks < m_anim->m_KeyFrames[joint.m_Name][i + 1].m_Timestamp)
            {
                KeyIndex = i;
                break;
            }
        }
        NextKeyIndex = KeyIndex + 1;
        float t1 = m_anim->m_KeyFrames[joint.m_Name][KeyIndex].m_Timestamp;
        float t2 = m_anim->m_KeyFrames[joint.m_Name][NextKeyIndex].m_Timestamp;
        float DeltaTime = t2 - t1;
        float Factor = (AnimationTimeTicks - (float)t1) / DeltaTime;
        HE_ASSERT( Factor >= 0.f && Factor <= 1.f );
        FTransform& Start = m_anim->m_KeyFrames[joint.m_Name][KeyIndex].m_AnimatedTransform;
        FTransform& End = m_anim->m_KeyFrames[joint.m_Name][NextKeyIndex].m_AnimatedTransform;
        FTransform AnimatedTransform = FTransform::Interpolate( Start, End, Factor );

        LocalTransforms[i] = AnimatedTransform.GetLocalMatrix();
    }
    else
    {
        LocalTransforms[i] = joint.m_LocalMatrix;
    }
}

ModelTransforms[0] = LocalTransforms[0];
for (uint32 i = 1; i < m_SkeletalMesh->Joints.size(); i++)
{
    FJoint& joint = m_SkeletalMesh->Joints[i];

    ModelTransforms[i] = ModelTransforms[joint.m_ParentIndex] * LocalTransforms[i];
}

JointCBData* pJointCB = m_SkeletalMesh->m_JointCB.GetBufferPointer();
for (uint32 i = 0; i < m_SkeletalMesh->Joints.size(); i++)
{
    FJoint& joint = m_SkeletalMesh->Joints[i];
    FMatrix& FinalTransform = pJointCB->kJoints[i];

    FinalTransform = m_SkeletalMesh->m_GlobalInverseTransform * ModelTransforms[i];
}

I'm confident the hierarchy is being parsed correctly but here is my code to do so:

void ProcessJoints( std::vector<FJoint>& Joints, const aiNode* pNode, const uint32& ParentIndex, const aiMesh* pMesh )
{
    FJoint& joint = Joints.emplace_back();
    strcpy_s( joint.m_Name, sizeof( joint.m_Name ), pNode->mName.C_Str());
    joint.m_NameHash = StringHash( joint.m_Name );
    joint.m_ParentIndex = ParentIndex;
    memcpy( &joint.m_LocalMatrix, &pNode->mTransformation, sizeof( FMatrix ) );
    for (uint32 i = 0; i < pMesh->mNumBones; i++)
    {
        if (pNode->mName == pMesh->mBones[i]->mName)
        {
            memcpy( &joint.m_OffsetMatrix, &pMesh->mBones[i]->mOffsetMatrix, sizeof( FMatrix ) );
            break;
        }
    }

    uint32 NewParentIndex = (uint32)Joints.size() - 1u;
    for (uint32 i = 0; i < pNode->mNumChildren; i++)
    {
        ProcessJoints( Joints, pNode->mChildren[i], NewParentIndex, pMesh );
    }
}

Here is my shader code as well which is taken from Frank Luna's DirectX12 book:

    float weights[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
    weights[0] = Input.Weights[0];
    weights[1] = Input.Weights[1];
    weights[2] = Input.Weights[2];
    weights[3] = 1.0f - weights[0] - weights[1] - weights[2];
    float3 totalLocalPos = float3(0, 0, 0);
    for (int i = 0; i < HE_MAX_JOINTS_PER_VERTEX; i++)
    {
        totalLocalPos += weights[i] * mul( float4(Input.Position, 0), Joints[Input.JointIDs[i]] ).xyz;
    }
    Result.Position = mul( float4(totalLocalPos, 1), WorldViewProjection );

I've been banging my head against this problem for weeks now and just cannot find the problem. Any help would be appreciated!

Other things I tried with no success were:

Update Assimp to the latest version thinking that might be the problem with the Assimp library
Made sure the vertices has the proper data types which was the solution to this problem
Made sure the matrices were in row-major in C++ then column-major for hlsl
Different models with different animations. Each model I tried had the same stretched/deformed look to them
Re-exporting the same models from blender as I saw some might cause issues without it like this tutorial

Bind different 3d models to a main model with opengl and assimp

2023-10-16T17:48:35Z

I hope you're doing well. I am starting with OpenGL, and currently, I have been implementing Assimp to load 3D models and animations, and so far, everything is going well. However, now what I want to know is whether it is possible to have several FBX files and link them to a bone of a main model. For example, I have an FBX file

male_character.fbx , and I have another file

helmet.fbx , and I want to associate it with the character's head. Is this possible, or can it only be done with one file and different meshes? Additionally, I have attached a gif to show what I have accomplished so far using Android Kotlin, NDK (C++), OpenGL ES, and Assimp. Thank you for your assistance! enter image description here

I added several 3D objects to the character from the same file (meaning different meshes), but I started thinking, if a new item needs to be added later on, then the entire FBX file would have to be completely updated to include this new item. That's why I want to know if it is possible to do this with separate files.

cookTriangleMesh access exception

2023-09-22T08:10:29Z

PxTriangleMesh* PhysX::CreateTriangleMesh(const PxVec3* verts, const PxU32 numVerts
    , const PxU32* indexs, const PxU32 numIndexes, PxPhysics* physics, PxCooking* cooking)
{
    // Create descriptor for triangle mesh
    PxTriangleMeshDesc meshDesc;
    meshDesc.points.count = numVerts;
    meshDesc.points.stride = sizeof(PxVec3);    
    meshDesc.points.data = verts;

    meshDesc.triangles.count = numIndexes / 3;
    meshDesc.triangles.stride = 3 * sizeof(PxU32);
    meshDesc.triangles.data = indexs;

    // for prevent stackoverflow
    PxU32 estimatedVertSize = numVerts * sizeof(PxVec3) * 1.5;
    PxU32 estimatedIndexSize = numIndexes * sizeof(PxU32) * 1.5;
    PxU32 initialSize = estimatedVertSize + estimatedIndexSize;
    CustomPhysXMemory writeBuffer(initialSize);

    //PxDefaultMemoryOutputStream writeBuffer;
    bool status = cooking->cookTriangleMesh(meshDesc, writeBuffer);
    if (!status)
        return nullptr; 

    PxDefaultMemoryInputData readBuffer(writeBuffer.getData(), writeBuffer.getSize());
    PxTriangleMesh* triangleMesh = physics->createTriangleMesh(readBuffer);

    return triangleMesh;
}

I want to give a collider to mesh that load by assimp so I made a physX triangleMesh. In many situations, it works But sometimes in cookTriangleMesh Exception thrown at 0x00007FFD322F259E (PhysXCooking_64.dll) in Client.exe: 0xC0000005: Access violation reading location 0x0000019F69AA8000. occurs.

I was worried about the capacity of buffer and gave him a 1.5 times space, and I checked ((physx::PxSimpleTriangleMesh)&meshDesc),nd {points={count=82772 } triangles={count=43798 } flags={mBits=0 } } writeBuffer.mBuffer.capacity() 2278260 These two always came out the same either success or failure..

So I don't have a clue what the problem is. Can someone who knows the problem and how to solve it help me?

Improve mesh geometry serialization performance

2023-08-26T19:59:44Z

I want to improve the serialization time of my 3D application. I use the following scene for testing: https://www.dropbox.com/scl/fi/j8ays9phm2xs45icla4bo/TestScene.zip?rlkey=qy8jpwgz3s8b95mz62l8axcug&dl=0

I did a performance comparison with Blender and 3DS Max.
Blender: 1 second
3DS max: 2 seconds
My application: 15 seconds !!

To serialize meshes I use the OBJ file format and Assimp.
The Assimp serialization time is too high. Should I write my own format? Is there any tricks I should know about?

Thank you. For convenience here my serialization code:

    aiScene* scene = new aiScene();

    // Allocate materials memory
    scene->mNumMaterials = 1;
    scene->mMaterials = new aiMaterial*[scene->mNumMaterials];
    
    // Allocate mesh memory
    scene->mNumMeshes = (unsigned)m_flatMeshContainer.size();
    scene->mMeshes = new aiMesh*[m_flatMeshContainer.size()];

    scene->mRootNode = new aiNode();
    scene->mRootNode->mNumMeshes = 0;

    // Create materials
    for (Uint32 i = 0u; i < scene->mNumMaterials; ++i)
    {
        scene->mMaterials[i] = new aiMaterial();
    }

    // Create meshes
    std::mutex mtx;
    tbb::parallel_for(size_t(0), m_meshGroupIdentifiers.size(), [&](size_t idx) {

        const auto& groupId = m_meshGroupIdentifiers[idx];
        const auto group = getMeshGroupPtr_FromEntity(groupId);

        // Create meshes
        const auto nbMeshes = (unsigned)group->m_meshes.size();
        aiNode* node = new aiNode();
        node->mMeshes = new unsigned int[nbMeshes];
        node->mNumMeshes = nbMeshes;

        for (Uint32 i = 0u; i < nbMeshes; ++i)
        {
            // Init mesh
            const Mesh* nativeMesh = group->m_meshes[i];
            const auto flatMeshIdx = nativeMesh->getFlatId();
            scene->mMeshes[flatMeshIdx] = new aiMesh();
            node->mMeshes[i] = flatMeshIdx;

            aiMesh* mesh = scene->mMeshes[flatMeshIdx];
            mesh->mName = group->getName();
            mesh->mMaterialIndex = 0;

            // Build vertices
            const auto& vertices = nativeMesh->getRealVertices();
            const auto nbVertex = (unsigned)vertices.size();

            mesh->mVertices = new aiVector3D[nbVertex];
            mesh->mNormals = new aiVector3D[nbVertex];
            mesh->mNumVertices = nbVertex;

            mesh->mTextureCoords[0] = new aiVector3D[nbVertex];
            mesh->mNumUVComponents[0] = nbVertex;

            for (Uint32 j = 0u; j < nbVertex; ++j)
            {
                const auto& vtx = vertices[j];

                mesh->mVertices[j] = aiVector3D(vtx.position.x, vtx.position.y, vtx.position.z);
                mesh->mNormals[j] = aiVector3D(vtx.normal.x, vtx.normal.y, vtx.normal.z);
                mesh->mTextureCoords[0][j] = aiVector3D(vtx.texCoord.x, vtx.texCoord.y, 0);
            }

            // Build faces
            const auto& indices = nativeMesh->getRealIndices();
            mesh->mNumFaces = (unsigned)indices.size() / PRIMITIVE_NB_VTX;
            mesh->mFaces = new aiFace[mesh->mNumFaces];

            for (Uint32 j = 0u; j < indices.size(); j += PRIMITIVE_NB_VTX)
            {
                aiFace &face = mesh->mFaces[j / PRIMITIVE_NB_VTX];
                face.mIndices = new unsigned int[PRIMITIVE_NB_VTX];
                face.mNumIndices = PRIMITIVE_NB_VTX;

                for (Uint32 k = 0; k < PRIMITIVE_NB_VTX; ++k)
                {
                    face.mIndices[k] = indices[k + j];
                }
            }
        }

        std::lock_guard<std::mutex> lock(mtx);
        scene->mRootNode->addChildren(1, &node);
    });


    const auto objPath = m_serializationFullPath.string();
    Assimp::Exporter exporter;
    // HERE : SLOW  --------------------------------------------------------------------------------------------
    exporter.Export(scene, "obj", objPath);
    // ---------------------------------------------------------------------------------------------------------

    delete scene;

How can I get texture file by using assimp?

2023-08-15T10:07:25Z

I am developing FBX model viewer using directx and assimp library. For loading texture, I called function like below. (I got FBX from mixamo)

aiString path;
mat->Get(AI_MATKEY_TEXTURE_DIFFUSE(0), path); // mat is aiMaterial*

The "path" variable now has "../../../../home/app/mixamo-mini/tmp/skins_XXX.fbm/Mutant_Diffuse.png"

I cannot find that path on my computer from the location where FBX file exists. I use Windows 11 Pro. How can I read the texture files Assimp extracted ? Even "../../../../home" does not exist.

How to check that extracted FBX indices are correct?

2023-08-14T08:14:44Z

I am trying to import FBX file using FBX SDK. Reference was "ImportScene" sample of FBX. I've extracted vertices (control point in FBX) and indices. I wanted to check whether the extracted values are correct by comparing the values using other library on same FBX file. The other library is ASSIMP. However, the extracted values of each library are different and I have no idea the values of which library is correct. I've tried to check which values are correct using other tools such as Blender and Unity. However, I couldn't find way to see the table of vertex indices. So my question is

Q. How to check that extracted FBX indices are correct?

Below are extracted values from FBX SDK and ASSIMP.

	FBX SDK	ASSIMP
Vertices
Indices
Triangulate

[Assumption]

My assumption is FBX vertices are correct while ASSIMP vertices z values are inverted (to negative). FBX indices are correct while ASSIMP indices are wrong.

The reason for assumption is Vertex count is 2409, face count is 4602 in Blender. FBX SDK gives 4602 faces and all GetPolygonSize gives 3, which means 13806 (= 4602 * 3) vertices (overlapping). However, ASSIMP gives 10482 vertices and some vertices have exact same x, y, z values. It seems ASSIMP is trying to give overlapping vertices. 10482 vertices seem weird anyway.

But assumption is assumption. I'd want to check the extracted values by model viewer that can show tables of imported mesh's vertices and indices. However, I could not find so far.

If anyone helps, it will be really appreciated.

How do I compile cmake generated binaries in 64bits using MinGW (Windows, GCC)?

2023-08-08T20:36:16Z

I've been trying to compile the model loading library Assimp for my project using cmake and then MinGW. However, I don't know how to do that for 64bits which is what I'm using on my project. I used the command "mingw32-make" but if I understand correctly that is for 32bits and when I try to run my project with the obtained DLL it exits without explanation. I've heard this can happen when you try to link 32bit files with a 64bit projects. I heard about "make.exe" but I don't know if it's what I need and either way I can't find it in my MinGW folder. I'd rather not resort to Visual Studio, I use VSCode.

Can you check if there are any errors in the collada (.dae) models that I extracted?

2023-08-05T13:38:51Z

I used the Assimp loader in my DirectX 11 engine to open my .dae model files, but it's not functioning correctly.

My team and I don't believe there are any errors in my code, so I asked others for help. They suggested that there might be an issue with the model itself. I will upload the model files, and I would appreciate it if you could let me know if there are any problems with them.

The issues I anticipate are as follows:

Debugging results show that the values of the base vectors are incorrect. The bone information I was manipulating is in local space, so the expected world position, rotation, and base are not being applied correctly.

Model - Google drive

This is the code I used to load the model.

void Model::recursiveProcessBoneMatrix(aiMatrix4x4 matrix, const std::wstring& nodeName)
{
    const ModelNode* modelNode = FindNode(nodeName);
    aiMatrix4x4 transform = modelNode->mTransformation;

    if (mParentModel)
    {
        // Code written to search for nodes with the same name in the model.
        ModelNode* parentModelNode = mParentModel->FindNode(nodeName);
        if (parentModelNode)
        {
            /*
            Set my hierarchy information based on the parent's corresponding node hierarchy.
            Although the model is forced to move to the position of that node, 
            it causes rotation issues.
            */
            Bone* bone = mParentModel->FindBone(nodeName);

            if (bone != nullptr)
            {
                bone = mParentModel->GetBone(bone->mIndex);

                matrix = bone->mLocalMatrix;
            }
        }
    }

    matrix = matrix * transform;


    if (mBoneMap.find(nodeName) != mBoneMap.end())
    {
        Bone* bone = &mBoneMap.find(nodeName)->second;
        aiMatrix4x4 glovalInvers = FindNode(L"Scene")->GetTransformation();

        // bone->mOffsetMatrix - vectex to bonespace (like world, view, projection transform)
        //matrix - transformed martrix from root
        bone->mFinalMatrix = glovalInvers.Inverse() * matrix * bone->mOffsetMatrix;
        bone->mLocalMatrix = matrix;

        mBones[bone->mIndex].mFinalMatrix = bone->mFinalMatrix;
        mBones[bone->mIndex].mLocalMatrix = matrix;
    }

    for (size_t i = 0; i < modelNode->mChilds.size(); ++i)
    {
        recursiveProcessBoneMatrix(matrix, modelNode->mChilds[i]->mName);
    }
}

Newest questions tagged assimp - Stack Overflow

Animation not animating correctly in assimp [closed]

What is the purpose of the pkey parameter?

Reading a 3D model with lwjgl-assimp failes in Clojure

Failing to load FBX meshes with correct transform. Assimp 5.2.5

Visual Studio 2022 OpenGL Project: 'assimp/Importer.hpp' Not Found Despite Correct Include Path

Texture mapping issues with Assimp and OpenGL: Some meshes have incorrect UV mapping [closed]

C++/Raylib - Unable to load mesh with Assimp

Assimp .NET Model Animation went wrong (DEFAULT VALUES?)

What am I doing wrong when loading a skeleton and animation?

Im storing the animation and skeleton in the structure below.

Code from the importer.

Code from the animator.

Strange relative paths containing "*0\0" or "*1\0" cutting off the first 3 characters of path while working with Blender, Assimp.NET and FBX files

How can I use assimp's aiMeshMorphKey to animate a character's facial expressions?

What is aiAnimation in assimp library?

Miscalculating skeleton matrices from assimp

CMake: including assimp header files and linking to shared library [duplicate]

Helix Viewport + SharpDX - Loaded models not visible in viewport

How to convert UTextureRenderTarget2D to Assimp embaded texture?

Getting a lot of "Duplicate class ... found in modules assimp.jar"

Using rapidjson and assimp together causes rapidjson to behave unpredictably

PyAssimp error for any loaded file - Scene has not attribute meshes, materials or textures

Converting local space normals into world space

UV texture mapping issue in .X file using assimp

Issue Linking Assimp Windows 11

DirectX12 Problems with skeletal animation and Assimp library

Bind different 3d models to a main model with opengl and assimp

cookTriangleMesh access exception

Improve mesh geometry serialization performance

How can I get texture file by using assimp?

How to check that extracted FBX indices are correct?

How do I compile cmake generated binaries in 64bits using MinGW (Windows, GCC)?

Can you check if there are any errors in the collada (.dae) models that I extracted?

Strange relative paths containing "0\0" or "1\0" cutting off the first 3 characters of path while working with Blender, Assimp.NET and FBX files