godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/editor/import/resource_importer_texture.cpp

687 lines
26 KiB
C++
Raw Normal View History

Add a bunch of missing Godot headers in own files
2017-03-05 14:47:28 +00:00
/*************************************************************************/
/* resource_importer_texture.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 12:16:55 +00:00
/* https://godotengine.org */
Add a bunch of missing Godot headers in own files
2017-03-05 14:47:28 +00:00
/*************************************************************************/
Update copyright statements to 2022 Happy new year to the wonderful Godot community!
2022-01-03 20:27:34 +00:00
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
Add a bunch of missing Godot headers in own files
2017-03-05 14:47:28 +00:00
/* */
/* 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-04 23:50:27 +00:00
OBJ file importing!
2017-02-03 03:08:50 +00:00
#include "resource_importer_texture.h"
Add a bunch of missing Godot headers in own files
2017-03-05 14:47:28 +00:00
Improve compilation speed (forward declarations/includes cleanup)
2022-02-12 01:46:22 +00: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 16:13:45 +00: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 02:16:44 +00: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 13:21:25 +00:00
#include "editor/editor_file_system.h"
Style: Apply clang-format to @reduz's changes [ci skip]
2017-09-13 07:13:23 +00:00
#include "editor/editor_node.h"
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 15:43:38 +00: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 15:56:41 +00: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 10:28:13 +00:00
MutexLock lock(singleton->mutex);
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00: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 18:43:37 +00:00
singleton->make_flags[path] = MakeInfo();
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00: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 18:43:37 +00: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 03:38:39 +00: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 15:43:38 +00:00
void ResourceImporterTexture::_texture_reimport_3d(const Ref<CompressedTexture2D> &p_tex) {
Don't crash when texture param is null
2021-12-17 15:56:41 +00: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 10:28:13 +00:00
MutexLock lock(singleton->mutex);
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00: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 18:43:37 +00:00
singleton->make_flags[path] = MakeInfo();
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00: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 18:43:37 +00:00
singleton->make_flags[path].flags |= MAKE_3D_FLAG;
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00: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 15:43:38 +00:00
void ResourceImporterTexture::_texture_reimport_normal(const Ref<CompressedTexture2D> &p_tex) {
Don't crash when texture param is null
2021-12-17 15:56:41 +00: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 10:28:13 +00: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 00:47:28 +00: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 18:43:37 +00: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 00:47:28 +00: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 18:43:37 +00: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 00:47:28 +00:00
}
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00: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 10:34:40 +00:00
return; // do nothing for now
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00: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 10:28:13 +00:00
MutexLock lock(mutex);
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00: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 10:28:13 +00:00
{
Rename empty() to is_empty()
2020-12-15 12:04:21 +00: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 10:28:13 +00:00
return;
}
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00:00
Use range iterators for `Map`
2021-08-09 20:13:42 +00: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 10:28:13 +00:00
Ref<ConfigFile> cf;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
cf.instantiate();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
String src_path = String(E.key) + ".import";
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00: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 10:28:13 +00: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 18:43:37 +00: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 10:28:13 +00:00
bool changed = false;
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00:00
Revert "Disable VRAM compression by default for small textures in Detect 3D"
2022-06-20 13:30:19 +00: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 18:16:14 +00: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 10:28:13 +00: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 00:47:28 +00:00
Use range iterators for `Map`
2021-08-09 20:13:42 +00: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 18:16:14 +00: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 20:13:42 +00: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 10:28:13 +00:00
changed = true;
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
}
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00:00
Revert "Disable VRAM compression by default for small textures in Detect 3D"
2022-06-20 13:30:19 +00: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 10:28:13 +00:00
if (changed) {
cf->save(src_path);
Use range iterators for `Map`
2021-08-09 20:13:42 +00: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 10:28:13 +00:00
}
}
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00: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 10:28:13 +00:00
make_flags.clear();
}
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00: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 12:45:45 +00:00
String ResourceImporterTexture::get_importer_name() const {
return "texture";
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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 18:43:37 +00:00
return "Texture2D";
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 12:29:06 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void ResourceImporterTexture::get_recognized_extensions(List<String> *p_extensions) const {
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
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 12:29:06 +00:00
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 15:43:38 +00:00
return "ctex";
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00: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 15:43:38 +00:00
return "CompressedTexture2D";
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 13:04:37 +00:00
bool ResourceImporterTexture::get_option_visibility(const String &p_path, const String &p_option, const HashMap<StringName, Variant> &p_options) const {
Add ETC1/ETC2 compression support though etc2comp. Remove rg-etc1 code. Also updated travis to use ubuntu 14.04. Fixes #8457.
2017-04-26 15:49:08 +00:00
if (p_option == "compress/lossy_quality") {
int compress_mode = int(p_options["compress/mode"]);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
if (compress_mode != COMPRESS_LOSSY && compress_mode != COMPRESS_VRAM_COMPRESSED) {
Add ETC1/ETC2 compression support though etc2comp. Remove rg-etc1 code. Also updated travis to use ubuntu 14.04. Fixes #8457.
2017-04-26 15:49:08 +00:00
return false;
}
Removed fallback system and merged bptc into s3tc
2018-08-27 16:47:13 +00: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-22 22:31:12 +00:00
int compress_mode = int(p_options["compress/mode"]);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
if (compress_mode < COMPRESS_VRAM_COMPRESSED) {
Hide "no BPTC if RGB" and "HDR Mode" options when not using "Video RAM" import.
2018-08-22 22:31:12 +00: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-26 23:21:07 +00: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 02:16:44 +00:00
} else if (p_option == "mipmaps/limit") {
return p_options["mipmaps/generate"];
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 03:05:04 +00:00
} else if (p_option == "compress/bptc_ldr") {
int compress_mode = int(p_options["compress/mode"]);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
if (compress_mode < COMPRESS_VRAM_COMPRESSED) {
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 03:05:04 +00:00
return false;
}
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 16:44:49 +00:00
if (!ProjectSettings::get_singleton()->get("rendering/textures/vram_compression/import_bptc")) {
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 03:05:04 +00:00
return false;
}
Add ETC1/ETC2 compression support though etc2comp. Remove rg-etc1 code. Also updated travis to use ubuntu 14.04. Fixes #8457.
2017-04-26 15:49:08 +00:00
}
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 13:08:09 +00:00
return 3;
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 12:29:06 +00:00
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
String ResourceImporterTexture::get_preset_name(int p_idx) const {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
static const char *preset_names[] = {
Make more import preset name translatable
2022-04-27 05:50:54 +00:00
TTRC("2D/3D (Auto-Detect)"),
TTRC("2D"),
TTRC("3D"),
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
};
Make more import preset name translatable
2022-04-27 05:50:54 +00:00
return TTRGET(preset_names[p_idx]);
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 17:02:38 +00: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 02:16:44 +00: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));
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 18:20:53 +00: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 12:34:23 +00:00
r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "compress/hdr_compression", PROPERTY_HINT_ENUM, "Disabled,Opaque Only,Always"), 1));
r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "compress/bptc_ldr", PROPERTY_HINT_ENUM, "Disabled,Enabled,RGBA Only"), 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 00:47:28 +00: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 18:43:37 +00: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 02:16:44 +00:00
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "mipmaps/generate"), (p_preset == PRESET_3D ? true : false)));
Fixes to Basis Universal.
2019-09-27 12:05:22 +00: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 18:43:37 +00: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 11:39:57 +00: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 13:08:25 +00: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 11:01:15 +00: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 17:27:29 +00: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 01:39:10 +00: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 00:43:44 +00: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 03:37:42 +00: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 12:05:22 +00: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 20:18:00 +00:00
if (p_path.get_extension() == "svg") {
r_options->push_back(ImportOption(PropertyInfo(Variant::FLOAT, "svg/scale", PROPERTY_HINT_RANGE, "0.001,100,0.001"), 1.0));
}
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
}
Make FileAccess and DirAccess classes reference counted.
2022-03-23 09:08:58 +00: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 12:45:45 +00:00
switch (p_compress_mode) {
case COMPRESS_LOSSLESS: {
Fix crash in ResourceImporterTexture::_save_stex if webp disabled Fixes #51535.
2021-08-13 20:17:55 +00:00
bool lossless_force_png = ProjectSettings::get_singleton()->get("rendering/textures/lossless_compression/force_png") ||
!Image::_webp_mem_loader_func; // WebP module disabled.
Implement lossless WebP encoding
2021-04-12 16:56:50 +00: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 15:43:38 +00: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 02:16:44 +00: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 12:45:45 +00:00
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
for (int i = 0; i < p_image->get_mipmap_count() + 1; i++) {
Implement lossless WebP encoding
2021-04-12 16:56:50 +00: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 12:45:45 +00: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 21:06:54 +00: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 12:45:45 +00: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 15:43:38 +00:00
f->store_32(CompressedTexture2D::DATA_FORMAT_WEBP);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00: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 12:45:45 +00:00
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
for (int i = 0; i < p_image->get_mipmap_count() + 1; i++) {
Implement lossless WebP encoding
2021-04-12 16:56:50 +00: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 12:45:45 +00: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 21:06:54 +00: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 12:45:45 +00:00
}
} break;
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
case COMPRESS_VRAM_COMPRESSED: {
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00: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 00:49:49 +00: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 12:34:23 +00:00
image->compress_from_channels(p_compress_format, p_channels, p_lossy_quality);
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 15:43:38 +00:00
f->store_32(CompressedTexture2D::DATA_FORMAT_IMAGE);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00: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 12:45:45 +00:00
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 21:06:54 +00:00
Vector<uint8_t> data = image->get_data();
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 21:06:54 +00: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 12:45:45 +00:00
} break;
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00: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 15:43:38 +00:00
f->store_32(CompressedTexture2D::DATA_FORMAT_IMAGE);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00: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 12:45:45 +00:00
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 21:06:54 +00:00
Vector<uint8_t> data = p_image->get_data();
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 21:06:54 +00:00
const uint8_t *r = data.ptr();
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 21:06:54 +00:00
f->store_buffer(r, dl);
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
} break;
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00: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 15:43:38 +00:00
f->store_32(CompressedTexture2D::DATA_FORMAT_BASIS_UNIVERSAL);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00: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());
for (int i = 0; i < p_image->get_mipmap_count() + 1; i++) {
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 21:06:54 +00:00
Vector<uint8_t> data = Image::basis_universal_packer(p_image->get_image_from_mipmap(i), p_channels);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00: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 21:06:54 +00:00
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 02:16:44 +00:00
}
} break;
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
}
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
}
Remove more occurrences of "stex"
2022-03-10 03:22:36 +00: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 09:08:58 +00: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 02:16:44 +00: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 15:43:38 +00:00
f->store_32(CompressedTexture2D::FORMAT_VERSION);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00: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 14:41:43 +00: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 15:43:38 +00: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 14:41:43 +00: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 15:43:38 +00: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 14:41:43 +00: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 15:43:38 +00: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 14:41:43 +00: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 15:43:38 +00: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 14:41:43 +00: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 15:43:38 +00: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 14:41:43 +00:00
}
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
f->store_32(flags);
f->store_32(p_limit_mipmap);
Fix various typos Found via `codespell`
2020-03-11 17:59:18 +00:00
//reserved for future use
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00: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();
if (((p_compress_mode == COMPRESS_BASIS_UNIVERSAL) || (p_compress_mode == COMPRESS_VRAM_COMPRESSED && p_force_po2_for_compressed)) && p_mipmaps) {
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-26 23:09:40 +00: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 02:16:44 +00: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 03:22:36 +00: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 12:45:45 +00: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 13:04:37 +00: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) {
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00: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 01:39:10 +00:00
const float lossy = p_options["compress/lossy_quality"];
const int pack_channels = p_options["compress/channel_pack"];
const bool mipmaps = p_options["mipmaps/generate"];
const uint32_t mipmap_limit = mipmaps ? uint32_t(p_options["mipmaps/limit"]) : uint32_t(-1);
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 01:37:14 +00: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 01:39:10 +00:00
const int size_limit = p_options["process/size_limit"];
const bool hdr_as_srgb = p_options["process/hdr_as_srgb"];
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 00:43:44 +00:00
const bool hdr_clamp_exposure = p_options["process/hdr_clamp_exposure"];
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 01:39:10 +00:00
const int normal = p_options["compress/normal_map"];
const int hdr_compression = p_options["compress/hdr_compression"];
const int bptc_ldr = p_options["compress/bptc_ldr"];
const int roughness = p_options["roughness/mode"];
const String normal_map = p_options["roughness/src_normal"];
Hide SVG scale for non-SVG textures
2022-01-16 20:18:00 +00:00
float scale = 1.0;
if (p_options.has("svg/scale")) {
scale = p_options["svg/scale"];
}
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-26 23:09:40 +00: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 11:50:25 +00:00
Image::RoughnessChannel roughness_channel = Image::ROUGHNESS_CHANNEL_R;
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-26 23:09:40 +00:00
if (mipmaps && roughness > 1 && FileAccess::exists(normal_map)) {
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
normal_image.instantiate();
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-26 23:09:40 +00:00
if (ImageLoader::load_image(normal_map, normal_image) == OK) {
roughness_channel = Image::RoughnessChannel(roughness - 2);
}
}
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
Ref<Image> image;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
image.instantiate();
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
Error err = ImageLoader::load_image(p_source_file, image, nullptr, hdr_as_srgb, 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 14:41:43 +00:00
if (err != OK) {
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 14:41:43 +00:00
}
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
-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 21:43:37 +00:00
Array formats_imported;
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
if (size_limit > 0 && (image->get_width() > size_limit || image->get_height() > size_limit)) {
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
//limit size
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
if (image->get_width() >= image->get_height()) {
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
int new_width = size_limit;
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
int new_height = image->get_height() * new_width / image->get_width();
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
image->resize(new_width, new_height, Image::INTERPOLATE_CUBIC);
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
} else {
int new_height = size_limit;
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
int new_width = image->get_width() * new_height / image->get_height();
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
image->resize(new_width, new_height, Image::INTERPOLATE_CUBIC);
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 13:55:50 +00:00
Do not normalize normal map when disabled, fixes #20761
2018-11-25 20:05:35 +00:00
if (normal == 1) {
Ensure, if a texture meant for a normal map is imported and size limit exists, that it's renormalized after resize.
2018-07-03 13:55:50 +00:00
image->normalize();
}
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
}
if (fix_alpha_border) {
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
image->fix_alpha_edges();
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
}
if (premult_alpha) {
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
image->premultiply_alpha();
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
}
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 17:27:29 +00:00
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 = image->get_height();
const int width = image->get_width();
[Texture Importer] Add option to invert color
2018-08-17 16:28:07 +00:00
[Texture Import] Fix invert color
2018-09-02 13:13:19 +00:00
for (int i = 0; i < width; i++) {
for (int j = 0; j < height; j++) {
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 17:27:29 +00:00
const Color color = image->get_pixel(i, j);
image->set_pixel(i, j, Color(color.r, 1 - color.g, color.b));
[Texture Importer] Add option to invert color
2018-08-17 16:28:07 +00: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 00:43:44 +00:00
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 = image->get_height();
const int width = 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 = 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));
}
image->set_pixel(i, j, clamped_color);
}
}
}
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
if (compress_mode == COMPRESS_BASIS_UNIVERSAL && image->get_format() >= Image::FORMAT_RF) {
//basis universal does not support float formats, fall back
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 18:43:37 +00: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 00:47:28 +00: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 18:43:37 +00:00
bool srgb_friendly_pack = pack_channels == 0;
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
if (compress_mode == COMPRESS_VRAM_COMPRESSED) {
-Renamed GlobalConfig to ProjectSettings, makes more sense. -Added system for feature overrides, it's pretty cool :)
2017-07-19 20:00:46 +00:00
//must import in all formats, in order of priority (so platform choses the best supported one. IE, etc2 over etc).
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
//Android, GLES 2.x
Added a warning for when a PC compression is not found for the project, closes #10626
2017-09-05 23:17:26 +00:00
Faster CVTT by reducing quality. Make BC6 and BC7 CVTT faster while still having better quality than DXT5.
2022-01-18 12:39:55 +00:00
const bool is_hdr = (image->get_format() >= Image::FORMAT_RF && image->get_format() <= Image::FORMAT_RGBE9995);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
bool is_ldr = (image->get_format() >= Image::FORMAT_L8 && image->get_format() <= Image::FORMAT_RGB565);
Faster CVTT by reducing quality. Make BC6 and BC7 CVTT faster while still having better quality than DXT5.
2022-01-18 12:39:55 +00:00
const bool can_bptc = ProjectSettings::get_singleton()->get("rendering/textures/vram_compression/import_bptc");
const bool can_s3tc = ProjectSettings::get_singleton()->get("rendering/textures/vram_compression/import_s3tc");
Added a warning for when a PC compression is not found for the project, closes #10626
2017-09-05 23:17:26 +00:00
Removed fallback system and merged bptc into s3tc
2018-08-27 16:47:13 +00:00
if (can_bptc) {
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 12:34:23 +00:00
//add to the list anyway
formats_imported.push_back("bptc");
}
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 03:05:04 +00: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 12:34:23 +00:00
bool can_compress_hdr = hdr_compression > 0;
bool has_alpha = image->detect_alpha() != Image::ALPHA_NONE;
if (is_hdr && can_compress_hdr) {
if (has_alpha) {
//can compress hdr, but hdr with alpha is not compressible
if (hdr_compression == 2) {
//but user selected to compress hdr anyway, so force an alpha-less format.
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 03:05:04 +00: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 12:34:23 +00:00
}
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 03:05:04 +00:00
Faster CVTT by reducing quality. Make BC6 and BC7 CVTT faster while still having better quality than DXT5.
2022-01-18 12:39:55 +00:00
if (!can_compress_hdr) {
//fallback to RGBE99995
if (image->get_format() != Image::FORMAT_RGBE9995) {
image->convert(Image::FORMAT_RGBE9995);
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 03:05:04 +00: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 12:34:23 +00:00
}
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 03:05:04 +00:00
}
BPTC support
2018-08-22 02:56:04 +00:00
Faster CVTT by reducing quality. Make BC6 and BC7 CVTT faster while still having better quality than DXT5.
2022-01-18 12:39:55 +00:00
bool ok_on_pc = false;
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 03:05:04 +00:00
if (can_bptc || can_s3tc) {
Faster CVTT by reducing quality. Make BC6 and BC7 CVTT faster while still having better quality than DXT5.
2022-01-18 12:39:55 +00:00
ok_on_pc = true;
Image::CompressMode image_compress_mode = Image::COMPRESS_BPTC;
if (!bptc_ldr && can_s3tc && is_ldr) {
image_compress_mode = Image::COMPRESS_S3TC;
}
Remove more occurrences of "stex"
2022-03-10 03:22:36 +00:00
_save_ctex(image, p_save_path + ".s3tc.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);
-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 00:47:28 +00:00
r_platform_variants->push_back("s3tc");
-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 21:43:37 +00:00
formats_imported.push_back("s3tc");
-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 00:47:28 +00:00
}
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 16:44:49 +00:00
if (ProjectSettings::get_singleton()->get("rendering/textures/vram_compression/import_etc2")) {
Remove more occurrences of "stex"
2022-03-10 03:22:36 +00:00
_save_ctex(image, p_save_path + ".etc2.ctex", compress_mode, lossy, Image::COMPRESS_ETC2, mipmaps, stream, detect_3d, detect_roughness, detect_normal, force_normal, srgb_friendly_pack, true, mipmap_limit, normal_image, roughness_channel);
-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 00:47:28 +00:00
r_platform_variants->push_back("etc2");
-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 21:43:37 +00:00
formats_imported.push_back("etc2");
-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 00:47:28 +00:00
}
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 16:44:49 +00:00
if (ProjectSettings::get_singleton()->get("rendering/textures/vram_compression/import_etc")) {
Remove more occurrences of "stex"
2022-03-10 03:22:36 +00:00
_save_ctex(image, p_save_path + ".etc.ctex", compress_mode, lossy, Image::COMPRESS_ETC, mipmaps, stream, detect_3d, detect_roughness, detect_normal, force_normal, srgb_friendly_pack, true, mipmap_limit, normal_image, roughness_channel);
-Renamed GlobalConfig to ProjectSettings, makes more sense. -Added system for feature overrides, it's pretty cool :)
2017-07-19 20:00:46 +00:00
r_platform_variants->push_back("etc");
-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 21:43:37 +00:00
formats_imported.push_back("etc");
-Renamed GlobalConfig to ProjectSettings, makes more sense. -Added system for feature overrides, it's pretty cool :)
2017-07-19 20:00:46 +00:00
}
Added a warning for when a PC compression is not found for the project, closes #10626
2017-09-05 23:17:26 +00:00
if (!ok_on_pc) {
Improve warning message for invalid desktop VRAM compression settings - Display the source file path. - Display the valid compression algorithms on desktop platforms. - Use "desktop platforms" instead of "PC" to avoid ambiguity. - Use "may" instead of "will", as desktop platforms can still sometimes display ETC1/ETC2 textures depending on the GPU and drivers.
2022-04-16 11:09:49 +00:00
EditorNode::add_io_error(vformat(TTR("%s: No suitable desktop VRAM compression algorithm enabled in Project Settings (S3TC or BPTC). This texture may not display correctly on desktop platforms."), p_source_file));
Added a warning for when a PC compression is not found for the project, closes #10626
2017-09-05 23:17:26 +00:00
}
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00:00
} else {
//import normally
Remove more occurrences of "stex"
2022-03-10 03:22:36 +00: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 12:45:45 +00:00
}
-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 21:43:37 +00:00
if (r_metadata) {
Dictionary metadata;
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 02:16:44 +00:00
metadata["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 21:43:37 +00:00
if (formats_imported.size()) {
metadata["imported_formats"] = formats_imported;
}
*r_metadata = metadata;
}
Lot of work in new importer, importing textures now works.
2017-02-01 12:45:45 +00: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 21:43:37 +00:00
const char *ResourceImporterTexture::compression_formats[] = {
"bptc",
"s3tc",
"etc",
"etc2",
Replace NULL with nullptr
2020-04-01 23:20:12 +00: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 21:43:37 +00: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 16:44:49 +00:00
String setting_path = "rendering/textures/vram_compression/import_" + String(compression_formats[index]);
-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 21:43:37 +00:00
bool test = ProjectSettings::get_singleton()->get(setting_path);
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
Dictionary metadata = ResourceFormatImporter::get_singleton()->get_resource_metadata(p_path);
if (!metadata.has("vram_texture")) {
return false;
}
bool vram = metadata["vram_texture"];
if (!vram) {
return true; //do not care about non vram
}
Vector<String> formats_imported;
if (metadata.has("imported_formats")) {
formats_imported = metadata["imported_formats"];
}
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 16:44:49 +00:00
String setting_path = "rendering/textures/vram_compression/import_" + String(compression_formats[index]);
-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 21:43:37 +00:00
bool test = ProjectSettings::get_singleton()->get(setting_path);
if (test) {
Vectors: Use clear() and has(). Use clear() instead of resize(0). Use has() instead of "find(p_val) != -1".
2022-02-01 18:19:13 +00:00
if (!formats_imported.has(compression_formats[index])) {
-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 21:43:37 +00:00
valid = false;
break;
}
}
index++;
}
return valid;
}
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
ResourceImporterTexture *ResourceImporterTexture::singleton = nullptr;
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ResourceImporterTexture::ResourceImporterTexture() {
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 15:43:38 +00: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 12:45:45 +00:00
}
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ResourceImporterTexture::~ResourceImporterTexture() {
Several bugfixes, improving the import workflow
2017-02-06 03:38:39 +00:00
}