mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-12-27 11:24:59 +08:00
Code Issues Packages Projects Releases Wiki Activity
87718d2a6e
godot/core/io/image.h

459 lines
18 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 20:25:55 +08:00
/**************************************************************************/
/* image.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 07:50:27 +08:00
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
#ifndef IMAGE_H
#define IMAGE_H
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-08 06:33:38 +08:00
#include "core/io/resource.h"
#include "core/math/color.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-12 00:13:45 +08:00
#include "core/math/rect2.h"
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/**
* Image storage class. This is used to store an image in user memory, as well as
* providing some basic methods for image manipulation.
* Images can be loaded from a file, or registered into the Render object as textures.
clang-format: Various fixes to comments alignment from `clang-format` 13 All reviewed manually and occasionally rewritten to avoid bad auto formatting.
2021-10-28 21:43:36 +08:00
*/
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
UDP Fixes -=-=-=-=- Curse the day I decided to port UDP code, as it ended up being two nights of work. At least It's done now (I hope). -Fixed UDP Support, API seems stable -Added UDP Chat demo (chat that can lose your packets, heh) -Added helpers to areas and bodies to get list of collided bodies and contained bodies. -Sped up screen/viewport capture code. -Added code to save an image as PNG -Small fix so scripts register their singletons after modules did.
2014-11-13 11:53:12 +08:00
class Image;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
typedef Error (*SavePNGFunc)(const String &p_path, const Ref<Image> &p_img);
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
typedef Vector<uint8_t> (*SavePNGBufferFunc)(const Ref<Image> &p_img);
Implement Running Godot as Movie Writer * Allows running the game in "movie writer" mode. * It ensures entirely stable framerate, so your run can be saved stable and with proper sound (which is impossible if your CPU/GPU can't sustain doing this in real-time). * If disabling vsync, it can save movies faster than the game is run, but if you want to control the interaction it can get difficult. * Implements a simple, default MJPEG writer. This new features has two main use cases, which have high demand: * Saving game videos in high quality and ensuring the frame rate is *completely* stable, always. * Using Godot as a tool to make movies and animations (which is ideal if you want interaction, or creating them procedurally. No other software is as good for this). **Note**: This feature **IS NOT** for capturing real-time footage. Use something like OBS, SimpleScreenRecorder or FRAPS to achieve that, as they do a much better job at intercepting the compositor than Godot can probably do using Vulkan or OpenGL natively. If your game runs near real-time when capturing, you can still use this feature but it will play no sound (sound will be saved directly). Usage: $ godot --write-movie movie.avi [scene_file.tscn] Missing: * Options for configuring video writing via GLOBAL_DEF * UI Menu for launching with this mode from the editor. * Add to list of command line options. * Add a feature tag to override configurations when movie writing (fantastic for saving videos with highest quality settings).
2022-06-17 06:55:19 +08:00
typedef Error (*SaveJPGFunc)(const String &p_path, const Ref<Image> &p_img, float p_quality);
typedef Vector<uint8_t> (*SaveJPGBufferFunc)(const Ref<Image> &p_img, float p_quality);
Add webp buffer loader for Image Cleanup the code memory load related code for Image Fix jpeg buff load function always returns OK event failed
2018-07-15 01:42:37 +08:00
typedef Ref<Image> (*ImageMemLoadFunc)(const uint8_t *p_png, int p_size);
Added Image's `load_svg_from_(buffer|string)` No core dependency to the svg module.
2023-06-15 07:27:56 +08:00
typedef Ref<Image> (*ScalableImageMemLoadFunc)(const uint8_t *p_data, int p_size, float p_scale);
Add support for saving WebP images
2022-06-05 05:05:55 +08:00
typedef Error (*SaveWebPFunc)(const String &p_path, const Ref<Image> &p_img, const bool p_lossy, const float p_quality);
typedef Vector<uint8_t> (*SaveWebPBufferFunc)(const Ref<Image> &p_img, const bool p_lossy, const float p_quality);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Add Image.save_exr()
2019-08-03 08:07:13 +08:00
typedef Error (*SaveEXRFunc)(const String &p_path, const Ref<Image> &p_img, bool p_grayscale);
For in-engine processing allow saving openexr to a buffer.
2022-06-20 09:55:47 +08:00
typedef Vector<uint8_t> (*SaveEXRBufferFunc)(const Ref<Image> &p_img, bool p_grayscale);
Add Image.save_exr()
2019-08-03 08:07:13 +08:00
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
class Image : public Resource {
GDCLASS(Image, Resource);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Prevent upscaled SVG from exceeding Image bounds Also expose Image MAX_WIDTH and MAX_HEIGHT. Fixes #24455.
2019-01-28 22:33:56 +08:00
public:
static SavePNGFunc save_png_func;
Implement Running Godot as Movie Writer * Allows running the game in "movie writer" mode. * It ensures entirely stable framerate, so your run can be saved stable and with proper sound (which is impossible if your CPU/GPU can't sustain doing this in real-time). * If disabling vsync, it can save movies faster than the game is run, but if you want to control the interaction it can get difficult. * Implements a simple, default MJPEG writer. This new features has two main use cases, which have high demand: * Saving game videos in high quality and ensuring the frame rate is *completely* stable, always. * Using Godot as a tool to make movies and animations (which is ideal if you want interaction, or creating them procedurally. No other software is as good for this). **Note**: This feature **IS NOT** for capturing real-time footage. Use something like OBS, SimpleScreenRecorder or FRAPS to achieve that, as they do a much better job at intercepting the compositor than Godot can probably do using Vulkan or OpenGL natively. If your game runs near real-time when capturing, you can still use this feature but it will play no sound (sound will be saved directly). Usage: $ godot --write-movie movie.avi [scene_file.tscn] Missing: * Options for configuring video writing via GLOBAL_DEF * UI Menu for launching with this mode from the editor. * Add to list of command line options. * Add a feature tag to override configurations when movie writing (fantastic for saving videos with highest quality settings).
2022-06-17 06:55:19 +08:00
static SaveJPGFunc save_jpg_func;
Add Image.save_exr()
2019-08-03 08:07:13 +08:00
static SaveEXRFunc save_exr_func;
Several fixes to GIProbes
2019-11-01 06:54:21 +08:00
static SavePNGBufferFunc save_png_buffer_func;
For in-engine processing allow saving openexr to a buffer.
2022-06-20 09:55:47 +08:00
static SaveEXRBufferFunc save_exr_buffer_func;
Implement Running Godot as Movie Writer * Allows running the game in "movie writer" mode. * It ensures entirely stable framerate, so your run can be saved stable and with proper sound (which is impossible if your CPU/GPU can't sustain doing this in real-time). * If disabling vsync, it can save movies faster than the game is run, but if you want to control the interaction it can get difficult. * Implements a simple, default MJPEG writer. This new features has two main use cases, which have high demand: * Saving game videos in high quality and ensuring the frame rate is *completely* stable, always. * Using Godot as a tool to make movies and animations (which is ideal if you want interaction, or creating them procedurally. No other software is as good for this). **Note**: This feature **IS NOT** for capturing real-time footage. Use something like OBS, SimpleScreenRecorder or FRAPS to achieve that, as they do a much better job at intercepting the compositor than Godot can probably do using Vulkan or OpenGL natively. If your game runs near real-time when capturing, you can still use this feature but it will play no sound (sound will be saved directly). Usage: $ godot --write-movie movie.avi [scene_file.tscn] Missing: * Options for configuring video writing via GLOBAL_DEF * UI Menu for launching with this mode from the editor. * Add to list of command line options. * Add a feature tag to override configurations when movie writing (fantastic for saving videos with highest quality settings).
2022-06-17 06:55:19 +08:00
static SaveJPGBufferFunc save_jpg_buffer_func;
Add support for saving WebP images
2022-06-05 05:05:55 +08:00
static SaveWebPFunc save_webp_func;
static SaveWebPBufferFunc save_webp_buffer_func;
Prevent upscaled SVG from exceeding Image bounds Also expose Image MAX_WIDTH and MAX_HEIGHT. Fixes #24455.
2019-01-28 22:33:56 +08:00
remove trailing whitespace
2016-03-09 07:00:52 +08:00
enum {
Several fixes to GIProbes
2019-11-01 06:54:21 +08:00
MAX_WIDTH = (1 << 24), // force a limit somehow
MAX_HEIGHT = (1 << 24), // force a limit somehow
MAX_PIXELS = 268435456
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
};
enum Format {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
FORMAT_L8, //luminance
FORMAT_LA8, //luminance-alpha
FORMAT_R8,
FORMAT_RG8,
FORMAT_RGB8,
FORMAT_RGBA8,
FORMAT_RGBA4444,
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 10:16:44 +08:00
FORMAT_RGB565,
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
FORMAT_RF, //float
FORMAT_RGF,
FORMAT_RGBF,
FORMAT_RGBAF,
FORMAT_RH, //half float
FORMAT_RGH,
FORMAT_RGBH,
FORMAT_RGBAH,
-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 08:49:49 +08:00
FORMAT_RGBE9995,
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
FORMAT_DXT1, //s3tc bc1
FORMAT_DXT3, //bc2
FORMAT_DXT5, //bc3
-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 08:49:49 +08:00
FORMAT_RGTC_R,
FORMAT_RGTC_RG,
FORMAT_BPTC_RGBA, //btpc bc7
FORMAT_BPTC_RGBF, //float bc6h
FORMAT_BPTC_RGBFU, //unsigned float bc6hu
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
FORMAT_ETC, //etc1
FORMAT_ETC2_R11, //etc2
FORMAT_ETC2_R11S, //signed, NOT srgb.
FORMAT_ETC2_RG11,
FORMAT_ETC2_RG11S,
FORMAT_ETC2_RGB8,
FORMAT_ETC2_RGBA8,
FORMAT_ETC2_RGB8A1,
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 10:16:44 +08:00
FORMAT_ETC2_RA_AS_RG, //used to make basis universal happy
FORMAT_DXT5_RA_AS_RG, //used to make basis universal happy
Implement basic ASTC support Implements basic ASTC support: * Only 4x4 and 8x8 block sizes. * Other block sizes are too complex to handle for Godot image compression handling. May be implemented sometime in the future. The need for ASTC is mostly for the following use cases: * Implement a high quality compression option for textures on mobile and M1 Apple hardware. * For this, the 4x4 is sufficient, since it uses the same size as BPTC. ASTC supports a lot of block sizes, but the benefit of supporting most of them is slim, while the implementation complexity in Godot is very high. Supporting only 4x4 (and 8x8) solves the real problem, which is lack of a BPTC alternative on hardware where it's missing. Note: This does not yet support encoding on import, an ASTC encoder will need to be added.
2022-09-06 03:11:34 +08:00
FORMAT_ASTC_4x4,
FORMAT_ASTC_4x4_HDR,
FORMAT_ASTC_8x8,
FORMAT_ASTC_8x8_HDR,
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
FORMAT_MAX
};
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 23:44:50 +08:00
static const char *format_names[FORMAT_MAX];
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
enum Interpolation {
INTERPOLATE_NEAREST,
INTERPOLATE_BILINEAR,
-Added ability to use cubic interpolation on image resize (little more quality on non-po2 resizing) -Added ability for exporter to shrink images to non-integer values. Helps if you want to convert your game artwork from 1080->720 or similar
2015-10-02 03:25:36 +08:00
INTERPOLATE_CUBIC,
Add trilinear filtering to image scaling
2018-06-02 03:53:35 +08:00
INTERPOLATE_TRILINEAR,
Implement Lanczos image filter
2019-05-05 20:03:52 +08:00
INTERPOLATE_LANCZOS,
Add trilinear filtering to image scaling
2018-06-02 03:53:35 +08:00
/* INTERPOLATE_TRICUBIC, */
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/* INTERPOLATE GAUSS */
};
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 10:16:44 +08:00
//this is used for compression
enum UsedChannels {
USED_CHANNELS_L,
USED_CHANNELS_LA,
USED_CHANNELS_R,
USED_CHANNELS_RG,
USED_CHANNELS_RGB,
USED_CHANNELS_RGBA,
-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 08:47:28 +08:00
};
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
//some functions provided by something else
Implement basic ASTC support Implements basic ASTC support: * Only 4x4 and 8x8 block sizes. * Other block sizes are too complex to handle for Godot image compression handling. May be implemented sometime in the future. The need for ASTC is mostly for the following use cases: * Implement a high quality compression option for textures on mobile and M1 Apple hardware. * For this, the 4x4 is sufficient, since it uses the same size as BPTC. ASTC supports a lot of block sizes, but the benefit of supporting most of them is slim, while the implementation complexity in Godot is very high. Supporting only 4x4 (and 8x8) solves the real problem, which is lack of a BPTC alternative on hardware where it's missing. Note: This does not yet support encoding on import, an ASTC encoder will need to be added.
2022-09-06 03:11:34 +08:00
enum ASTCFormat {
ASTC_FORMAT_4x4,
ASTC_FORMAT_8x8,
};
Add webp buffer loader for Image Cleanup the code memory load related code for Image Fix jpeg buff load function always returns OK event failed
2018-07-15 01:42:37 +08:00
static ImageMemLoadFunc _png_mem_loader_func;
Fix lossless formats in PortableCompressedTexture2D Update scene/resources/portable_compressed_texture.cpp Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>
2023-09-06 07:44:18 +08:00
static ImageMemLoadFunc _png_mem_unpacker_func;
Add webp buffer loader for Image Cleanup the code memory load related code for Image Fix jpeg buff load function always returns OK event failed
2018-07-15 01:42:37 +08:00
static ImageMemLoadFunc _jpg_mem_loader_func;
static ImageMemLoadFunc _webp_mem_loader_func;
Expose loading TGA images in Image.
2020-05-21 19:46:44 +08:00
static ImageMemLoadFunc _tga_mem_loader_func;
Add `Image.load_bmp_from_buffer()` for run-time BMP image loading This partially addresses https://github.com/godotengine/godot-proposals/issues/676.
2020-10-21 05:25:58 +08:00
static ImageMemLoadFunc _bmp_mem_loader_func;
Added Image's `load_svg_from_(buffer|string)` No core dependency to the svg module.
2023-06-15 07:27:56 +08:00
static ScalableImageMemLoadFunc _svg_scalable_mem_loader_func;
Add support for KTX & KTX2 image format Add support glTF KHR_texture_basisu extension
2023-04-29 00:26:01 +08:00
static ImageMemLoadFunc _ktx_mem_loader_func;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 19:17:11 +08:00
static void (*_image_compress_bc_func)(Image *, UsedChannels p_channels);
static void (*_image_compress_bptc_func)(Image *, UsedChannels p_channels);
static void (*_image_compress_etc1_func)(Image *);
static void (*_image_compress_etc2_func)(Image *, UsedChannels p_channels);
static void (*_image_compress_astc_func)(Image *, ASTCFormat p_format);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
static void (*_image_decompress_bc)(Image *);
BPTC support
2018-08-22 10:56:04 +08:00
static void (*_image_decompress_bptc)(Image *);
Add ETC1/ETC2 compression support though etc2comp. Remove rg-etc1 code. Also updated travis to use ubuntu 14.04. Fixes #8457.
2017-04-26 23:49:08 +08:00
static void (*_image_decompress_etc1)(Image *);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
static void (*_image_decompress_etc2)(Image *);
Implement basic ASTC support Implements basic ASTC support: * Only 4x4 and 8x8 block sizes. * Other block sizes are too complex to handle for Godot image compression handling. May be implemented sometime in the future. The need for ASTC is mostly for the following use cases: * Implement a high quality compression option for textures on mobile and M1 Apple hardware. * For this, the 4x4 is sufficient, since it uses the same size as BPTC. ASTC supports a lot of block sizes, but the benefit of supporting most of them is slim, while the implementation complexity in Godot is very high. Supporting only 4x4 (and 8x8) solves the real problem, which is lack of a BPTC alternative on hardware where it's missing. Note: This does not yet support encoding on import, an ASTC encoder will need to be added.
2022-09-06 03:11:34 +08:00
static void (*_image_decompress_astc)(Image *);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Implement lossless WebP encoding
2021-04-13 00:56:50 +08:00
static Vector<uint8_t> (*webp_lossy_packer)(const Ref<Image> &p_image, float p_quality);
static Vector<uint8_t> (*webp_lossless_packer)(const Ref<Image> &p_image);
static Ref<Image> (*webp_unpacker)(const Vector<uint8_t> &p_buffer);
static Vector<uint8_t> (*png_packer)(const Ref<Image> &p_image);
static Ref<Image> (*png_unpacker)(const Vector<uint8_t> &p_buffer);
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
static Vector<uint8_t> (*basis_universal_packer)(const Ref<Image> &p_image, UsedChannels p_channels);
static Ref<Image> (*basis_universal_unpacker)(const Vector<uint8_t> &p_buffer);
Add PortableCompressedTexture * Resource that allows saving textures embedded in scenes or standalone. * Supports only formats that are portable: Lossy, Lossles or BasisUniversal This is something I wanted to add for a long time. I made it now because @fire requires it for importing GLTF2 files with embedded textures, but also this will allow saving Godot scenes as standalone binary files that will run in all platforms (because textures will load everywhere). This is ideal when you want to distribute individual standalone assets online in games that can be built from Godot scenes.
2022-03-25 01:18:55 +08:00
static Ref<Image> (*basis_universal_unpacker_ptr)(const uint8_t *p_data, int p_size);
-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 08:49:49 +08:00
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
_FORCE_INLINE_ Color _get_color_at_ofs(const uint8_t *ptr, uint32_t ofs) const;
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 07:09:40 +08:00
_FORCE_INLINE_ void _set_color_at_ofs(uint8_t *ptr, uint32_t ofs, const Color &p_color);
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
protected:
static void _bind_methods();
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08: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 23:44:50 +08:00
private:
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 23:01:17 +08:00
Format format = FORMAT_L8;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
Vector<uint8_t> data;
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 23:01:17 +08:00
int width = 0;
int height = 0;
bool mipmaps = false;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
void _copy_internals_from(const Image &p_image) {
format = p_image.format;
width = p_image.width;
height = p_image.height;
mipmaps = p_image.mipmaps;
data = p_image.data;
}
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 23:44:50 +08:00
_FORCE_INLINE_ void _get_mipmap_offset_and_size(int p_mipmap, int &r_offset, int &r_width, int &r_height) const; //get where the mipmap begins in data
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Replace NULL with nullptr
2020-04-02 07:20:12 +08:00
static int _get_dst_image_size(int p_width, int p_height, Format p_format, int &r_mipmaps, int p_mipmaps = -1, int *r_mm_width = nullptr, int *r_mm_height = nullptr);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
bool _can_modify(Format p_format) const;
Fix `Image.blit_rect/blend_rect()` for negative `p_dest` point
2021-07-05 16:48:25 +08:00
_FORCE_INLINE_ void _get_clipped_src_and_dest_rects(const Ref<Image> &p_src, const Rect2i &p_src_rect, const Point2i &p_dest, Rect2i &r_clipped_src_rect, Rect2i &r_clipped_dest_rect) const;
Image Use memcpy() in fill(), fill_rect(), _put_pixelb(), _get_pixelb() Co-authored-by: Lightning_A <aaronjrecord@gmail.com>
2021-09-08 16:16:11 +08:00
_FORCE_INLINE_ void _put_pixelb(int p_x, int p_y, uint32_t p_pixel_size, uint8_t *p_data, const uint8_t *p_pixel);
_FORCE_INLINE_ void _get_pixelb(int p_x, int p_y, uint32_t p_pixel_size, const uint8_t *p_data, uint8_t *p_pixel);
_FORCE_INLINE_ void _repeat_pixel_over_subsequent_memory(uint8_t *p_pixel, int p_pixel_size, int p_count);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
void _set_data(const Dictionary &p_data);
Dictionary _get_data() const;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
Error _load_from_buffer(const Vector<uint8_t> &p_array, ImageMemLoadFunc p_loader);
Add webp buffer loader for Image Cleanup the code memory load related code for Image Fix jpeg buff load function always returns OK event failed
2018-07-15 01:42:37 +08:00
BPTC support
2018-08-22 10:56:04 +08:00
static void average_4_uint8(uint8_t &p_out, const uint8_t &p_a, const uint8_t &p_b, const uint8_t &p_c, const uint8_t &p_d);
static void average_4_float(float &p_out, const float &p_a, const float &p_b, const float &p_c, const float &p_d);
static void average_4_half(uint16_t &p_out, const uint16_t &p_a, const uint16_t &p_b, const uint16_t &p_c, const uint16_t &p_d);
static void average_4_rgbe9995(uint32_t &p_out, const uint32_t &p_a, const uint32_t &p_b, const uint32_t &p_c, const uint32_t &p_d);
static void renormalize_uint8(uint8_t *p_rgb);
static void renormalize_float(float *p_rgb);
static void renormalize_half(uint16_t *p_rgb);
static void renormalize_rgbe9995(uint32_t *p_rgb);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
public:
int get_width() const; ///< Get image width
int get_height() const; ///< Get image height
Replace Vector2(i) with Size2(i) for methods returning a size
2022-09-01 17:34:15 +08:00
Size2i get_size() const;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
bool has_mipmaps() const;
int get_mipmap_count() const;
remove trailing whitespace
2016-03-09 07:00:52 +08:00
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/**
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
* Convert the image to another format, conversion only to raw byte format
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08: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 23:44:50 +08:00
void convert(Format p_new_format);
Huge Amount of BugFix -=-=-=-=-=-=-=-=-=-=- -Fixes to Collada Exporter (avoid crash situtions) -Fixed to Collada Importer (Fixed Animation Optimizer Bugs) -Fixes to RigidBody/RigidBody2D body_enter/body_exit, was buggy -Fixed ability for RigidBody/RigidBody2D to get contacts reported and bodyin/out in Kinematic mode. -Added proper trigger support for 3D Physics shapes -Changed proper value for Z-Offset in OmniLight -Fixed spot attenuation bug in SpotLight -Fixed some 3D and 2D spatial soudn bugs related to distance attenuation. -Fixed bugs in EventPlayer (channels were muted by default) -Fix in ButtonGroup (get nodes in group are now returned in order) -Fixed Linear->SRGB Conversion, previous algo sucked, new algo works OK -Changed SRGB->Linear conversion to use hardware if supported, improves texture quality a lot -Fixed options for Y-Fov and X-Fov in camera, should be more intuitive. -Fixed bugs related to viewports and transparency Huge Amount of New Stuff: -=-=-=-=-=-=-=-==-=-=-=- -Ability to manually advance an AnimationPlayer that is inactive (with advance() function) -More work in WinRT platform -Added XY normalmap support, imports on this format by default. Reduces normlmap size and enables much nice compression using LATC -Added Anisotropic filter support to textures, can be specified on import -Added support for Non-Square, Isometric and Hexagonal tilemaps in TileMap. -Added Isometric Dungeon demo. -Added simple hexagonal map demo. -Added Truck-Town demo. Shows how most types of joints and vehicles are used. Please somebody make a nicer town, this one is too hardcore. -Added an Object-Picking API to both RigidBody and Area! (and relevant demo)
2014-10-03 11:10:51 +08:00
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/**
* Get the current image format.
*/
Format get_format() const;
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 07:09:40 +08:00
int get_mipmap_byte_size(int p_mipmap) const; //get where the mipmap begins in data
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
int get_mipmap_offset(int p_mipmap) const; //get where the mipmap begins in data
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 23:44:50 +08:00
void get_mipmap_offset_and_size(int p_mipmap, int &r_ofs, int &r_size) const; //get where the mipmap begins in data
void get_mipmap_offset_size_and_dimensions(int p_mipmap, int &r_ofs, int &r_size, int &w, int &h) const; //get where the mipmap begins in data
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Implement 3D textures as import and resource format.
2020-09-09 23:40:51 +08:00
enum Image3DValidateError {
VALIDATE_3D_OK,
VALIDATE_3D_ERR_IMAGE_EMPTY,
VALIDATE_3D_ERR_MISSING_IMAGES,
VALIDATE_3D_ERR_EXTRA_IMAGES,
VALIDATE_3D_ERR_IMAGE_SIZE_MISMATCH,
VALIDATE_3D_ERR_IMAGE_FORMAT_MISMATCH,
VALIDATE_3D_ERR_IMAGE_HAS_MIPMAPS,
};
static Image3DValidateError validate_3d_image(Format p_format, int p_width, int p_height, int p_depth, bool p_mipmaps, const Vector<Ref<Image>> &p_images);
static String get_3d_image_validation_error_text(Image3DValidateError p_error);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/**
Fix typos in source code using codespell From https://github.com/lucasdemarchi/codespell
2017-03-25 04:45:31 +08:00
* Resize the image, using the preferred interpolation method.
remove trailing whitespace
2016-03-09 07:00:52 +08:00
*/
Add interpolation parameter to resize_to_po2() Image::resize_to_po2() now takes an optional p_interpolation parameter that it passes directly to resize() with default value INTERPOLATE_BILINEAR.
2020-12-18 22:14:55 +08:00
void resize_to_po2(bool p_square = false, Interpolation p_interpolation = INTERPOLATE_BILINEAR);
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 23:44:50 +08:00
void resize(int p_width, int p_height, Interpolation p_interpolation = INTERPOLATE_BILINEAR);
ability to shrink all images x2 on load this is for extreme cases when running on devices with very low video memory, so you can still retain compatibility.
2016-05-04 23:36:51 +08:00
void shrink_x2();
Ensure ETC2 textures are ALSO compressed to Po2 when have mipmaps. Fixes #26733
2019-03-07 23:15:10 +08:00
bool is_size_po2() const;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/**
* Crop the image to a specific size, if larger, then the image is filled by black
*/
Improved packed scene previews.
2017-11-18 11:42:14 +08:00
void crop_from_point(int p_x, int p_y, int p_width, int p_height);
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 23:44:50 +08:00
void crop(int p_width, int p_height);
remove trailing whitespace
2016-03-09 07:00:52 +08:00
Implement `rotate_90/rotate_180` functions to `Image`
2022-07-15 03:20:12 +08:00
void rotate_90(ClockDirection p_direction);
void rotate_180();
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
void flip_x();
void flip_y();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/**
remove trailing whitespace
2016-03-09 07:00:52 +08:00
* Generate a mipmap to an image (creates an image 1/4 the size, with averaging of 4->1)
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
*/
Add option to renormalize mipmaps when generating them for normalmaps. Reduces some aliasing.
2018-04-30 08:51:37 +08:00
Error generate_mipmaps(bool p_renormalize = false);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 07:09:40 +08:00
enum RoughnessChannel {
ROUGHNESS_CHANNEL_R,
ROUGHNESS_CHANNEL_G,
ROUGHNESS_CHANNEL_B,
ROUGHNESS_CHANNEL_A,
ROUGHNESS_CHANNEL_L,
};
Error generate_mipmap_roughness(RoughnessChannel p_roughness_channel, const Ref<Image> &p_normal_map);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
void clear_mipmaps();
Ensure, if a texture meant for a normal map is imported and size limit exists, that it's renormalized after resize.
2018-07-03 21:55:50 +08:00
void normalize(); //for normal maps
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/**
Make some Image methods static
2022-07-23 02:06:19 +08:00
* Creates new internal image data of a given size and format. Current image will be lost.
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
*/
Make some Image methods static
2022-07-23 02:06:19 +08:00
void initialize_data(int p_width, int p_height, bool p_use_mipmaps, Format p_format);
void initialize_data(int p_width, int p_height, bool p_use_mipmaps, Format p_format, const Vector<uint8_t> &p_data);
void initialize_data(const char **p_xpm);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/**
* returns true when the image is empty (0,0) in size
*/
Rename empty() to is_empty()
2020-12-15 20:04:21 +08:00
bool is_empty() const;
remove trailing whitespace
2016-03-09 07:00:52 +08:00
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
Vector<uint8_t> get_data() const;
remove trailing whitespace
2016-03-09 07:00:52 +08: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 23:44:50 +08:00
Error load(const String &p_path);
Add static methods for creating Image and ImageTexture
2022-05-04 07:49:20 +08:00
static Ref<Image> load_from_file(const String &p_path);
Use libsquish to decompress DXT textures.
2017-04-30 09:14:14 +08:00
Error save_png(const String &p_path) const;
Implement Running Godot as Movie Writer * Allows running the game in "movie writer" mode. * It ensures entirely stable framerate, so your run can be saved stable and with proper sound (which is impossible if your CPU/GPU can't sustain doing this in real-time). * If disabling vsync, it can save movies faster than the game is run, but if you want to control the interaction it can get difficult. * Implements a simple, default MJPEG writer. This new features has two main use cases, which have high demand: * Saving game videos in high quality and ensuring the frame rate is *completely* stable, always. * Using Godot as a tool to make movies and animations (which is ideal if you want interaction, or creating them procedurally. No other software is as good for this). **Note**: This feature **IS NOT** for capturing real-time footage. Use something like OBS, SimpleScreenRecorder or FRAPS to achieve that, as they do a much better job at intercepting the compositor than Godot can probably do using Vulkan or OpenGL natively. If your game runs near real-time when capturing, you can still use this feature but it will play no sound (sound will be saved directly). Usage: $ godot --write-movie movie.avi [scene_file.tscn] Missing: * Options for configuring video writing via GLOBAL_DEF * UI Menu for launching with this mode from the editor. * Add to list of command line options. * Add a feature tag to override configurations when movie writing (fantastic for saving videos with highest quality settings).
2022-06-17 06:55:19 +08:00
Error save_jpg(const String &p_path, float p_quality = 0.75) const;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
Vector<uint8_t> save_png_to_buffer() const;
Implement Running Godot as Movie Writer * Allows running the game in "movie writer" mode. * It ensures entirely stable framerate, so your run can be saved stable and with proper sound (which is impossible if your CPU/GPU can't sustain doing this in real-time). * If disabling vsync, it can save movies faster than the game is run, but if you want to control the interaction it can get difficult. * Implements a simple, default MJPEG writer. This new features has two main use cases, which have high demand: * Saving game videos in high quality and ensuring the frame rate is *completely* stable, always. * Using Godot as a tool to make movies and animations (which is ideal if you want interaction, or creating them procedurally. No other software is as good for this). **Note**: This feature **IS NOT** for capturing real-time footage. Use something like OBS, SimpleScreenRecorder or FRAPS to achieve that, as they do a much better job at intercepting the compositor than Godot can probably do using Vulkan or OpenGL natively. If your game runs near real-time when capturing, you can still use this feature but it will play no sound (sound will be saved directly). Usage: $ godot --write-movie movie.avi [scene_file.tscn] Missing: * Options for configuring video writing via GLOBAL_DEF * UI Menu for launching with this mode from the editor. * Add to list of command line options. * Add a feature tag to override configurations when movie writing (fantastic for saving videos with highest quality settings).
2022-06-17 06:55:19 +08:00
Vector<uint8_t> save_jpg_to_buffer(float p_quality = 0.75) const;
Give EXR saving methods a default value of false like the bindings
2024-01-11 05:53:40 +08:00
Vector<uint8_t> save_exr_to_buffer(bool p_grayscale = false) const;
Error save_exr(const String &p_path, bool p_grayscale = false) const;
Add support for saving WebP images
2022-06-05 05:05:55 +08:00
Error save_webp(const String &p_path, const bool p_lossy = false, const float p_quality = 0.75f) const;
Vector<uint8_t> save_webp_to_buffer(const bool p_lossy = false, const float p_quality = 0.75f) const;
remove trailing whitespace
2016-03-09 07:00:52 +08:00
Make some Image methods static
2022-07-23 02:06:19 +08:00
static Ref<Image> create_empty(int p_width, int p_height, bool p_use_mipmaps, Format p_format);
static Ref<Image> create_from_data(int p_width, int p_height, bool p_use_mipmaps, Format p_format, const Vector<uint8_t> &p_data);
void set_data(int p_width, int p_height, bool p_use_mipmaps, Format p_format, const Vector<uint8_t> &p_data);
Unify TextServer built-in module and GDExtension code.
2022-02-13 20:41:29 +08:00
remove trailing whitespace
2016-03-09 07:00:52 +08:00
/**
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
* create an empty image
*/
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 23:01:17 +08:00
Image() {}
remove trailing whitespace
2016-03-09 07:00:52 +08:00
/**
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
* create an empty image of a specific size and format
*/
Image(int p_width, int p_height, bool p_use_mipmaps, Format p_format);
remove trailing whitespace
2016-03-09 07:00:52 +08:00
/**
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
* import an image of a specific size and format from a pointer
*/
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
Image(int p_width, int p_height, bool p_mipmaps, Format p_format, const Vector<uint8_t> &p_data);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 23:01:17 +08:00
~Image() {}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
enum AlphaMode {
ALPHA_NONE,
ALPHA_BIT,
ALPHA_BLEND
};
AlphaMode detect_alpha() const;
-fixes to navigation, so edge-merging is more flexible on conflict -add tab support to richtextlabel -some click fixes to audio stream resampled -ability to import largetextures (dialog)
2015-06-02 06:42:34 +08:00
bool is_invisible() const;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
static int get_format_pixel_size(Format p_format);
static int get_format_pixel_rshift(Format p_format);
-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 08:49:49 +08:00
static int get_format_block_size(Format p_format);
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 23:44:50 +08:00
static void get_format_min_pixel_size(Format p_format, int &r_w, int &r_h);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
Added proper import support for 3D and Array textures
2018-08-07 01:56:06 +08:00
static int get_image_data_size(int p_width, int p_height, Format p_format, bool p_mipmaps = false);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
static int get_image_required_mipmaps(int p_width, int p_height, Format p_format);
Custom material support seems complete.
2019-07-27 21:23:24 +08:00
static Size2i get_image_mipmap_size(int p_width, int p_height, Format p_format, int p_mipmap);
Fix Squish decompression, closes #18109
2018-11-17 06:12:00 +08:00
static int get_image_mipmap_offset(int p_width, int p_height, Format p_format, int p_mipmap);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 10:16:44 +08:00
static int get_image_mipmap_offset_and_dimensions(int p_width, int p_height, Format p_format, int p_mipmap, int &r_w, int &r_h);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
enum CompressMode {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-04 03:33:42 +08:00
COMPRESS_S3TC,
COMPRESS_ETC,
-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 08:49:49 +08:00
COMPRESS_ETC2,
Image: Rename PVRTC{2,4} to PVRTC1_{2,4}, drop COMPRESS_PVRTC2 We haven't had a proper implementation for COMPRESS_PVRTC2 (which is PVRTC1 2-bpp) in years, so let's drop it instead of keeping a compress type which doesn't work. The other enum values were renamed to clarify that our PVRTC2 and PVRTC4 are respectively PVRTC1 2-bpp and PVRTC1 4-bpp. PVRTC2 2-bpp and 4-bpp are not implemented yet.
2020-12-11 06:01:00 +08:00
COMPRESS_BPTC,
Implement basic ASTC support Implements basic ASTC support: * Only 4x4 and 8x8 block sizes. * Other block sizes are too complex to handle for Godot image compression handling. May be implemented sometime in the future. The need for ASTC is mostly for the following use cases: * Implement a high quality compression option for textures on mobile and M1 Apple hardware. * For this, the 4x4 is sufficient, since it uses the same size as BPTC. ASTC supports a lot of block sizes, but the benefit of supporting most of them is slim, while the implementation complexity in Godot is very high. Supporting only 4x4 (and 8x8) solves the real problem, which is lack of a BPTC alternative on hardware where it's missing. Note: This does not yet support encoding on import, an ASTC encoder will need to be added.
2022-09-06 03:11:34 +08:00
COMPRESS_ASTC,
Validate image formats, check if resize_to_po2 failed
2021-06-25 19:50:22 +08:00
COMPRESS_MAX,
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
};
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 10:16:44 +08:00
enum CompressSource {
COMPRESS_SOURCE_GENERIC,
COMPRESS_SOURCE_SRGB,
Validate image formats, check if resize_to_po2 failed
2021-06-25 19:50:22 +08:00
COMPRESS_SOURCE_NORMAL,
COMPRESS_SOURCE_MAX,
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 10:16:44 +08:00
};
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 19:17:11 +08:00
Error compress(CompressMode p_mode, CompressSource p_source = COMPRESS_SOURCE_GENERIC, ASTCFormat p_astc_format = ASTC_FORMAT_4x4);
Error compress_from_channels(CompressMode p_mode, UsedChannels p_channels, ASTCFormat p_astc_format = ASTC_FORMAT_4x4);
Light Baker! -=-=-=-=-=-= -Support for lightmap baker, have fun figuring out how it works before tutorial is published.
2014-06-11 21:41:03 +08:00
Error decompress();
work in progress, resource previews
2015-05-31 12:59:42 +08:00
bool is_compressed() const;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
void fix_alpha_edges();
Making Godot Easier to Use.. -=-=-=-=-=-=-=-=-=-=-=-=-=-= -Auto indenter in code editor, this makes it much easier to paste external code. -Zoom in 2D viewport now uses the mouse pointer as reference. -Obscure hack to see where code/line of GDScript in C++ backtrace. -Fixed a bug where keys would get stuck on X11 if pressed simultaneously -Added Api on IP singleton to request local IPs. -Premultiplied alpha support when importing texture, editing PNGs and as a blend mode.
2014-05-24 12:35:47 +08:00
void premultiply_alpha();
More 3D Work -=-=-=-=-=- -ESM Shadow Mapping for softer and less glitchy shadows -HDR Pipeline (convert to Linear on texture import, convert to SRGB at the end) -Fix to xml parse bug
2014-06-16 21:22:26 +08:00
void srgb_to_linear();
Consistently use normal_map
2020-12-23 17:34:26 +08:00
void normal_map_to_xy();
added rgbe_to_srgb method to Image
2018-05-31 03:14:07 +08:00
Ref<Image> rgbe_to_srgb();
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 10:16:44 +08:00
Ref<Image> get_image_from_mipmap(int p_mipamp) const;
Consistently use normal_map
2020-12-23 17:34:26 +08:00
void bump_map_to_normal_map(float bump_scale = 1.0);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Use integer types in Image and ImageTexture methods - Image.blit_rect() - Image.blit_rect_mask() - Image.blend_rect() - Image.blend_rect_mask() - Image.fill_rect() - Image.get_used_rect() - Image.get_rect() - ImageTexture.set_size_override()
2022-07-10 04:43:34 +08:00
void blit_rect(const Ref<Image> &p_src, const Rect2i &p_src_rect, const Point2i &p_dest);
void blit_rect_mask(const Ref<Image> &p_src, const Ref<Image> &p_mask, const Rect2i &p_src_rect, const Point2i &p_dest);
void blend_rect(const Ref<Image> &p_src, const Rect2i &p_src_rect, const Point2i &p_dest);
void blend_rect_mask(const Ref<Image> &p_src, const Ref<Image> &p_mask, const Rect2i &p_src_rect, const Point2i &p_dest);
Add Image::fill_rect method
2021-09-07 16:27:32 +08:00
void fill(const Color &p_color);
Use integer types in Image and ImageTexture methods - Image.blit_rect() - Image.blit_rect_mask() - Image.blend_rect() - Image.blend_rect_mask() - Image.fill_rect() - Image.get_used_rect() - Image.get_rect() - ImageTexture.set_size_override()
2022-07-10 04:43:34 +08:00
void fill_rect(const Rect2i &p_rect, const Color &p_color);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Use integer types in Image and ImageTexture methods - Image.blit_rect() - Image.blit_rect_mask() - Image.blend_rect() - Image.blend_rect_mask() - Image.fill_rect() - Image.get_used_rect() - Image.get_rect() - ImageTexture.set_size_override()
2022-07-10 04:43:34 +08:00
Rect2i get_used_rect() const;
Rename Image's `get_rect` to `get_region` Also renames its parameter to from "rect" to "region".
2022-09-18 08:19:55 +08:00
Ref<Image> get_region(const Rect2i &p_area) const;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 19:17:11 +08:00
static void set_compress_bc_func(void (*p_compress_func)(Image *, UsedChannels));
static void set_compress_bptc_func(void (*p_compress_func)(Image *, UsedChannels));
-Ability to debug video memory usage -Small fix to xml saver (swapping > and <)
2015-10-21 20:50:44 +08:00
static String get_format_name(Format p_format);
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-18 05:06:54 +08:00
Error load_png_from_buffer(const Vector<uint8_t> &p_array);
Error load_jpg_from_buffer(const Vector<uint8_t> &p_array);
Error load_webp_from_buffer(const Vector<uint8_t> &p_array);
Expose loading TGA images in Image.
2020-05-21 19:46:44 +08:00
Error load_tga_from_buffer(const Vector<uint8_t> &p_array);
Add `Image.load_bmp_from_buffer()` for run-time BMP image loading This partially addresses https://github.com/godotengine/godot-proposals/issues/676.
2020-10-21 05:25:58 +08:00
Error load_bmp_from_buffer(const Vector<uint8_t> &p_array);
Add support for KTX & KTX2 image format Add support glTF KHR_texture_basisu extension
2023-04-29 00:26:01 +08:00
Error load_ktx_from_buffer(const Vector<uint8_t> &p_array);
Add functions to image to load a PNG or JPG from a buffer, closes #4024
2017-12-21 04:16:21 +08:00
Added Image's `load_svg_from_(buffer|string)` No core dependency to the svg module.
2023-06-15 07:27:56 +08:00
Error load_svg_from_buffer(const Vector<uint8_t> &p_array, float scale = 1.0);
Error load_svg_from_string(const String &p_svg_str, float scale = 1.0);
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 10:16:44 +08:00
void convert_rg_to_ra_rgba8();
void convert_ra_rgba8_to_rg();
ETCPAK expects BGRA data for ETC
2022-12-01 22:34:05 +08:00
void convert_rgba8_to_bgra8();
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 10:16:44 +08: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 23:44:50 +08:00
Image(const uint8_t *p_mem_png_jpg, int p_len = -1);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Image(const char **p_xpm);
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
Add override keywords.
2020-07-10 18:34:39 +08:00
virtual Ref<Resource> duplicate(bool p_subresources = false) const override;
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
Add PortableCompressedTexture * Resource that allows saving textures embedded in scenes or standalone. * Supports only formats that are portable: Lossy, Lossles or BasisUniversal This is something I wanted to add for a long time. I made it now because @fire requires it for importing GLTF2 files with embedded textures, but also this will allow saving Godot scenes as standalone binary files that will run in all platforms (because textures will load everywhere). This is ideal when you want to distribute individual standalone assets online in games that can be built from Godot scenes.
2022-03-25 01:18:55 +08:00
UsedChannels detect_used_channels(CompressSource p_source = COMPRESS_SOURCE_GENERIC) const;
Added proper import support for 3D and Array textures
2018-08-07 01:56:06 +08:00
void optimize_channels();
-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 08:49:49 +08:00
Use Vector2i instead of Vector2 for Image get_pixelv and set_pixelv Co-authored-by: Andrii Doroshenko <xrayez@gmail.com>
2020-11-21 15:42:29 +08:00
Color get_pixelv(const Point2i &p_point) const;
Fixed a bug in get_pixel not being const
2017-06-17 08:28:58 +08:00
Color get_pixel(int p_x, int p_y) const;
Use Vector2i instead of Vector2 for Image get_pixelv and set_pixelv Co-authored-by: Andrii Doroshenko <xrayez@gmail.com>
2020-11-21 15:42:29 +08:00
void set_pixelv(const Point2i &p_point, const Color &p_color);
[#9292] Renamed Image.put_pixel() to set_pixel().
2017-07-08 01:05:45 +08:00
void set_pixel(int p_x, int p_y, const Color &p_color);
-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 08:49:49 +08:00
[TextServer / Font] Do not duplicate images to prevent unnecessary embedding.
2024-02-05 16:38:32 +08:00
const uint8_t *ptr() const;
uint8_t *ptrw();
int64_t data_size() const;
Add ability to change Icon Saturation -Allows for more theme freedom -Allows for entirely B&W themes.
2021-02-12 23:16:37 +08:00
void adjust_bcs(float p_brightness, float p_contrast, float p_saturation);
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 20:34:23 +08:00
void set_as_black();
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
void copy_internals_from(const Ref<Image> &p_image) {
Improve error reporting in the asset library and in related types This also makes errors related to asset image loading verbose-only, because, frankly, users can't do much about those errors. Spamming them with error messages about some assets on the frontend being broken is pointless.
2024-01-27 03:33:22 +08:00
ERR_FAIL_COND_MSG(p_image.is_null(), "Cannot copy image internals: invalid Image object.");
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
format = p_image->format;
width = p_image->width;
height = p_image->height;
mipmaps = p_image->mipmaps;
data = p_image->data;
}
Faster CVTT by reducing quality. Make BC6 and BC7 CVTT faster while still having better quality than DXT5.
2022-01-18 20:39:55 +08:00
Dictionary compute_image_metrics(const Ref<Image> p_compared_image, bool p_luma_metric = true);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
};
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
VARIANT_ENUM_CAST(Image::Format)
VARIANT_ENUM_CAST(Image::Interpolation)
VARIANT_ENUM_CAST(Image::CompressMode)
-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 08:47:28 +08:00
VARIANT_ENUM_CAST(Image::CompressSource)
Rewritten StreamTexture for better code reuse, added basis universal support
2019-09-27 10:16:44 +08:00
VARIANT_ENUM_CAST(Image::UsedChannels)
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
VARIANT_ENUM_CAST(Image::AlphaMode)
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 07:09:40 +08:00
VARIANT_ENUM_CAST(Image::RoughnessChannel)
Implement basic ASTC support Implements basic ASTC support: * Only 4x4 and 8x8 block sizes. * Other block sizes are too complex to handle for Godot image compression handling. May be implemented sometime in the future. The need for ASTC is mostly for the following use cases: * Implement a high quality compression option for textures on mobile and M1 Apple hardware. * For this, the 4x4 is sufficient, since it uses the same size as BPTC. ASTC supports a lot of block sizes, but the benefit of supporting most of them is slim, while the implementation complexity in Godot is very high. Supporting only 4x4 (and 8x8) solves the real problem, which is lack of a BPTC alternative on hardware where it's missing. Note: This does not yet support encoding on import, an ASTC encoder will need to be added.
2022-09-06 03:11:34 +08:00
VARIANT_ENUM_CAST(Image::ASTCFormat)
Removal of Image from Variant, converted to a Resource.
2017-05-17 18:36:47 +08:00
Style: Harmonize header guards to style guide [Core]
2020-03-25 18:10:34 +08:00
#endif // IMAGE_H
Reference in New Issue Copy Permalink