ImageData.h

浏览该文件的文档.

 
#pragma once
#include "common/Export.h"
 
 
#include "common/Data.h"
#include "common/Resource.h"
#include "common/Result.h"
 
#include "medialoader/image/pixelformat.h"
#include "medialoader/image/floattypes.h"
#include "medialoader/image/Color.h"
#include "medialoader/image/FormatHandler.h"
 
#include <cstdint>
 
namespace eve
{
namespace filesystem {
class FileData;
}
namespace image
{
 
enum class ImageScaleFilter { Point, Bilinear };
 
struct UvPaintReceipt {
    int centerX = 0;
    int centerY = 0;
    int changedPixelCount = 0;
};
 
class EVENGINE_API_PLATFORM ImageData : public Resource {
public:
    using float16 = medialoader::float16;
    using Colorf = medialoader::Colorf;
    using FormatHandler = medialoader::FormatHandler;
 
    union Pixel
    {
        uint8_t   rgba8[4];
        uint16_t  rgba16[4];
        float16   rgba16f[4];
        float     rgba32f[4];
        uint16_t  packed16;
        uint32_t  packed32;
    };
 
    typedef void (*PixelSetFunction)(const Colorf &c, Pixel *p);
    typedef void (*PixelGetFunction)(const Pixel *p, Colorf &c);
 
    ImageData(Data *data);
    ImageData(int width, int height, std::string format = "RGBA8");
    ImageData(int width, int height, std::string format, void *data, bool own);
    ImageData(const ImageData &c);
    virtual ~ImageData();
 
    void paste(ImageData *src, int dx, int dy, int sx, int sy, int sw, int sh);
 
    ImageData *rotate(float radians, std::string filter = "nearest", bool expand = true) const;
 
    [[nodiscard]] eve::Result<int> scalePcg(int newWidth, int newHeight, ImageScaleFilter filter);
 
    bool inside(int x, int y) const;
 
    void setPixel(int x, int y, const Colorf &p);
 
    [[nodiscard]] eve::Result<UvPaintReceipt> paintCircleUv(float u, float v, float radiusPixels,
                                                            const Colorf &color, bool wrapU = false,
                                                            bool wrapV = false);
 
    void getPixel(int x, int y, Colorf &c) const;
    Colorf getPixel(int x, int y) const;
 
    filesystem::FileData *encode(FormatHandler::EncodedFormat format, const char *filename, bool writefile) const;
 
    // Implements ImageDataBase.
    ImageData *clone() const;
    void *getData() const;
    size_t getSize() const;
    bool isSRGB() const;
 
    void adopt(eve::Resource &replacement) override;
 
    int getWidth() const;
    int getHeight() const;
    std::string getFormat() const;
 
    size_t getPixelSize() const;
 
    PixelSetFunction getPixelSetFunction() const { return pixelSetFunction; }
    PixelGetFunction getPixelGetFunction() const { return pixelGetFunction; }
 
    static bool validPixelFormat(std::string format);
    static bool canPaste(std::string src, std::string dst);
 
    static PixelSetFunction getPixelSetFunction(std::string format);
    static PixelGetFunction getPixelGetFunction(std::string format);
 
    static bool getConstant(const char *in, FormatHandler::EncodedFormat &out);
    static bool getConstant(FormatHandler::EncodedFormat in, const char *&out);
    static std::vector<std::string> getConstants(FormatHandler::EncodedFormat);
 
private:
 
    // Create imagedata. Initialize with data if not null.
    void create(int width, int height, std::string format, void *data = nullptr);
 
    // Decode and load an encoded format.
    void decode(Data *data);
 
    // The actual data.
    unsigned char *data = nullptr;
 
    int width, height;
    std::string format;
 
    // The format handler that was used to decode the ImageData. We need to know
    // this so we can properly delete memory allocated by the decoder.
    FormatHandler* decodeHandler;
 
    PixelSetFunction pixelSetFunction;
    PixelGetFunction pixelGetFunction;
 
};  // ImageData
 
} // image
} // eve