CSE::DAELoader Class Reference

Public Types
enum	LOAD_TYPE {   ALL , MESH , ANIMATION , AUTO ,   NOTHING }

Public Member Functions
	DAELoader (const char *path, LOAD_TYPE type, bool isLoad)
void	Load (const char *path, LOAD_TYPE type)
void	LoadTexture (const AssetMgr::AssetReference *asset)
Skeleton *	getSkeleton () const
SPrefab *	GeneratePrefab (Animation *animation, SPrefab *prefab=nullptr)

Static Public Member Functions
static SPrefab *	GeneratePrefab (const char *path, Skeleton *skeleton, MeshSurface *mesh, Animation *animation, SPrefab *prefab=nullptr)

Detailed Description

Definition at line 18 of file DAELoader.h.

Member Enumeration Documentation

LOAD_TYPE

enum CSE::DAELoader::LOAD_TYPE

Definition at line 20 of file DAELoader.h.

                       {
            ALL, MESH, ANIMATION, AUTO, NOTHING
        };

Constructor & Destructor Documentation

DAELoader()

DAELoader::DAELoader	(	const char *	path,
		LOAD_TYPE	type,
		bool	isLoad
	)

Definition at line 16 of file DAELoader.cpp.

                                                                  {
    if (type == NOTHING) return;
 
    if (isLoad) Load(path, type);
}

~DAELoader()

DAELoader::~DAELoader

(

)

Definition at line 22 of file DAELoader.cpp.

                      {
    Exterminate();
}

Member Function Documentation

GeneratePrefab() [1/2]

SPrefab * DAELoader::GeneratePrefab	(	Animation *	animation,
		SPrefab *	prefab = nullptr
	)

Definition at line 519 of file DAELoader.cpp.

                                                                        {
    if (prefab == nullptr)
        prefab = new SPrefab();
    auto* root = new SGameObjectFromSPrefab(m_name);
    prefab->SetGameObject(root);
 
    SGameObject* joint_root = nullptr;
 
    if (m_isSkinning) {
        joint_root = new SGameObjectFromSPrefab("Armature");
        root->AddChild(joint_root);
        DAEConvertSGameObject::CreateJoints(joint_root, m_skeletonData->getHeadJoint());
    }
 
    JointComponent* joint_root_component = m_isSkinning ? joint_root->GetChildren().front()->GetComponent<JointComponent>() : nullptr;
    for (const auto& mesh : m_meshList) {
        auto* mesh_root = new SGameObjectFromSPrefab(mesh->meshName);
        root->AddChild(mesh_root);
        DrawableStaticMeshComponent* mesh_component = nullptr;
 
        if (m_isSkinning) {
            mesh_component = mesh_root->CreateComponent<DrawableSkinnedMeshComponent>();
        } else {
            mesh_component = mesh_root->CreateComponent<DrawableStaticMeshComponent>();
        }
 
        mesh_component->SetMesh(*mesh->meshSurface);
 
        if (m_isSkinning)
            dynamic_cast<DrawableSkinnedMeshComponent*>(mesh_component)->SetRootJoint(
                    joint_root_component->GetGameObject(),
                    m_skeletonData->getJointCount());
 
        auto renderComponent = mesh_root->CreateComponent<RenderComponent>();
//    mesh_root->GetComponent<RenderComponent>()->SetShaderHandle("PBR.shader");
    }
 
    if (m_isSkinning) {
        SGameObject* animationObj = DAEConvertSGameObject::CreateAnimation(root, joint_root_component,
                                                                           m_animationLoader->GetAnimation(),
                                                                           m_name, animation);
    }
 
    return prefab;
}

GeneratePrefab() [2/2]

SPrefab * DAELoader::GeneratePrefab ( const char *  path, Skeleton *  skeleton, MeshSurface *  mesh, Animation *  animation, SPrefab *  prefab = nullptr  )

static

Definition at line 565 of file DAELoader.cpp.

                                                    {
    auto* loader = new DAELoader(path, AUTO, false);
    auto asset = CORE->GetCore(ResMgr)->GetAssetReference(path);
    if (asset == nullptr) {
        SAFE_DELETE(loader);
        return nullptr;
    }
    std::string prefab_id = asset->id;
 
    loader->m_resource_id = asset->id;
    loader->m_skeletonData = skeleton;
 
    if (loader->m_skeletonData == nullptr) {
        loader->m_skeletonData = new Skeleton();
    }
 
    const auto& meshData = loader->m_meshList;
    for (const auto& mesh : meshData) {
        mesh->meshSurface->LinkResource(prefab_id + "." + mesh->meshName +"?mesh");
    }
    loader->m_skeletonData->LinkResource(prefab_id + "?skeleton");
 
    loader->Load(path, AUTO);
    prefab = loader->GeneratePrefab(animation, prefab);
 
    SAFE_DELETE(loader);
    return prefab;
}

getSkeleton()

Skeleton * CSE::DAELoader::getSkeleton ( ) const

inline

Definition at line 56 of file DAELoader.h.

                                      {
            return m_skeletonData;
        }

Load()

void DAELoader::Load	(	const char *	path,
		LOAD_TYPE	type
	)

Definition at line 26 of file DAELoader.cpp.

                                                     {
    {
        std::string path_str = path;
        std::size_t index = path_str.rfind('/');
        if (index == std::string::npos) {
            index = path_str.rfind('\\');
        }
        std::size_t name_index = path_str.rfind('.');
 
        m_name = path_str.substr(index + 1, name_index - index - 1);
    }
 
    m_root = XFILE(path).getRoot();
    XNode collada = m_root->getChild("COLLADA");
 
    if (type == LOAD_TYPE::MESH || type == LOAD_TYPE::ALL || type == LOAD_TYPE::AUTO) {
        try {
            bool safe_result;
            if(collada.hasChild("library_controllers") && collada.hasChild("library_visual_scenes")) {
                safe_result = LoadSkin(collada.getChild("library_controllers"));
                safe_result &= LoadSkeleton(collada.getChild("library_visual_scenes"));
            }
            else
                safe_result = false;
            m_isSkinning = safe_result;
        } catch (int error) {
            std::cout << "passing skinning...\n";
            m_isSkinning = false;
        }
 
        try {
            if(collada.hasChild("library_images"))
                LoadTexturePath(collada.getChild("library_images"));
            else
                std::cout << "passing texture...\n";
        } catch (int error) {
            std::cout << "passing texture...\n";
        }
 
        try {
            const auto& geometryData = collada.getChild("library_geometries").children;
            m_meshList.reserve(geometryData.size());
 
            for (const auto& geometry : geometryData) {
                auto meshData = new DAEMeshData();
                meshData->meshName = geometry.getAttribute("id").value;
                LoadGeometry(geometry, meshData);
                m_meshList.push_back(meshData);
            }
        } catch (int error) {
            std::cout << "passing geometry...\n";
        }
    }
    if (type == ANIMATION || type == ALL || type == AUTO) {
        try {
            bool safe_exception;
            m_animationLoader = new DAEAnimationLoader();
            safe_exception = m_animationLoader->Load(path, m_name);
#ifdef __EMSCRIPTEN__
            if(!safe_exception) {
                SAFE_DELETE(m_animationLoader);
            }
#endif
        } catch (int error) {
            SAFE_DELETE(m_animationLoader);
            std::cout << "passing Animation...\n";
        }
    }
//    LoadTexture(texture_path);
}

LoadTexture()

void DAELoader::LoadTexture

(

const AssetMgr::AssetReference *

asset

)

Definition at line 98 of file DAELoader.cpp.

                                                               {
    if (asset == nullptr) return;
 
    auto* texture = SResource::Create<STexture>(asset);
    m_texture_name = texture->GetName();
}

---

The documentation for this class was generated from the following files:

• Util/Loader/DAE/DAELoader.h
• Util/Loader/DAE/DAELoader.cpp