asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/editor/import/resource_importer_texture.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

774 lines
30 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 13:25:55 +01:00
/**************************************************************************/
/* resource_importer_texture.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
OBJ file importing!
2017-02-03 04:08:50 +01:00
#include "resource_importer_texture.h"
Add a bunch of missing Godot headers in own files
2017-03-05 15:47:28 +01:00
Improve compilation speed (forward declarations/includes cleanup)
2022-02-12 02:46:22 +01:00
#include "core/config/project_settings.h"
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 18:13:45 +02:00
#include "core/io/config_file.h"
#include "core/io/image_loader.h"
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
#include "core/version.h"
Refactoring: rename tools/editor/ to editor/ The other subfolders of tools/ had already been moved to either editor/, misc/ or thirdparty/, so the hiding the editor code that deep was no longer meaningful.
2017-03-05 14:21:25 +01:00
#include "editor/editor_file_system.h"
Style: Apply clang-format to @reduz's changes [ci skip]
2017-09-13 09:13:23 +02:00
#include "editor/editor_node.h"
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
#include "editor/editor_scale.h"
#include "editor/editor_settings.h"
Style: Apply clang-format to @reduz's changes [ci skip]
2017-09-13 09:13:23 +02:00
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
void ResourceImporterTexture::_texture_reimport_roughness(const Ref<CompressedTexture2D> &p_tex, const String &p_normal_path, RS::TextureDetectRoughnessChannel p_channel) {
Don't crash when texture param is null
2021-12-17 16:56:41 +01:00
ERR_FAIL_COND(p_tex.is_null());
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
MutexLock lock(singleton->mutex);
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
StringName path = p_tex->get_path();
if (!singleton->make_flags.has(path)) {
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
singleton->make_flags[path] = MakeInfo();
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
}
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
singleton->make_flags[path].flags |= MAKE_ROUGHNESS_FLAG;
singleton->make_flags[path].channel_for_roughness = p_channel;
singleton->make_flags[path].normal_path_for_roughness = p_normal_path;
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
}
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
void ResourceImporterTexture::_texture_reimport_3d(const Ref<CompressedTexture2D> &p_tex) {
Don't crash when texture param is null
2021-12-17 16:56:41 +01:00
ERR_FAIL_COND(p_tex.is_null());
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
MutexLock lock(singleton->mutex);
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
StringName path = p_tex->get_path();
if (!singleton->make_flags.has(path)) {
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
singleton->make_flags[path] = MakeInfo();
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
}
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
singleton->make_flags[path].flags |= MAKE_3D_FLAG;
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
}
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
void ResourceImporterTexture::_texture_reimport_normal(const Ref<CompressedTexture2D> &p_tex) {
Don't crash when texture param is null
2021-12-17 16:56:41 +01:00
ERR_FAIL_COND(p_tex.is_null());
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
MutexLock lock(singleton->mutex);
-Fix freezes caused by etccomp2, closes #9183 -Normalmaps are now detected and imported as RGTC, both in S3TC and ETC2, this improves their quality.
2017-06-17 02:47:28 +02:00
StringName path = p_tex->get_path();
if (!singleton->make_flags.has(path)) {
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
singleton->make_flags[path] = MakeInfo();
-Fix freezes caused by etccomp2, closes #9183 -Normalmaps are now detected and imported as RGTC, both in S3TC and ETC2, this improves their quality.
2017-06-17 02:47:28 +02:00
}
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
singleton->make_flags[path].flags |= MAKE_NORMAL_FLAG;
-Fix freezes caused by etccomp2, closes #9183 -Normalmaps are now detected and imported as RGTC, both in S3TC and ETC2, this improves their quality.
2017-06-17 02:47:28 +02:00
}
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
void ResourceImporterTexture::update_imports() {
if (EditorFileSystem::get_singleton()->is_scanning() || EditorFileSystem::get_singleton()->is_importing()) {
Fix typos with codespell Using codespell 1.15.0. Method: ``` $ cat > ../godot-word-whitelist.txt << EOF ang curvelinear doubleclick leapyear lod merchantibility nd numer ois ony que seeked synching te uint unselect webp EOF $ codespell -w -q 3 -I ../godot-word-whitelist.txt --skip="./thirdparty,*.po" $ git diff // undo unwanted changes ```
2019-05-19 12:34:40 +02:00
return; // do nothing for now
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
}
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
MutexLock lock(mutex);
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
Vector<String> to_reimport;
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
{
Rename empty() to is_empty()
2020-12-15 13:04:21 +01:00
if (make_flags.is_empty()) {
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
return;
}
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
Use range iterators for `Map`
2021-08-09 22:13:42 +02:00
for (const KeyValue<StringName, MakeInfo> &E : make_flags) {
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
Ref<ConfigFile> cf;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
cf.instantiate();
Use range iterators for `Map`
2021-08-09 22:13:42 +02:00
String src_path = String(E.key) + ".import";
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
Error err = cf->load(src_path);
ERR_CONTINUE(err != OK);
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
bool changed = false;
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
Revert "Disable VRAM compression by default for small textures in Detect 3D"
2022-06-20 15:30:19 +02:00
if (E.value.flags & MAKE_NORMAL_FLAG && int(cf->get_value("params", "compress/normal_map")) == 0) {
Add internationalization for Detect 3D texture import messages These messages are only printed in the editor and can be seen in the editor Output panel, so these should be localizable.
2022-06-13 20:16:14 +02:00
print_line(vformat(TTR("%s: Texture detected as used as a normal map in 3D. Enabling red-green texture compression to reduce memory usage (blue channel is discarded)."), String(E.key)));
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
cf->set_value("params", "compress/normal_map", 1);
changed = true;
}
-Fix freezes caused by etccomp2, closes #9183 -Normalmaps are now detected and imported as RGTC, both in S3TC and ETC2, this improves their quality.
2017-06-17 02:47:28 +02:00
Use range iterators for `Map`
2021-08-09 22:13:42 +02:00
if (E.value.flags & MAKE_ROUGHNESS_FLAG && int(cf->get_value("params", "roughness/mode")) == 0) {
Add internationalization for Detect 3D texture import messages These messages are only printed in the editor and can be seen in the editor Output panel, so these should be localizable.
2022-06-13 20:16:14 +02:00
print_line(vformat(TTR("%s: Texture detected as used as a roughness map in 3D. Enabling roughness limiter based on the detected associated normal map at %s."), String(E.key), E.value.normal_path_for_roughness));
Use range iterators for `Map`
2021-08-09 22:13:42 +02:00
cf->set_value("params", "roughness/mode", E.value.channel_for_roughness + 2);
cf->set_value("params", "roughness/src_normal", E.value.normal_path_for_roughness);
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
changed = true;
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
}
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
Revert "Disable VRAM compression by default for small textures in Detect 3D"
2022-06-20 15:30:19 +02:00
if (E.value.flags & MAKE_3D_FLAG && bool(cf->get_value("params", "detect_3d/compress_to"))) {
const int compress_to = cf->get_value("params", "detect_3d/compress_to");
String compress_string;
cf->set_value("params", "detect_3d/compress_to", 0);
if (compress_to == 1) {
cf->set_value("params", "compress/mode", COMPRESS_VRAM_COMPRESSED);
compress_string = "VRAM Compressed (S3TC/ETC/BPTC)";
} else if (compress_to == 2) {
cf->set_value("params", "compress/mode", COMPRESS_BASIS_UNIVERSAL);
compress_string = "Basis Universal";
}
print_line(vformat(TTR("%s: Texture detected as used in 3D. Enabling mipmap generation and setting the texture compression mode to %s."), String(E.key), compress_string));
cf->set_value("params", "mipmaps/generate", true);
changed = true;
}
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
if (changed) {
cf->save(src_path);
Use range iterators for `Map`
2021-08-09 22:13:42 +02:00
to_reimport.push_back(E.key);
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
}
}
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
make_flags.clear();
}
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
if (to_reimport.size()) {
EditorFileSystem::get_singleton()->reimport_files(to_reimport);
}
}
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
String ResourceImporterTexture::get_importer_name() const {
return "texture";
}
String ResourceImporterTexture::get_visible_name() const {
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
return "Texture2D";
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
void ResourceImporterTexture::get_recognized_extensions(List<String> *p_extensions) const {
ImageLoader::get_recognized_extensions(p_extensions);
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
String ResourceImporterTexture::get_save_extension() const {
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
return "ctex";
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
String ResourceImporterTexture::get_resource_type() const {
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
return "CompressedTexture2D";
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
bool ResourceImporterTexture::get_option_visibility(const String &p_path, const String &p_option, const HashMap<StringName, Variant> &p_options) const {
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
if (p_option == "compress/high_quality" || p_option == "compress/hdr_compression") {
Add ETC1/ETC2 compression support though etc2comp. Remove rg-etc1 code. Also updated travis to use ubuntu 14.04. Fixes #8457.
2017-04-26 17:49:08 +02:00
int compress_mode = int(p_options["compress/mode"]);
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
if (compress_mode != COMPRESS_VRAM_COMPRESSED) {
return false;
}
} else if (p_option == "compress/lossy_quality") {
int compress_mode = int(p_options["compress/mode"]);
if (compress_mode != COMPRESS_LOSSY) {
Add ETC1/ETC2 compression support though etc2comp. Remove rg-etc1 code. Also updated travis to use ubuntu 14.04. Fixes #8457.
2017-04-26 17:49:08 +02:00
return false;
}
Removed fallback system and merged bptc into s3tc
2018-08-27 18:47:13 +02:00
} else if (p_option == "compress/hdr_mode") {
Hide "no BPTC if RGB" and "HDR Mode" options when not using "Video RAM" import.
2018-08-23 00:31:12 +02:00
int compress_mode = int(p_options["compress/mode"]);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
if (compress_mode < COMPRESS_VRAM_COMPRESSED) {
Hide "no BPTC if RGB" and "HDR Mode" options when not using "Video RAM" import.
2018-08-23 00:31:12 +02:00
return false;
}
Hide "Normal Map" import option when using lossless compression on Texture This pull request resolves an issue where images being imported with lossless compression allowed you to select a normal map, but the normal map only applies if you're using VRAM compression. Thereby making it redundant to appear when using lossless compression. This pull request hides the normal map option when lossless compression is selected. Resolves: #59435
2022-03-27 00:21:07 +01:00
} else if (p_option == "compress/normal_map") {
int compress_mode = int(p_options["compress/mode"]);
if (compress_mode == COMPRESS_LOSSLESS) {
return false;
}
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
} else if (p_option == "mipmaps/limit") {
return p_options["mipmaps/generate"];
Add ETC1/ETC2 compression support though etc2comp. Remove rg-etc1 code. Also updated travis to use ubuntu 14.04. Fixes #8457.
2017-04-26 17:49:08 +02:00
}
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
return true;
}
int ResourceImporterTexture::get_preset_count() const {
Remove the obsolete "2D Pixel" import preset Texture filtering is now defined on a per-node basis, thanks to bindless textures provided by Vulkan. This closes #37057.
2020-06-14 15:08:09 +02:00
return 3;
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
String ResourceImporterTexture::get_preset_name(int p_idx) const {
static const char *preset_names[] = {
Make more import preset name translatable
2022-04-27 07:50:54 +02:00
TTRC("2D/3D (Auto-Detect)"),
TTRC("2D"),
TTRC("3D"),
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
};
Make more import preset name translatable
2022-04-27 07:50:54 +02:00
return TTRGET(preset_names[p_idx]);
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
Add path to functions that return iporter options -Allows displaying custom options for specific file format variants -Added support for scene format import to retrieve custom options This PR is necessary for #54886 to be implemented properly.
2021-11-14 18:02:38 +01:00
void ResourceImporterTexture::get_import_options(const String &p_path, List<ImportOption> *r_options, int p_preset) const {
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "compress/mode", PROPERTY_HINT_ENUM, "Lossless,Lossy,VRAM Compressed,VRAM Uncompressed,Basis Universal", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), p_preset == PRESET_3D ? 2 : 0));
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "compress/high_quality"), false));
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
r_options->push_back(ImportOption(PropertyInfo(Variant::FLOAT, "compress/lossy_quality", PROPERTY_HINT_RANGE, "0,1,0.01"), 0.7));
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "compress/hdr_compression", PROPERTY_HINT_ENUM, "Disabled,Opaque Only,Always"), 1));
-Fix freezes caused by etccomp2, closes #9183 -Normalmaps are now detected and imported as RGTC, both in S3TC and ETC2, this improves their quality.
2017-06-17 02:47:28 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "compress/normal_map", PROPERTY_HINT_ENUM, "Detect,Enable,Disabled"), 0));
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "compress/channel_pack", PROPERTY_HINT_ENUM, "sRGB Friendly,Optimized"), 0));
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "mipmaps/generate"), (p_preset == PRESET_3D ? true : false)));
Fixes to Basis Universal.
2019-09-27 14:05:22 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "mipmaps/limit", PROPERTY_HINT_RANGE, "-1,256"), -1));
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "roughness/mode", PROPERTY_HINT_ENUM, "Detect,Disabled,Red,Green,Blue,Alpha,Gray"), 0));
Remove property hints referencing unsupported svgz extension The wrongly claimed support for it was removed in #49645. See also #56862.
2022-01-17 12:39:57 +01:00
r_options->push_back(ImportOption(PropertyInfo(Variant::STRING, "roughness/src_normal", PROPERTY_HINT_FILE, "*.bmp,*.dds,*.exr,*.jpeg,*.jpg,*.hdr,*.png,*.svg,*.tga,*.webp"), ""));
Some code changed with Clang-Tidy
2019-06-26 15:08:25 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "process/fix_alpha_border"), p_preset != PRESET_3D));
Ability to restart particle system with a function call
2017-06-25 13:01:15 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "process/premult_alpha"), false));
Replace "Invert" import option with more useful "Normal Map Invert Y" This can be used to invert a normal map's direction. The "Invert" import option is no longer useful in Godot 4.0 since it uses height maps instead of depth maps in StandardMaterial3D. This closes https://github.com/godotengine/godot-proposals/issues/785.
2020-05-31 19:27:29 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "process/normal_map_invert_y"), false));
Rename Hdr as Srgb texture import option to be lowercase Unlike all other import options, Hdr As Srgb was internally spelled out with uppercase characters.
2022-02-12 02:39:10 +01:00
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "process/hdr_as_srgb"), false));
Add an option to clamp HDR exposure to reduce environment fireflies HDRI panoramas designed for realistic lighting can have extremely bright suns, causing fireflies to appear in the environment reflection (in addition to making environment lighting too bright when a DirectionalLight3D is used). This uses the Filament tonemapping formula.
2022-02-16 01:43:44 +01:00
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "process/hdr_clamp_exposure"), false));
Several fixes to 3D rendering, and multimesh implementation.
2019-09-14 05:37:42 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "process/size_limit", PROPERTY_HINT_RANGE, "0,4096,1"), 0));
Fixes to Basis Universal.
2019-09-27 14:05:22 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "detect_3d/compress_to", PROPERTY_HINT_ENUM, "Disabled,VRAM Compressed,Basis Universal"), (p_preset == PRESET_DETECT) ? 1 : 0));
Hide SVG scale for non-SVG textures
2022-01-16 21:18:00 +01:00
Show svg import options in default settings. Fixes: #63840 Importers can export options conditional based on the resource path. If an empty path is passed (as by the editor settings) filtering should not be done.
2022-10-08 16:01:00 +02:00
// Do path based customization only if a path was passed.
if (p_path.is_empty() || p_path.get_extension() == "svg") {
Hide SVG scale for non-SVG textures
2022-01-16 21:18:00 +01:00
r_options->push_back(ImportOption(PropertyInfo(Variant::FLOAT, "svg/scale", PROPERTY_HINT_RANGE, "0.001,100,0.001"), 1.0));
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Editor use only, applies to SVG.
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "editor/scale_with_editor_scale"), false));
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "editor/convert_colors_with_editor_theme"), false));
Hide SVG scale for non-SVG textures
2022-01-16 21:18:00 +01:00
}
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
Make FileAccess and DirAccess classes reference counted.
2022-03-23 10:08:58 +01:00
void ResourceImporterTexture::save_to_ctex_format(Ref<FileAccess> f, const Ref<Image> &p_image, CompressMode p_compress_mode, Image::UsedChannels p_channels, Image::CompressMode p_compress_format, float p_lossy_quality) {
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
switch (p_compress_mode) {
case COMPRESS_LOSSLESS: {
Unify usage of GLOBAL/EDITOR_GET
2022-10-18 16:43:37 +02:00
bool lossless_force_png = GLOBAL_GET("rendering/textures/lossless_compression/force_png") ||
Fix crash in ResourceImporterTexture::_save_stex if webp disabled Fixes #51535.
2021-08-13 22:17:55 +02:00
!Image::_webp_mem_loader_func; // WebP module disabled.
Implement lossless WebP encoding
2021-04-12 18:56:50 +02:00
bool use_webp = !lossless_force_png && p_image->get_width() <= 16383 && p_image->get_height() <= 16383; // WebP has a size limit
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
f->store_32(use_webp ? CompressedTexture2D::DATA_FORMAT_WEBP : CompressedTexture2D::DATA_FORMAT_PNG);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
f->store_16(p_image->get_width());
f->store_16(p_image->get_height());
f->store_32(p_image->get_mipmap_count());
f->store_32(p_image->get_format());
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
for (int i = 0; i < p_image->get_mipmap_count() + 1; i++) {
Implement lossless WebP encoding
2021-04-12 18:56:50 +02:00
Vector<uint8_t> data;
if (use_webp) {
data = Image::webp_lossless_packer(p_image->get_image_from_mipmap(i));
} else {
data = Image::png_packer(p_image->get_image_from_mipmap(i));
}
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
int data_len = data.size();
f->store_32(data_len);
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
const uint8_t *r = data.ptr();
f->store_buffer(r, data_len);
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
} break;
case COMPRESS_LOSSY: {
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
f->store_32(CompressedTexture2D::DATA_FORMAT_WEBP);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
f->store_16(p_image->get_width());
f->store_16(p_image->get_height());
f->store_32(p_image->get_mipmap_count());
f->store_32(p_image->get_format());
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
for (int i = 0; i < p_image->get_mipmap_count() + 1; i++) {
Implement lossless WebP encoding
2021-04-12 18:56:50 +02:00
Vector<uint8_t> data = Image::webp_lossy_packer(p_image->get_image_from_mipmap(i), p_lossy_quality);
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
int data_len = data.size();
f->store_32(data_len);
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
const uint8_t *r = data.ptr();
f->store_buffer(r, data_len);
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
} break;
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
case COMPRESS_VRAM_COMPRESSED: {
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02:00
Ref<Image> image = p_image->duplicate();
-Added EXR supprot for HDR (no BC6 compression yet though) -Improvements to texture importer -Proper detection of S3TC compression modes, and added all modes to Image -Fixes to non-power of 2 compressed textures, which should all be supported by GLES3
2017-05-27 02:49:49 +02:00
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
image->compress_from_channels(p_compress_format, p_channels);
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
f->store_32(CompressedTexture2D::DATA_FORMAT_IMAGE);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
f->store_16(image->get_width());
f->store_16(image->get_height());
f->store_32(image->get_mipmap_count());
f->store_32(image->get_format());
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
Vector<uint8_t> data = image->get_data();
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
int dl = data.size();
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
const uint8_t *r = data.ptr();
f->store_buffer(r, dl);
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
} break;
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
case COMPRESS_VRAM_UNCOMPRESSED: {
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
f->store_32(CompressedTexture2D::DATA_FORMAT_IMAGE);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
f->store_16(p_image->get_width());
f->store_16(p_image->get_height());
f->store_32(p_image->get_mipmap_count());
f->store_32(p_image->get_format());
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
Vector<uint8_t> data = p_image->get_data();
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
int dl = data.size();
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
const uint8_t *r = data.ptr();
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 22:06:54 +01:00
f->store_buffer(r, dl);
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
} break;
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
case COMPRESS_BASIS_UNIVERSAL: {
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
f->store_32(CompressedTexture2D::DATA_FORMAT_BASIS_UNIVERSAL);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
f->store_16(p_image->get_width());
f->store_16(p_image->get_height());
f->store_32(p_image->get_mipmap_count());
f->store_32(p_image->get_format());
Handle gltf binary [ Ignore and Warn | Extract Textures (default) | Optimize Loading Embedded as Basisu ] Enable compressed mip maps from Basis Universal for faster compressions. Increase the quality of Basis to avoid corruption. To keep compatibility use the first mip of the previous internal Godot format. Because texture names may have invalid filename characters, adds String::validate_filename to sanitize filenames for import pipeline use.
2022-07-19 02:58:27 +02:00
Vector<uint8_t> data = Image::basis_universal_packer(p_image, p_channels);
int data_len = data.size();
f->store_32(data_len);
const uint8_t *r = data.ptr();
f->store_buffer(r, data_len);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
} break;
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
}
Remove more occurrences of "stex"
2022-03-10 04:22:36 +01:00
void ResourceImporterTexture::_save_ctex(const Ref<Image> &p_image, const String &p_to_path, CompressMode p_compress_mode, float p_lossy_quality, Image::CompressMode p_vram_compression, bool p_mipmaps, bool p_streamable, bool p_detect_3d, bool p_detect_roughness, bool p_detect_normal, bool p_force_normal, bool p_srgb_friendly, bool p_force_po2_for_compressed, uint32_t p_limit_mipmap, const Ref<Image> &p_normal, Image::RoughnessChannel p_roughness_channel) {
Make FileAccess and DirAccess classes reference counted.
2022-03-23 10:08:58 +01:00
Ref<FileAccess> f = FileAccess::open(p_to_path, FileAccess::WRITE);
ERR_FAIL_COND(f.is_null());
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
f->store_8('G');
f->store_8('S');
f->store_8('T');
f->store_8('2'); //godot streamable texture 2D
//format version
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
f->store_32(CompressedTexture2D::FORMAT_VERSION);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
//texture may be resized later, so original size must be saved first
f->store_32(p_image->get_width());
f->store_32(p_image->get_height());
uint32_t flags = 0;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (p_streamable) {
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
flags |= CompressedTexture2D::FORMAT_BIT_STREAM;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
if (p_mipmaps) {
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
flags |= CompressedTexture2D::FORMAT_BIT_HAS_MIPMAPS; //mipmaps bit
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
if (p_detect_3d) {
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
flags |= CompressedTexture2D::FORMAT_BIT_DETECT_3D;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
if (p_detect_roughness) {
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
flags |= CompressedTexture2D::FORMAT_BIT_DETECT_ROUGNESS;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
if (p_detect_normal) {
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
flags |= CompressedTexture2D::FORMAT_BIT_DETECT_NORMAL;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
f->store_32(flags);
f->store_32(p_limit_mipmap);
Fix various typos Found via `codespell`
2020-03-11 18:59:18 +01:00
//reserved for future use
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
f->store_32(0);
f->store_32(0);
f->store_32(0);
/*
print_line("streamable " + itos(p_streamable));
print_line("mipmaps " + itos(p_mipmaps));
print_line("detect_3d " + itos(p_detect_3d));
print_line("roughness " + itos(p_detect_roughness));
print_line("normal " + itos(p_detect_normal));
*/
if ((p_compress_mode == COMPRESS_LOSSLESS || p_compress_mode == COMPRESS_LOSSY) && p_image->get_format() > Image::FORMAT_RGBA8) {
p_compress_mode = COMPRESS_VRAM_UNCOMPRESSED; //these can't go as lossy
}
Ref<Image> image = p_image->duplicate();
Handle gltf binary [ Ignore and Warn | Extract Textures (default) | Optimize Loading Embedded as Basisu ] Enable compressed mip maps from Basis Universal for faster compressions. Increase the quality of Basis to avoid corruption. To keep compatibility use the first mip of the previous internal Godot format. Because texture names may have invalid filename characters, adds String::validate_filename to sanitize filenames for import pipeline use.
2022-07-19 02:58:27 +02:00
if (p_force_po2_for_compressed && p_mipmaps && ((p_compress_mode == COMPRESS_BASIS_UNIVERSAL) || (p_compress_mode == COMPRESS_VRAM_COMPRESSED))) {
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
image->resize_to_po2();
}
if (p_mipmaps && (!image->has_mipmaps() || p_force_normal)) {
image->generate_mipmaps(p_force_normal);
}
if (!p_mipmaps) {
image->clear_mipmaps();
}
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 00:09:40 +01:00
if (image->has_mipmaps() && p_normal.is_valid()) {
image->generate_mipmap_roughness(p_roughness_channel, p_normal);
}
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
Image::CompressSource csource = Image::COMPRESS_SOURCE_GENERIC;
if (p_force_normal) {
csource = Image::COMPRESS_SOURCE_NORMAL;
} else if (p_srgb_friendly) {
csource = Image::COMPRESS_SOURCE_SRGB;
}
Image::UsedChannels used_channels = image->detect_used_channels(csource);
Remove more occurrences of "stex"
2022-03-10 04:22:36 +01:00
save_to_ctex_format(f, image, p_compress_mode, used_channels, p_vram_compression, p_lossy_quality);
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
Error ResourceImporterTexture::import(const String &p_source_file, const String &p_save_path, const HashMap<StringName, Variant> &p_options, List<String> *r_platform_variants, List<String> *r_gen_files, Variant *r_metadata) {
Make `ImageLoader` take bit field flags
2022-08-23 12:25:14 +02:00
// Parse import options.
int32_t loader_flags = ImageFormatLoader::FLAG_NONE;
// Compression.
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
CompressMode compress_mode = CompressMode(int(p_options["compress/mode"]));
Rename Hdr as Srgb texture import option to be lowercase Unlike all other import options, Hdr As Srgb was internally spelled out with uppercase characters.
2022-02-12 02:39:10 +01:00
const float lossy = p_options["compress/lossy_quality"];
const int pack_channels = p_options["compress/channel_pack"];
Make `ImageLoader` take bit field flags
2022-08-23 12:25:14 +02:00
const int normal = p_options["compress/normal_map"];
const int hdr_compression = p_options["compress/hdr_compression"];
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
const int high_quality = p_options["compress/high_quality"];
Make `ImageLoader` take bit field flags
2022-08-23 12:25:14 +02:00
// Mipmaps.
Rename Hdr as Srgb texture import option to be lowercase Unlike all other import options, Hdr As Srgb was internally spelled out with uppercase characters.
2022-02-12 02:39:10 +01:00
const bool mipmaps = p_options["mipmaps/generate"];
const uint32_t mipmap_limit = mipmaps ? uint32_t(p_options["mipmaps/limit"]) : uint32_t(-1);
Make `ImageLoader` take bit field flags
2022-08-23 12:25:14 +02:00
// Roughness.
const int roughness = p_options["roughness/mode"];
const String normal_map = p_options["roughness/src_normal"];
// Processing.
Rename Hdr as Srgb texture import option to be lowercase Unlike all other import options, Hdr As Srgb was internally spelled out with uppercase characters.
2022-02-12 02:39:10 +01:00
const bool fix_alpha_border = p_options["process/fix_alpha_border"];
const bool premult_alpha = p_options["process/premult_alpha"];
const bool normal_map_invert_y = p_options["process/normal_map_invert_y"];
Remove unused Streamed option for textures in the Import dock Godot does not support texture streaming yet (and is only planned for a future 4.x release), so displaying an option can be misleading.
2022-02-12 02:37:14 +01:00
// Support for texture streaming is not implemented yet.
const bool stream = false;
Rename Hdr as Srgb texture import option to be lowercase Unlike all other import options, Hdr As Srgb was internally spelled out with uppercase characters.
2022-02-12 02:39:10 +01:00
const int size_limit = p_options["process/size_limit"];
const bool hdr_as_srgb = p_options["process/hdr_as_srgb"];
Make `ImageLoader` take bit field flags
2022-08-23 12:25:14 +02:00
if (hdr_as_srgb) {
loader_flags |= ImageFormatLoader::FLAG_FORCE_LINEAR;
}
Add an option to clamp HDR exposure to reduce environment fireflies HDRI panoramas designed for realistic lighting can have extremely bright suns, causing fireflies to appear in the environment reflection (in addition to making environment lighting too bright when a DirectionalLight3D is used). This uses the Filament tonemapping formula.
2022-02-16 01:43:44 +01:00
const bool hdr_clamp_exposure = p_options["process/hdr_clamp_exposure"];
Make `ImageLoader` take bit field flags
2022-08-23 12:25:14 +02:00
Hide SVG scale for non-SVG textures
2022-01-16 21:18:00 +01:00
float scale = 1.0;
Make `ImageLoader` take bit field flags
2022-08-23 12:25:14 +02:00
// SVG-specific options.
Hide SVG scale for non-SVG textures
2022-01-16 21:18:00 +01:00
if (p_options.has("svg/scale")) {
scale = p_options["svg/scale"];
}
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 00:09:40 +01:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Editor-specific options.
bool use_editor_scale = p_options.has("editor/scale_with_editor_scale") && p_options["editor/scale_with_editor_scale"];
bool convert_editor_colors = p_options.has("editor/convert_colors_with_editor_theme") && p_options["editor/convert_colors_with_editor_theme"];
// Start importing images.
List<Ref<Image>> images_imported;
// Load the normal image.
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 00:09:40 +01:00
Ref<Image> normal_image;
Fix more -Wmaybe-uninitialized warnings with target=release_debug I have no idea why those don't get triggered in target=debug builds. Fixes #37461.
2020-03-31 13:50:25 +02:00
Image::RoughnessChannel roughness_channel = Image::ROUGHNESS_CHANNEL_R;
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 00:09:40 +01:00
if (mipmaps && roughness > 1 && FileAccess::exists(normal_map)) {
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
normal_image.instantiate();
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 00:09:40 +01:00
if (ImageLoader::load_image(normal_map, normal_image) == OK) {
roughness_channel = Image::RoughnessChannel(roughness - 2);
}
}
Make `ImageLoader` take bit field flags
2022-08-23 12:25:14 +02:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Load the main image.
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02:00
Ref<Image> image;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
image.instantiate();
Make `ImageLoader` take bit field flags
2022-08-23 12:25:14 +02:00
Error err = ImageLoader::load_image(p_source_file, image, nullptr, loader_flags, scale);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (err != OK) {
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
return err;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
images_imported.push_back(image);
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Load the editor-only image.
Ref<Image> editor_image;
bool import_editor_image = use_editor_scale || convert_editor_colors;
if (import_editor_image) {
float editor_scale = scale;
if (use_editor_scale) {
editor_scale = scale * EDSCALE;
}
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
int32_t editor_loader_flags = loader_flags;
if (convert_editor_colors) {
editor_loader_flags |= ImageFormatLoader::FLAG_CONVERT_COLORS;
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
Ensure, if a texture meant for a normal map is imported and size limit exists, that it's renormalized after resize.
2018-07-03 15:55:50 +02:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
editor_image.instantiate();
err = ImageLoader::load_image(p_source_file, editor_image, nullptr, editor_loader_flags, editor_scale);
if (err != OK) {
WARN_PRINT("Failed to import an image resource for editor use from '" + p_source_file + "'");
} else {
images_imported.push_back(editor_image);
Ensure, if a texture meant for a normal map is imported and size limit exists, that it's renormalized after resize.
2018-07-03 15:55:50 +02:00
}
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
for (Ref<Image> &target_image : images_imported) {
// Apply the size limit.
if (size_limit > 0 && (target_image->get_width() > size_limit || target_image->get_height() > size_limit)) {
if (target_image->get_width() >= target_image->get_height()) {
int new_width = size_limit;
int new_height = target_image->get_height() * new_width / target_image->get_width();
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
target_image->resize(new_width, new_height, Image::INTERPOLATE_CUBIC);
} else {
int new_height = size_limit;
int new_width = target_image->get_width() * new_height / target_image->get_height();
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
target_image->resize(new_width, new_height, Image::INTERPOLATE_CUBIC);
}
[Texture Importer] Add option to invert color
2018-08-17 18:28:07 +02:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
if (normal == 1) {
target_image->normalize();
[Texture Importer] Add option to invert color
2018-08-17 18:28:07 +02:00
}
}
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Fix alpha border.
if (fix_alpha_border) {
target_image->fix_alpha_edges();
}
Add an option to clamp HDR exposure to reduce environment fireflies HDRI panoramas designed for realistic lighting can have extremely bright suns, causing fireflies to appear in the environment reflection (in addition to making environment lighting too bright when a DirectionalLight3D is used). This uses the Filament tonemapping formula.
2022-02-16 01:43:44 +01:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Premultiply the alpha.
if (premult_alpha) {
target_image->premultiply_alpha();
}
Add an option to clamp HDR exposure to reduce environment fireflies HDRI panoramas designed for realistic lighting can have extremely bright suns, causing fireflies to appear in the environment reflection (in addition to making environment lighting too bright when a DirectionalLight3D is used). This uses the Filament tonemapping formula.
2022-02-16 01:43:44 +01:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Invert the green channel of the image to flip the normal map it contains.
if (normal_map_invert_y) {
// Inverting the green channel can be used to flip a normal map's direction.
// There's no standard when it comes to normal map Y direction, so this is
// sometimes needed when using a normal map exported from another program.
// See <http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates>.
const int height = target_image->get_height();
const int width = target_image->get_width();
for (int i = 0; i < width; i++) {
for (int j = 0; j < height; j++) {
const Color color = target_image->get_pixel(i, j);
target_image->set_pixel(i, j, Color(color.r, 1 - color.g, color.b));
Add an option to clamp HDR exposure to reduce environment fireflies HDRI panoramas designed for realistic lighting can have extremely bright suns, causing fireflies to appear in the environment reflection (in addition to making environment lighting too bright when a DirectionalLight3D is used). This uses the Filament tonemapping formula.
2022-02-16 01:43:44 +01:00
}
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
}
}
Add an option to clamp HDR exposure to reduce environment fireflies HDRI panoramas designed for realistic lighting can have extremely bright suns, causing fireflies to appear in the environment reflection (in addition to making environment lighting too bright when a DirectionalLight3D is used). This uses the Filament tonemapping formula.
2022-02-16 01:43:44 +01:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Clamp HDR exposure.
if (hdr_clamp_exposure) {
// Clamp HDR exposure following Filament's tonemapping formula.
// This can be used to reduce fireflies in environment maps or reduce the influence
// of the sun from an HDRI panorama on environment lighting (when a DirectionalLight3D is used instead).
const int height = target_image->get_height();
const int width = target_image->get_width();
// These values are chosen arbitrarily and seem to produce good results with 4,096 samples.
const float linear = 4096.0;
const float compressed = 16384.0;
for (int i = 0; i < width; i++) {
for (int j = 0; j < height; j++) {
const Color color = target_image->get_pixel(i, j);
const float luma = color.get_luminance();
Color clamped_color;
if (luma <= linear) {
clamped_color = color;
} else {
clamped_color = (color / luma) * ((linear * linear - compressed * luma) / (2 * linear - compressed - luma));
}
target_image->set_pixel(i, j, clamped_color);
}
Add an option to clamp HDR exposure to reduce environment fireflies HDRI panoramas designed for realistic lighting can have extremely bright suns, causing fireflies to appear in the environment reflection (in addition to making environment lighting too bright when a DirectionalLight3D is used). This uses the Filament tonemapping formula.
2022-02-16 01:43:44 +01:00
}
}
}
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
if (compress_mode == COMPRESS_BASIS_UNIVERSAL && image->get_format() >= Image::FORMAT_RF) {
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Basis universal does not support float formats, fallback.
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
compress_mode = COMPRESS_VRAM_COMPRESSED;
}
bool detect_3d = int(p_options["detect_3d/compress_to"]) > 0;
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
bool detect_roughness = roughness == 0;
-Fix freezes caused by etccomp2, closes #9183 -Normalmaps are now detected and imported as RGTC, both in S3TC and ETC2, this improves their quality.
2017-06-17 02:47:28 +02:00
bool detect_normal = normal == 0;
bool force_normal = normal == 1;
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
bool srgb_friendly_pack = pack_channels == 0;
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
Array formats_imported;
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
if (compress_mode == COMPRESS_VRAM_COMPRESSED) {
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Must import in all formats, in order of priority (so platform choses the best supported one. IE, etc2 over etc).
// Android, GLES 2.x
Added a warning for when a PC compression is not found for the project, closes #10626
2017-09-06 01:17:26 +02:00
Faster CVTT by reducing quality. Make BC6 and BC7 CVTT faster while still having better quality than DXT5.
2022-01-18 13:39:55 +01:00
const bool is_hdr = (image->get_format() >= Image::FORMAT_RF && image->get_format() <= Image::FORMAT_RGBE9995);
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
const bool can_s3tc_bptc = GLOBAL_GET("rendering/textures/vram_compression/import_s3tc_bptc") || OS::get_singleton()->get_preferred_texture_format() == OS::PREFERRED_TEXTURE_FORMAT_S3TC_BPTC;
const bool can_etc2_astc = GLOBAL_GET("rendering/textures/vram_compression/import_etc2_astc") || OS::get_singleton()->get_preferred_texture_format() == OS::PREFERRED_TEXTURE_FORMAT_ETC2_ASTC;
Added a warning for when a PC compression is not found for the project, closes #10626
2017-09-06 01:17:26 +02:00
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
// Add list of formats imported
if (can_s3tc_bptc) {
formats_imported.push_back("s3tc_bptc");
}
if (can_etc2_astc) {
formats_imported.push_back("etc2_astc");
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
}
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 05:05:04 +02:00
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
bool can_compress_hdr = hdr_compression > 0;
bool has_alpha = image->detect_alpha() != Image::ALPHA_NONE;
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
bool use_uncompressed = false;
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
if (is_hdr) {
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
if (has_alpha) {
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Can compress HDR, but HDR with alpha is not compressible.
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
if (hdr_compression == 2) {
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// But user selected to compress HDR anyway, so force an alpha-less format.
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
if (image->get_format() == Image::FORMAT_RGBAF) {
image->convert(Image::FORMAT_RGBF);
} else if (image->get_format() == Image::FORMAT_RGBAH) {
image->convert(Image::FORMAT_RGBH);
}
} else {
can_compress_hdr = false;
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 05:05:04 +02:00
}
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
}
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 05:05:04 +02:00
Faster CVTT by reducing quality. Make BC6 and BC7 CVTT faster while still having better quality than DXT5.
2022-01-18 13:39:55 +01:00
if (!can_compress_hdr) {
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Fallback to RGBE99995.
Faster CVTT by reducing quality. Make BC6 and BC7 CVTT faster while still having better quality than DXT5.
2022-01-18 13:39:55 +01:00
if (image->get_format() != Image::FORMAT_RGBE9995) {
image->convert(Image::FORMAT_RGBE9995);
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
use_uncompressed = true;
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 05:05:04 +02:00
}
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
}
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 05:05:04 +02:00
}
BPTC support
2018-08-22 04:56:04 +02:00
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
if (use_uncompressed) {
_save_ctex(image, p_save_path + ".ctex", COMPRESS_VRAM_UNCOMPRESSED, lossy, Image::COMPRESS_S3TC /*this is ignored */, mipmaps, stream, detect_3d, detect_roughness, detect_normal, force_normal, srgb_friendly_pack, false, mipmap_limit, normal_image, roughness_channel);
} else {
if (can_s3tc_bptc) {
Image::CompressMode image_compress_mode;
String image_compress_format;
if (high_quality || is_hdr) {
image_compress_mode = Image::COMPRESS_BPTC;
image_compress_format = "bptc";
} else {
image_compress_mode = Image::COMPRESS_S3TC;
image_compress_format = "s3tc";
}
_save_ctex(image, p_save_path + "." + image_compress_format + ".ctex", compress_mode, lossy, image_compress_mode, mipmaps, stream, detect_3d, detect_roughness, detect_normal, force_normal, srgb_friendly_pack, false, mipmap_limit, normal_image, roughness_channel);
r_platform_variants->push_back(image_compress_format);
Faster CVTT by reducing quality. Make BC6 and BC7 CVTT faster while still having better quality than DXT5.
2022-01-18 13:39:55 +01:00
}
-Fix freezes caused by etccomp2, closes #9183 -Normalmaps are now detected and imported as RGTC, both in S3TC and ETC2, this improves their quality.
2017-06-17 02:47:28 +02:00
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
if (can_etc2_astc) {
Image::CompressMode image_compress_mode;
String image_compress_format;
if (high_quality || is_hdr) {
image_compress_mode = Image::COMPRESS_ASTC;
image_compress_format = "astc";
} else {
image_compress_mode = Image::COMPRESS_ETC2;
image_compress_format = "etc2";
}
_save_ctex(image, p_save_path + "." + image_compress_format + ".ctex", compress_mode, lossy, image_compress_mode, mipmaps, stream, detect_3d, detect_roughness, detect_normal, force_normal, srgb_friendly_pack, false, mipmap_limit, normal_image, roughness_channel);
r_platform_variants->push_back(image_compress_format);
}
Added a warning for when a PC compression is not found for the project, closes #10626
2017-09-06 01:17:26 +02:00
}
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
} else {
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
// Import normally.
Remove more occurrences of "stex"
2022-03-10 04:22:36 +01:00
_save_ctex(image, p_save_path + ".ctex", compress_mode, lossy, Image::COMPRESS_S3TC /*this is ignored */, mipmaps, stream, detect_3d, detect_roughness, detect_normal, force_normal, srgb_friendly_pack, false, mipmap_limit, normal_image, roughness_channel);
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
if (editor_image.is_valid()) {
_save_ctex(editor_image, p_save_path + ".editor.ctex", compress_mode, lossy, Image::COMPRESS_S3TC /*this is ignored */, mipmaps, stream, detect_3d, detect_roughness, detect_normal, force_normal, srgb_friendly_pack, false, mipmap_limit, normal_image, roughness_channel);
}
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
if (r_metadata) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
Dictionary meta;
meta["vram_texture"] = compress_mode == COMPRESS_VRAM_COMPRESSED;
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
if (formats_imported.size()) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
meta["imported_formats"] = formats_imported;
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
}
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
if (editor_image.is_valid()) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
meta["has_editor_variant"] = true;
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
if (use_editor_scale) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
meta["editor_scale"] = EDSCALE;
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
}
if (convert_editor_colors) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
meta["editor_dark_theme"] = EditorSettings::get_singleton()->is_dark_theme();
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
}
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
*r_metadata = meta;
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
}
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
return OK;
}
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
const char *ResourceImporterTexture::compression_formats[] = {
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
"s3tc_bptc",
"etc2_astc",
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
nullptr
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
};
String ResourceImporterTexture::get_import_settings_string() const {
String s;
int index = 0;
while (compression_formats[index]) {
Reorganize Project Settings -Advanced Settings toggle also hides advanced properties when disabled -Simplified Advanced Bar (errors were just plain redundant) -Reorganized rendering quality settings. -Reorganized miscelaneous settings for clean up.
2021-02-17 17:44:49 +01:00
String setting_path = "rendering/textures/vram_compression/import_" + String(compression_formats[index]);
Unify usage of GLOBAL/EDITOR_GET
2022-10-18 16:43:37 +02:00
bool test = GLOBAL_GET(setting_path);
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
if (test) {
s += String(compression_formats[index]);
}
index++;
}
return s;
}
bool ResourceImporterTexture::are_import_settings_valid(const String &p_path) const {
//will become invalid if formats are missing to import
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
Dictionary meta = ResourceFormatImporter::get_singleton()->get_resource_metadata(p_path);
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
if (meta.has("has_editor_variant")) {
if (meta.has("editor_scale") && (float)meta["editor_scale"] != EDSCALE) {
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
return false;
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
if (meta.has("editor_dark_theme") && (bool)meta["editor_dark_theme"] != EditorSettings::get_singleton()->is_dark_theme()) {
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
return false;
}
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
if (!meta.has("vram_texture")) {
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
return false;
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
bool vram = meta["vram_texture"];
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
if (!vram) {
Allow images to be imported "for editor use" and respect editor settings
2022-08-22 21:07:02 +02:00
return true; // Do not care about non-VRAM.
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
}
Vector<String> formats_imported;
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
if (meta.has("imported_formats")) {
formats_imported = meta["imported_formats"];
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
}
int index = 0;
bool valid = true;
while (compression_formats[index]) {
Reorganize Project Settings -Advanced Settings toggle also hides advanced properties when disabled -Simplified Advanced Bar (errors were just plain redundant) -Reorganized rendering quality settings. -Reorganized miscelaneous settings for clean up.
2021-02-17 17:44:49 +01:00
String setting_path = "rendering/textures/vram_compression/import_" + String(compression_formats[index]);
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
if (ProjectSettings::get_singleton()->has_setting(setting_path)) {
bool test = GLOBAL_GET(setting_path);
if (test) {
if (!formats_imported.has(compression_formats[index])) {
valid = false;
break;
}
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
}
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
} else {
WARN_PRINT("Setting for imported format not found: " + setting_path);
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
}
index++;
}
return valid;
}
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ResourceImporterTexture *ResourceImporterTexture::singleton = nullptr;
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
ResourceImporterTexture::ResourceImporterTexture() {
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
singleton = this;
Rename StreamTexture* to CompressedTexture* * Its not and will not be used for streaming. * Streaming will be implemented in 4.1 and it will work different. * It makes more sense to be called CompressedTexture since it imports and compresses texture files.
2022-03-05 16:43:38 +01:00
CompressedTexture2D::request_3d_callback = _texture_reimport_3d;
CompressedTexture2D::request_roughness_callback = _texture_reimport_roughness;
CompressedTexture2D::request_normal_callback = _texture_reimport_normal;
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
ResourceImporterTexture::~ResourceImporterTexture() {
}
Reference in a new issue Copy permalink