448 lines
18 KiB
C++
448 lines
18 KiB
C++
/*************************************************************************/
|
|
/* import_utils.h */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
#ifndef IMPORT_UTILS_IMPORTER_ASSIMP_H
|
|
#define IMPORT_UTILS_IMPORTER_ASSIMP_H
|
|
|
|
#include "core/io/image_loader.h"
|
|
#include "import_state.h"
|
|
|
|
#include <assimp/SceneCombiner.h>
|
|
#include <assimp/cexport.h>
|
|
#include <assimp/cimport.h>
|
|
#include <assimp/matrix4x4.h>
|
|
#include <assimp/pbrmaterial.h>
|
|
#include <assimp/postprocess.h>
|
|
#include <assimp/scene.h>
|
|
#include <assimp/DefaultLogger.hpp>
|
|
#include <assimp/Importer.hpp>
|
|
#include <assimp/LogStream.hpp>
|
|
#include <assimp/Logger.hpp>
|
|
#include <string>
|
|
|
|
using namespace AssimpImporter;
|
|
|
|
#define AI_PROPERTIES aiTextureType_UNKNOWN, 0
|
|
#define AI_NULL 0, 0
|
|
#define AI_MATKEY_FBX_MAYA_BASE_COLOR_FACTOR "$raw.Maya|baseColor"
|
|
#define AI_MATKEY_FBX_MAYA_METALNESS_FACTOR "$raw.Maya|metalness"
|
|
#define AI_MATKEY_FBX_MAYA_DIFFUSE_ROUGHNESS_FACTOR "$raw.Maya|diffuseRoughness"
|
|
|
|
#define AI_MATKEY_FBX_MAYA_EMISSION_TEXTURE "$raw.Maya|emissionColor|file"
|
|
#define AI_MATKEY_FBX_MAYA_EMISSIVE_FACTOR "$raw.Maya|emission"
|
|
#define AI_MATKEY_FBX_MAYA_METALNESS_TEXTURE "$raw.Maya|metalness|file"
|
|
#define AI_MATKEY_FBX_MAYA_METALNESS_UV_XFORM "$raw.Maya|metalness|uvtrafo"
|
|
#define AI_MATKEY_FBX_MAYA_DIFFUSE_ROUGHNESS_TEXTURE "$raw.Maya|diffuseRoughness|file"
|
|
#define AI_MATKEY_FBX_MAYA_DIFFUSE_ROUGHNESS_UV_XFORM "$raw.Maya|diffuseRoughness|uvtrafo"
|
|
#define AI_MATKEY_FBX_MAYA_BASE_COLOR_TEXTURE "$raw.Maya|baseColor|file"
|
|
#define AI_MATKEY_FBX_MAYA_BASE_COLOR_UV_XFORM "$raw.Maya|baseColor|uvtrafo"
|
|
#define AI_MATKEY_FBX_MAYA_NORMAL_TEXTURE "$raw.Maya|normalCamera|file"
|
|
#define AI_MATKEY_FBX_MAYA_NORMAL_UV_XFORM "$raw.Maya|normalCamera|uvtrafo"
|
|
|
|
#define AI_MATKEY_FBX_NORMAL_TEXTURE "$raw.Maya|normalCamera|file"
|
|
#define AI_MATKEY_FBX_NORMAL_UV_XFORM "$raw.Maya|normalCamera|uvtrafo"
|
|
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_DISPLACEMENT_SCALING_FACTOR "$raw.Maya|displacementscaling"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_BASE_COLOR_FACTOR "$raw.Maya|base_color"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_EMISSIVE_FACTOR "$raw.Maya|emissive"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_METALLIC_FACTOR "$raw.Maya|metallic"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_ROUGHNESS_FACTOR "$raw.Maya|roughness"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_EMISSIVE_INTENSITY_FACTOR "$raw.Maya|emissive_intensity"
|
|
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_NORMAL_TEXTURE "$raw.Maya|TEX_normal_map|file"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_NORMAL_UV_XFORM "$raw.Maya|TEX_normal_map|uvtrafo"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_COLOR_TEXTURE "$raw.Maya|TEX_color_map|file"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_COLOR_UV_XFORM "$raw.Maya|TEX_color_map|uvtrafo"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_METALLIC_TEXTURE "$raw.Maya|TEX_metallic_map|file"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_METALLIC_UV_XFORM "$raw.Maya|TEX_metallic_map|uvtrafo"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_ROUGHNESS_TEXTURE "$raw.Maya|TEX_roughness_map|file"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_ROUGHNESS_UV_XFORM "$raw.Maya|TEX_roughness_map|uvtrafo"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_EMISSIVE_TEXTURE "$raw.Maya|TEX_emissive_map|file"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_EMISSIVE_UV_XFORM "$raw.Maya|TEX_emissive_map|uvtrafo"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_AO_TEXTURE "$raw.Maya|TEX_ao_map|file"
|
|
#define AI_MATKEY_FBX_MAYA_STINGRAY_AO_UV_XFORM "$raw.Maya|TEX_ao_map|uvtrafo"
|
|
|
|
/**
|
|
* Assimp Utils
|
|
* Conversion tools / glue code to convert from assimp to godot
|
|
*/
|
|
class AssimpUtils {
|
|
public:
|
|
/**
|
|
* calculate tangents for mesh data from assimp data
|
|
*/
|
|
static void calc_tangent_from_mesh(const aiMesh *ai_mesh, int i, int tri_index, int index, PoolColorArray::Write &w) {
|
|
const aiVector3D normals = ai_mesh->mAnimMeshes[i]->mNormals[tri_index];
|
|
const Vector3 godot_normal = Vector3(normals.x, normals.y, normals.z);
|
|
const aiVector3D tangent = ai_mesh->mAnimMeshes[i]->mTangents[tri_index];
|
|
const Vector3 godot_tangent = Vector3(tangent.x, tangent.y, tangent.z);
|
|
const aiVector3D bitangent = ai_mesh->mAnimMeshes[i]->mBitangents[tri_index];
|
|
const Vector3 godot_bitangent = Vector3(bitangent.x, bitangent.y, bitangent.z);
|
|
float d = godot_normal.cross(godot_tangent).dot(godot_bitangent) > 0.0f ? 1.0f : -1.0f;
|
|
Color plane_tangent = Color(tangent.x, tangent.y, tangent.z, d);
|
|
w[index] = plane_tangent;
|
|
}
|
|
|
|
struct AssetImportFbx {
|
|
enum ETimeMode {
|
|
TIME_MODE_DEFAULT = 0,
|
|
TIME_MODE_120 = 1,
|
|
TIME_MODE_100 = 2,
|
|
TIME_MODE_60 = 3,
|
|
TIME_MODE_50 = 4,
|
|
TIME_MODE_48 = 5,
|
|
TIME_MODE_30 = 6,
|
|
TIME_MODE_30_DROP = 7,
|
|
TIME_MODE_NTSC_DROP_FRAME = 8,
|
|
TIME_MODE_NTSC_FULL_FRAME = 9,
|
|
TIME_MODE_PAL = 10,
|
|
TIME_MODE_CINEMA = 11,
|
|
TIME_MODE_1000 = 12,
|
|
TIME_MODE_CINEMA_ND = 13,
|
|
TIME_MODE_CUSTOM = 14,
|
|
TIME_MODE_TIME_MODE_COUNT = 15
|
|
};
|
|
enum UpAxis {
|
|
UP_VECTOR_AXIS_X = 1,
|
|
UP_VECTOR_AXIS_Y = 2,
|
|
UP_VECTOR_AXIS_Z = 3
|
|
};
|
|
enum FrontAxis {
|
|
FRONT_PARITY_EVEN = 1,
|
|
FRONT_PARITY_ODD = 2,
|
|
};
|
|
|
|
enum CoordAxis {
|
|
COORD_RIGHT = 0,
|
|
COORD_LEFT = 1
|
|
};
|
|
};
|
|
|
|
/** Get assimp string
|
|
* automatically filters the string data
|
|
*/
|
|
static String get_assimp_string(const aiString &p_string) {
|
|
//convert an assimp String to a Godot String
|
|
String name;
|
|
name.parse_utf8(p_string.C_Str() /*,p_string.length*/);
|
|
if (name.find(":") != -1) {
|
|
String replaced_name = name.split(":")[1];
|
|
print_verbose("Replacing " + name + " containing : with " + replaced_name);
|
|
name = replaced_name;
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
static String get_anim_string_from_assimp(const aiString &p_string) {
|
|
|
|
String name;
|
|
name.parse_utf8(p_string.C_Str() /*,p_string.length*/);
|
|
if (name.find(":") != -1) {
|
|
String replaced_name = name.split(":")[1];
|
|
print_verbose("Replacing " + name + " containing : with " + replaced_name);
|
|
name = replaced_name;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* No filter logic get_raw_string_from_assimp
|
|
* This just convers the aiString to a parsed utf8 string
|
|
* Without removing special chars etc
|
|
*/
|
|
static String get_raw_string_from_assimp(const aiString &p_string) {
|
|
String name;
|
|
name.parse_utf8(p_string.C_Str() /*,p_string.length*/);
|
|
return name;
|
|
}
|
|
|
|
static Ref<Animation> import_animation(const String &p_path, uint32_t p_flags, int p_bake_fps) {
|
|
return Ref<Animation>();
|
|
}
|
|
|
|
/**
|
|
* Converts aiMatrix4x4 to godot Transform
|
|
*/
|
|
static const Transform assimp_matrix_transform(const aiMatrix4x4 p_matrix) {
|
|
aiMatrix4x4 matrix = p_matrix;
|
|
Transform xform;
|
|
xform.set(matrix.a1, matrix.a2, matrix.a3, matrix.b1, matrix.b2, matrix.b3, matrix.c1, matrix.c2, matrix.c3, matrix.a4, matrix.b4, matrix.c4);
|
|
return xform;
|
|
}
|
|
|
|
/** Get fbx fps for time mode meta data
|
|
*/
|
|
static float get_fbx_fps(int32_t time_mode, const aiScene *p_scene) {
|
|
switch (time_mode) {
|
|
case AssetImportFbx::TIME_MODE_DEFAULT: return 24; //hack
|
|
case AssetImportFbx::TIME_MODE_120: return 120;
|
|
case AssetImportFbx::TIME_MODE_100: return 100;
|
|
case AssetImportFbx::TIME_MODE_60: return 60;
|
|
case AssetImportFbx::TIME_MODE_50: return 50;
|
|
case AssetImportFbx::TIME_MODE_48: return 48;
|
|
case AssetImportFbx::TIME_MODE_30: return 30;
|
|
case AssetImportFbx::TIME_MODE_30_DROP: return 30;
|
|
case AssetImportFbx::TIME_MODE_NTSC_DROP_FRAME: return 29.9700262f;
|
|
case AssetImportFbx::TIME_MODE_NTSC_FULL_FRAME: return 29.9700262f;
|
|
case AssetImportFbx::TIME_MODE_PAL: return 25;
|
|
case AssetImportFbx::TIME_MODE_CINEMA: return 24;
|
|
case AssetImportFbx::TIME_MODE_1000: return 1000;
|
|
case AssetImportFbx::TIME_MODE_CINEMA_ND: return 23.976f;
|
|
case AssetImportFbx::TIME_MODE_CUSTOM:
|
|
int32_t frame_rate = -1;
|
|
p_scene->mMetaData->Get("FrameRate", frame_rate);
|
|
return frame_rate;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Get global transform for the current node - so we can use world space rather than
|
|
* local space coordinates
|
|
* useful if you need global - although recommend using local wherever possible over global
|
|
* as you could break fbx scaling :)
|
|
*/
|
|
static Transform _get_global_assimp_node_transform(const aiNode *p_current_node) {
|
|
aiNode const *current_node = p_current_node;
|
|
Transform xform;
|
|
while (current_node != NULL) {
|
|
xform = assimp_matrix_transform(current_node->mTransformation) * xform;
|
|
current_node = current_node->mParent;
|
|
}
|
|
return xform;
|
|
}
|
|
|
|
/**
|
|
* Find hardcoded textures from assimp which could be in many different directories
|
|
*/
|
|
static void find_texture_path(const String &p_path, _Directory &dir, String &path, bool &found, String extension) {
|
|
Vector<String> paths;
|
|
paths.push_back(path.get_basename() + extension);
|
|
paths.push_back(path + extension);
|
|
paths.push_back(path);
|
|
paths.push_back(p_path.get_base_dir().plus_file(path.get_file().get_basename() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file(path.get_file() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file(path.get_file()));
|
|
paths.push_back(p_path.get_base_dir().plus_file("textures/" + path.get_file().get_basename() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("textures/" + path.get_file() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("textures/" + path.get_file()));
|
|
paths.push_back(p_path.get_base_dir().plus_file("Textures/" + path.get_file().get_basename() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("Textures/" + path.get_file() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("Textures/" + path.get_file()));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../Textures/" + path.get_file() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../Textures/" + path.get_file().get_basename() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../Textures/" + path.get_file()));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../textures/" + path.get_file().get_basename() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../textures/" + path.get_file() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../textures/" + path.get_file()));
|
|
paths.push_back(p_path.get_base_dir().plus_file("texture/" + path.get_file().get_basename() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("texture/" + path.get_file() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("texture/" + path.get_file()));
|
|
paths.push_back(p_path.get_base_dir().plus_file("Texture/" + path.get_file().get_basename() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("Texture/" + path.get_file() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("Texture/" + path.get_file()));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../Texture/" + path.get_file() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../Texture/" + path.get_file().get_basename() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../Texture/" + path.get_file()));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../texture/" + path.get_file().get_basename() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../texture/" + path.get_file() + extension));
|
|
paths.push_back(p_path.get_base_dir().plus_file("../texture/" + path.get_file()));
|
|
for (int i = 0; i < paths.size(); i++) {
|
|
if (dir.file_exists(paths[i])) {
|
|
found = true;
|
|
path = paths[i];
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** find the texture path for the supplied fbx path inside godot
|
|
* very simple lookup for subfolders etc for a texture which may or may not be in a directory
|
|
*/
|
|
static void find_texture_path(const String &r_p_path, String &r_path, bool &r_found) {
|
|
_Directory dir;
|
|
|
|
List<String> exts;
|
|
ImageLoader::get_recognized_extensions(&exts);
|
|
|
|
Vector<String> split_path = r_path.get_basename().split("*");
|
|
if (split_path.size() == 2) {
|
|
r_found = true;
|
|
return;
|
|
}
|
|
|
|
if (dir.file_exists(r_p_path.get_base_dir() + r_path.get_file())) {
|
|
r_path = r_p_path.get_base_dir() + r_path.get_file();
|
|
r_found = true;
|
|
return;
|
|
}
|
|
|
|
for (int32_t i = 0; i < exts.size(); i++) {
|
|
if (r_found) {
|
|
return;
|
|
}
|
|
find_texture_path(r_p_path, dir, r_path, r_found, "." + exts[i]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* set_texture_mapping_mode
|
|
* Helper to check the mapping mode of the texture (repeat, clamp and mirror)
|
|
*/
|
|
static void set_texture_mapping_mode(aiTextureMapMode *map_mode, Ref<ImageTexture> texture) {
|
|
ERR_FAIL_COND(texture.is_null());
|
|
ERR_FAIL_COND(map_mode == NULL);
|
|
aiTextureMapMode tex_mode = map_mode[0];
|
|
|
|
int32_t flags = Texture::FLAGS_DEFAULT;
|
|
if (tex_mode == aiTextureMapMode_Wrap) {
|
|
//Default
|
|
} else if (tex_mode == aiTextureMapMode_Clamp) {
|
|
flags = flags & ~Texture::FLAG_REPEAT;
|
|
} else if (tex_mode == aiTextureMapMode_Mirror) {
|
|
flags = flags | Texture::FLAG_MIRRORED_REPEAT;
|
|
}
|
|
texture->set_flags(flags);
|
|
}
|
|
|
|
/**
|
|
* Load or load from cache image :)
|
|
*/
|
|
static Ref<Image> load_image(ImportState &state, const aiScene *p_scene, String p_path) {
|
|
|
|
Map<String, Ref<Image> >::Element *match = state.path_to_image_cache.find(p_path);
|
|
|
|
// if our cache contains this image then don't bother
|
|
if (match) {
|
|
return match->get();
|
|
}
|
|
|
|
Vector<String> split_path = p_path.get_basename().split("*");
|
|
if (split_path.size() == 2) {
|
|
size_t texture_idx = split_path[1].to_int();
|
|
ERR_FAIL_COND_V(texture_idx >= p_scene->mNumTextures, Ref<Image>());
|
|
aiTexture *tex = p_scene->mTextures[texture_idx];
|
|
String filename = AssimpUtils::get_raw_string_from_assimp(tex->mFilename);
|
|
filename = filename.get_file();
|
|
print_verbose("Open Asset Import: Loading embedded texture " + filename);
|
|
if (tex->mHeight == 0) {
|
|
if (tex->CheckFormat("png")) {
|
|
ERR_FAIL_COND_V(Image::_png_mem_loader_func == NULL, Ref<Image>());
|
|
Ref<Image> img = Image::_png_mem_loader_func((uint8_t *)tex->pcData, tex->mWidth);
|
|
ERR_FAIL_COND_V(img.is_null(), Ref<Image>());
|
|
state.path_to_image_cache.insert(p_path, img);
|
|
return img;
|
|
} else if (tex->CheckFormat("jpg")) {
|
|
ERR_FAIL_COND_V(Image::_jpg_mem_loader_func == NULL, Ref<Image>());
|
|
Ref<Image> img = Image::_jpg_mem_loader_func((uint8_t *)tex->pcData, tex->mWidth);
|
|
ERR_FAIL_COND_V(img.is_null(), Ref<Image>());
|
|
state.path_to_image_cache.insert(p_path, img);
|
|
return img;
|
|
} else if (tex->CheckFormat("dds")) {
|
|
ERR_FAIL_COND_V_MSG(true, Ref<Image>(), "Open Asset Import: Embedded dds not implemented");
|
|
}
|
|
} else {
|
|
Ref<Image> img;
|
|
img.instance();
|
|
PoolByteArray arr;
|
|
uint32_t size = tex->mWidth * tex->mHeight;
|
|
arr.resize(size);
|
|
memcpy(arr.write().ptr(), tex->pcData, size);
|
|
ERR_FAIL_COND_V(arr.size() % 4 != 0, Ref<Image>());
|
|
//ARGB8888 to RGBA8888
|
|
for (int32_t i = 0; i < arr.size() / 4; i++) {
|
|
arr.write().ptr()[(4 * i) + 3] = arr[(4 * i) + 0];
|
|
arr.write().ptr()[(4 * i) + 0] = arr[(4 * i) + 1];
|
|
arr.write().ptr()[(4 * i) + 1] = arr[(4 * i) + 2];
|
|
arr.write().ptr()[(4 * i) + 2] = arr[(4 * i) + 3];
|
|
}
|
|
img->create(tex->mWidth, tex->mHeight, true, Image::FORMAT_RGBA8, arr);
|
|
ERR_FAIL_COND_V(img.is_null(), Ref<Image>());
|
|
state.path_to_image_cache.insert(p_path, img);
|
|
return img;
|
|
}
|
|
return Ref<Image>();
|
|
} else {
|
|
Ref<Texture> texture = ResourceLoader::load(p_path);
|
|
ERR_FAIL_COND_V(texture.is_null(), Ref<Image>());
|
|
Ref<Image> image = texture->get_data();
|
|
ERR_FAIL_COND_V(image.is_null(), Ref<Image>());
|
|
state.path_to_image_cache.insert(p_path, image);
|
|
return image;
|
|
}
|
|
|
|
return Ref<Image>();
|
|
}
|
|
|
|
/* create texture from assimp data, if found in path */
|
|
static bool CreateAssimpTexture(
|
|
AssimpImporter::ImportState &state,
|
|
aiString texture_path,
|
|
String &filename,
|
|
String &path,
|
|
AssimpImageData &image_state) {
|
|
filename = get_raw_string_from_assimp(texture_path);
|
|
path = state.path.get_base_dir().plus_file(filename.replace("\\", "/"));
|
|
bool found = false;
|
|
find_texture_path(state.path, path, found);
|
|
if (found) {
|
|
image_state.raw_image = AssimpUtils::load_image(state, state.assimp_scene, path);
|
|
if (image_state.raw_image.is_valid()) {
|
|
image_state.texture.instance();
|
|
image_state.texture->create_from_image(image_state.raw_image);
|
|
image_state.texture->set_storage(ImageTexture::STORAGE_COMPRESS_LOSSY);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
/** GetAssimpTexture
|
|
* Designed to retrieve textures for you
|
|
*/
|
|
static bool GetAssimpTexture(
|
|
AssimpImporter::ImportState &state,
|
|
aiMaterial *ai_material,
|
|
aiTextureType texture_type,
|
|
String &filename,
|
|
String &path,
|
|
AssimpImageData &image_state) {
|
|
aiString ai_filename = aiString();
|
|
if (AI_SUCCESS == ai_material->GetTexture(texture_type, 0, &ai_filename, NULL, NULL, NULL, NULL, image_state.map_mode)) {
|
|
return CreateAssimpTexture(state, ai_filename, filename, path, image_state);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
#endif // IMPORT_UTILS_IMPORTER_ASSIMP_H
|