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

635 lines
24 KiB
C++
Raw Normal View History

Add a bunch of missing Godot headers in own files
2017-03-05 15:47:28 +01: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 14:16:55 +02:00
/* https://godotengine.org */
Add a bunch of missing Godot headers in own files
2017-03-05 15:47:28 +01:00
/*************************************************************************/
Update copyright statements to 2020 Happy new year to the wonderful Godot community! We're starting a new decade with a well-established, non-profit, free and open source game engine, and tons of further improvements in the pipeline from hundreds of contributors. Godot will keep getting better, and we're looking forward to all the games that the community will keep developing and releasing with it.
2020-01-01 11:16:22 +01:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
Add a bunch of missing Godot headers in own files
2017-03-05 15:47:28 +01: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-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
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"
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
void ResourceImporterTexture::_texture_reimport_roughness(const Ref<StreamTexture2D> &p_tex, const String &p_normal_path, RS::TextureDetectRoughnessChannel p_channel) {
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
}
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
void ResourceImporterTexture::_texture_reimport_3d(const Ref<StreamTexture2D> &p_tex) {
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
}
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
void ResourceImporterTexture::_texture_reimport_normal(const Ref<StreamTexture2D> &p_tex) {
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
{
if (make_flags.empty()) {
return;
}
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
for (Map<StringName, MakeInfo>::Element *E = make_flags.front(); E; E = E->next()) {
Ref<ConfigFile> cf;
cf.instance();
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
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 (E->get().flags & MAKE_NORMAL_FLAG && int(cf->get_value("params", "compress/normal_map")) == 0) {
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
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 (E->get().flags & MAKE_ROUGHNESS_FLAG && int(cf->get_value("params", "roughness/mode")) == 0) {
cf->set_value("params", "roughness/mode", E->get().channel_for_roughness + 2);
cf->set_value("params", "roughness/src_normal", E->get().normal_path_for_roughness);
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
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 (E->get().flags & MAKE_3D_FLAG && bool(cf->get_value("params", "detect_3d/compress_to"))) {
int compress_to = cf->get_value("params", "detect_3d/compress_to");
cf->set_value("params", "detect_3d/compress_to", 0);
if (compress_to == 1) {
cf->set_value("params", "compress/mode", COMPRESS_VRAM_COMPRESSED);
} else if (compress_to == 2) {
cf->set_value("params", "compress/mode", COMPRESS_BASIS_UNIVERSAL);
}
cf->set_value("params", "mipmaps/generate", true);
changed = true;
}
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
if (changed) {
cf->save(src_path);
to_reimport.push_back(E->key());
}
}
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";
}
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 16:44:50 +01: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 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
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 16:44:50 +01:00
void ResourceImporterTexture::get_recognized_extensions(List<String> *p_extensions) const {
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01: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 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 {
return "stex";
}
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 16:44:50 +01:00
String ResourceImporterTexture::get_resource_type() const {
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
return "StreamTexture2D";
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01: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 16:44:50 +01:00
bool ResourceImporterTexture::get_option_visibility(const String &p_option, const Map<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 17:49:08 +02: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 04:16:44 +02: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 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;
}
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"];
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 05:05:04 +02: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 04:16:44 +02:00
if (compress_mode < COMPRESS_VRAM_COMPRESSED) {
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 05:05:04 +02:00
return false;
}
if (!ProjectSettings::get_singleton()->get("rendering/vram_compression/import_bptc")) {
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 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 {
return 4;
}
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 {
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 16:44:50 +01:00
static const char *preset_names[] = {
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
"2D, Detect 3D",
"2D",
"2D Pixel",
"3D"
};
return preset_names[p_idx];
}
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 16:44:50 +01:00
void ResourceImporterTexture::get_import_options(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));
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));
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 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::INT, "compress/streamed"), false));
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));
r_options->push_back(ImportOption(PropertyInfo(Variant::STRING, "roughness/src_normal", PROPERTY_HINT_FILE, "*.png,*.jpg"), ""));
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));
[Texture Importer] Add option to invert color
2018-08-17 18:28:07 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "process/invert_color"), false));
Fix crash on import.
2019-06-26 20:11:52 +02:00
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "process/HDR_as_SRGB"), 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));
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, "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 13:45:45 +01: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
void ResourceImporterTexture::save_to_stex_format(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: {
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
f->store_32(StreamTexture2D::DATA_FORMAT_LOSSLESS);
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++) {
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::lossless_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: {
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
f->store_32(StreamTexture2D::DATA_FORMAT_LOSSY);
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++) {
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::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
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
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 13:45:45 +01: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
f->store_32(StreamTexture2D::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: {
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
f->store_32(StreamTexture2D::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: {
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
f->store_32(StreamTexture2D::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());
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 22:06:54 +01: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 04:16:44 +02: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);
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
}
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
void ResourceImporterTexture::_save_stex(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) {
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
FileAccess *f = FileAccess::open(p_to_path, FileAccess::WRITE);
f->store_8('G');
f->store_8('S');
f->store_8('T');
f->store_8('2'); //godot streamable texture 2D
//format version
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
f->store_32(StreamTexture2D::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) {
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
flags |= StreamTexture2D::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) {
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
flags |= StreamTexture2D::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) {
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
flags |= StreamTexture2D::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) {
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
flags |= StreamTexture2D::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) {
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
flags |= StreamTexture2D::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();
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-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);
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
save_to_stex_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
memdelete(f);
}
-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
Error ResourceImporterTexture::import(const String &p_source_file, const String &p_save_path, const Map<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 04:16:44 +02:00
CompressMode compress_mode = CompressMode(int(p_options["compress/mode"]));
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 16:44:50 +01:00
float lossy = p_options["compress/lossy_quality"];
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
int pack_channels = p_options["compress/channel_pack"];
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
bool mipmaps = p_options["mipmaps/generate"];
uint32_t mipmap_limit = int(mipmaps ? int(p_options["mipmaps/limit"]) : int(-1));
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 16:44:50 +01:00
bool fix_alpha_border = p_options["process/fix_alpha_border"];
bool premult_alpha = p_options["process/premult_alpha"];
[Texture Importer] Add option to invert color
2018-08-17 18:28:07 +02:00
bool invert_color = p_options["process/invert_color"];
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02:00
bool stream = p_options["compress/streamed"];
Several fixes to 3D rendering, and multimesh implementation.
2019-09-14 05:37:42 +02:00
int size_limit = p_options["process/size_limit"];
Several fixes related to PBR and Environment
2017-05-30 03:11:33 +02:00
bool hdr_as_srgb = p_options["process/HDR_as_SRGB"];
-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
int normal = p_options["compress/normal_map"];
updated import settings loader to 'svg/scale' fixes: #10815
2017-08-31 18:52:07 +02:00
float scale = p_options["svg/scale"];
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
int hdr_compression = p_options["compress/hdr_compression"];
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 05:05:04 +02:00
int bptc_ldr = p_options["compress/bptc_ldr"];
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
int roughness = p_options["roughness/mode"];
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 00:09:40 +01:00
String normal_map = p_options["roughness/src_normal"];
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;
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
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)) {
normal_image.instance();
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 12:36:47 +02:00
Ref<Image> image;
image.instance();
Replace NULL with nullptr
2020-04-02 01:20:12 +02: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 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
}
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01: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 22:43:37 +01:00
Array formats_imported;
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02: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 13:45:45 +01:00
//limit size
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02:00
if (image->get_width() >= image->get_height()) {
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
int new_width = size_limit;
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02: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 13:45:45 +01:00
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02:00
image->resize(new_width, new_height, Image::INTERPOLATE_CUBIC);
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
} else {
int new_height = size_limit;
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02: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 13:45:45 +01:00
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02:00
image->resize(new_width, new_height, Image::INTERPOLATE_CUBIC);
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
Do not normalize normal map when disabled, fixes #20761
2018-11-25 21:05:35 +01: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 15:55:50 +02:00
image->normalize();
}
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
if (fix_alpha_border) {
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02:00
image->fix_alpha_edges();
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
if (premult_alpha) {
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02:00
image->premultiply_alpha();
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
}
[Texture Importer] Add option to invert color
2018-08-17 18:28:07 +02:00
if (invert_color) {
int height = image->get_height();
int width = image->get_width();
[Texture Import] Fix invert color
2018-09-02 15:13:19 +02:00
for (int i = 0; i < width; i++) {
for (int j = 0; j < height; j++) {
[Texture Importer] Add option to invert color
2018-08-17 18:28:07 +02:00
image->set_pixel(i, j, image->get_pixel(i, j).inverted());
}
}
}
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) {
//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 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
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02: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 22:00:46 +02: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 13:45:45 +01:00
//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
Style: Apply clang-format to @reduz's changes [ci skip]
2017-09-13 09:13:23 +02:00
bool ok_on_pc = false;
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 05:05:04 +02:00
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 04:16:44 +02:00
bool is_ldr = (image->get_format() >= Image::FORMAT_L8 && image->get_format() <= Image::FORMAT_RGB565);
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 05:05:04 +02:00
bool can_bptc = ProjectSettings::get_singleton()->get("rendering/vram_compression/import_bptc");
bool can_s3tc = ProjectSettings::get_singleton()->get("rendering/vram_compression/import_s3tc");
Added a warning for when a PC compression is not found for the project, closes #10626
2017-09-06 01:17:26 +02:00
Removed fallback system and merged bptc into s3tc
2018-08-27 18:47:13 +02: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 14:34:23 +02:00
//add to the list anyway
formats_imported.push_back("bptc");
}
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;
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 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
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 (can_compress_hdr) {
if (!can_bptc) {
//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 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
} else {
can_bptc = false;
BPTC support
2018-08-22 04:56: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
if (is_ldr && can_bptc) {
if (bptc_ldr == 0 || (bptc_ldr == 1 && !has_alpha)) {
can_bptc = false;
}
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
Fix BPTC and fix importing HDR images with LDR compression
2018-08-28 05:05:04 +02:00
if (can_bptc || can_s3tc) {
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
_save_stex(image, p_save_path + ".s3tc.stex", compress_mode, lossy, can_bptc ? Image::COMPRESS_BPTC : Image::COMPRESS_S3TC, 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 02:47:28 +02: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 22:43:37 +01:00
formats_imported.push_back("s3tc");
Style: Apply clang-format to @reduz's changes [ci skip]
2017-09-13 09:13:23 +02:00
ok_on_pc = 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
}
Removed fallback system and merged bptc into s3tc
2018-08-27 18:47:13 +02:00
if (ProjectSettings::get_singleton()->get("rendering/vram_compression/import_etc2")) {
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
_save_stex(image, p_save_path + ".etc2.stex", 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 02:47:28 +02: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 22:43:37 +01: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 02:47:28 +02:00
}
Removed fallback system and merged bptc into s3tc
2018-08-27 18:47:13 +02:00
if (ProjectSettings::get_singleton()->get("rendering/vram_compression/import_etc")) {
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
_save_stex(image, p_save_path + ".etc.stex", 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 22:00:46 +02: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 22:43:37 +01: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 22:00:46 +02:00
}
Removed fallback system and merged bptc into s3tc
2018-08-27 18:47:13 +02:00
if (ProjectSettings::get_singleton()->get("rendering/vram_compression/import_pvrtc")) {
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
_save_stex(image, p_save_path + ".pvrtc.stex", compress_mode, lossy, Image::COMPRESS_PVRTC4, 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 02:47:28 +02:00
r_platform_variants->push_back("pvrtc");
-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
formats_imported.push_back("pvrtc");
-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
}
Lot of work in new importer, importing textures now works.
2017-02-01 13:45:45 +01:00
Added a warning for when a PC compression is not found for the project, closes #10626
2017-09-06 01:17:26 +02:00
if (!ok_on_pc) {
Misc. typos Found via `codespell -q 3 -I ../godot-word-whitelist.txt --skip="./thirdparty,*.po"`
2018-09-13 03:38:39 +02:00
EditorNode::add_io_error("Warning, no suitable PC VRAM compression enabled in Project Settings. This texture will not display correctly on PC.");
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 {
//import normally
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
_save_stex(image, p_save_path + ".stex", 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
}
-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) {
Dictionary metadata;
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 04:16:44 +02: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 22:43:37 +01: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 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[] = {
"bptc",
"s3tc",
"etc",
"etc2",
"pvrtc",
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]) {
String setting_path = "rendering/vram_compression/import_" + String(compression_formats[index]);
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]) {
String setting_path = "rendering/vram_compression/import_" + String(compression_formats[index]);
bool test = ProjectSettings::get_singleton()->get(setting_path);
if (test) {
if (formats_imported.find(compression_formats[index]) == -1) {
valid = false;
break;
}
}
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
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 16:44:50 +01:00
ResourceImporterTexture::ResourceImporterTexture() {
singleton = this;
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
StreamTexture2D::request_3d_callback = _texture_reimport_3d;
StreamTexture2D::request_roughness_callback = _texture_reimport_roughness;
StreamTexture2D::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
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 16:44:50 +01:00
ResourceImporterTexture::~ResourceImporterTexture() {
Several bugfixes, improving the import workflow
2017-02-06 04:38:39 +01:00
}
Reference in a new issue Copy permalink