ObjectThumbnail.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "CoreTypes.h"
#include "Serialization/Archive.h"
#include "Serialization/StructuredArchive.h"
#include "UObject/NameTypes.h"
#include "ImageCore.h"
 
class FThumbnailCompressionInterface
{
public:
 
    virtual bool CompressImage( const TArray< uint8 >& InUncompressedData, const int32 InWidth, const int32 InHeight, TArray< uint8 >& OutCompressedData ) = 0;
 
    virtual bool DecompressImage( const TArray< uint8 >& InCompressedData, const int32 InWidth, const int32 InHeight, TArray< uint8 >& OutUncompressedData ) = 0;
 
    virtual FName GetThumbnailCompressorName() const = 0;
 
    virtual bool IsLosslessCompression() const = 0;
};
 
 
class FObjectThumbnail
{
public:
 
    static void SetThumbnailCompressors( FThumbnailCompressionInterface* InPNGThumbnailCompressor, 
        FThumbnailCompressionInterface* InJPEGThumbnailCompressor)
    {
        PNGThumbnailCompressor = InPNGThumbnailCompressor;
        JPEGThumbnailCompressor = InJPEGThumbnailCompressor;
    }
 
private:
 
    static CORE_API FThumbnailCompressionInterface* PNGThumbnailCompressor;
    static CORE_API FThumbnailCompressionInterface* JPEGThumbnailCompressor;
 
public:
 
    CORE_API FObjectThumbnail();
 
    int32 GetImageWidth() const
    {
        return ImageWidth;
    }
 
    int32 GetImageHeight() const
    {
        return ImageHeight;
    }
 
    int32 GetCompressedDataSize() const
    {
        return CompressedImageData.Num();
    }
 
    void SetImageSize( int32 InWidth, int32 InHeight )
    {
        ImageWidth = InWidth;
        ImageHeight = InHeight;
    }
 
    bool IsLoadedFromDisk(void) const { return bLoadedFromDisk; }
 
    bool IsCreatedAfterCustomThumbsEnabled (void) const { return bCreatedAfterCustomThumbForSharedTypesEnabled; }
    
    void SetCreatedAfterCustomThumbsEnabled(void) { bCreatedAfterCustomThumbForSharedTypesEnabled = true; }
 
    bool IsDirty() const
    {
        return bIsDirty;
    }
 
    void MarkAsDirty()
    {
        bIsDirty = true;
    }
 
    TArray< uint8 >& AccessImageData()
    {
        return ImageData;
    }
 
    const TArray< uint8 >& AccessImageData() const
    {
        return ImageData;
    }
 
    TArray< uint8 >& AccessCompressedImageData()
    {
        return CompressedImageData;
    }
 
    bool IsEmpty() const
    {
        return ImageWidth == 0 || ImageHeight == 0;
    }
 
    bool HasValidImageData() const
    {
        return !ImageData.IsEmpty() || !CompressedImageData.IsEmpty();
    }
 
    CORE_API FThumbnailCompressionInterface* GetCompressor() const;
 
    CORE_API FThumbnailCompressionInterface* ChooseNewCompressor() const;
 
    CORE_API const TArray< uint8 >& GetUncompressedImageData() const;
 
    FImageView GetImage() const
    {
        const TArray< uint8 >& Data = FObjectThumbnail::GetUncompressedImageData();
        if ( Data.Num() == 0 )
        {
            return FImageView();
        }
 
        return FImageView( (void *)&Data[0],ImageWidth,ImageHeight,ERawImageFormat::BGRA8 );
    }
 
    void SetImage(const FImageView & Image)
    {
        // Image must be converted to BGRA8 to store in Thumbnail
        // if Image is already BGRA8-SRGB then this is just a memcpy
        //  which is what we need anyway to copy the bytes into a new array
        //  so there is no inefficiency in just always using the FImage copy here
        FImage ImageBGRA8;
        Image.CopyTo(ImageBGRA8,ERawImageFormat::BGRA8,EGammaSpace::sRGB);
        SetImage( MoveTemp(ImageBGRA8) );
    }
    
    void SetImage(FImage && Image)
    {
        // change format if needed, nop if not
        // MoveFrom is discardable so it's okay if we just change it in place
        Image.ChangeFormat(ERawImageFormat::BGRA8,EGammaSpace::sRGB);
 
        ImageWidth  = Image.SizeX;
        ImageHeight = Image.SizeY;
        CompressedImageData.Reset();
        bIsJPEG = false;
        ImageData = MoveTemp(Image.RawData); // array move
        Image.Reset();
    }
 
    CORE_API void Serialize(FArchive& Ar);
    CORE_API void Serialize(FStructuredArchive::FSlot Slot);
    
    CORE_API void CompressImageData();
 
    CORE_API void DecompressImageData();
 
    CORE_API void CountBytes( FArchive& Ar ) const;
 
    CORE_API void CountImageBytes_Compressed( FArchive& Ar ) const;
 
    CORE_API void CountImageBytes_Uncompressed( FArchive& Ar ) const;
 
    friend FArchive& operator<<( FArchive& Ar, FObjectThumbnail& Thumb )
    {
        if ( Ar.IsCountingMemory() )
        {
            Thumb.CountBytes(Ar);
        }
        else
        {
            Thumb.Serialize(Ar);
        }
        return Ar;
    }
 
    friend FArchive& operator<<( FArchive& Ar, const FObjectThumbnail& Thumb )
    {
        Thumb.CountBytes(Ar);
        return Ar;
    }
 
    bool operator ==( const FObjectThumbnail& Other ) const
    {
        return  ImageWidth          == Other.ImageWidth
            &&  ImageHeight         == Other.ImageHeight
            &&  bIsDirty            == Other.bIsDirty
            &&  CompressedImageData == Other.CompressedImageData;
    }
 
    bool operator !=( const FObjectThumbnail& Other ) const
    {
        return  ImageWidth          != Other.ImageWidth
            ||  ImageHeight         != Other.ImageHeight
            ||  bIsDirty            != Other.bIsDirty
            ||  CompressedImageData != Other.CompressedImageData;
    }
 
private:
 
    int32 ImageWidth;
 
    int32 ImageHeight;
 
    TArray< uint8 > CompressedImageData;
 
    TArray< uint8 > ImageData;
 
    bool bIsDirty;
 
    bool bLoadedFromDisk;
 
    bool bIsJPEG;
 
    bool bCreatedAfterCustomThumbForSharedTypesEnabled;
};
 
 
typedef TMap< FName, FObjectThumbnail > FThumbnailMap;
 
 
struct FObjectFullNameAndThumbnail
{
    FName ObjectFullName;
    
    const FObjectThumbnail* ObjectThumbnail;
 
    int32 FileOffset;
 
    FObjectFullNameAndThumbnail()
        : ObjectFullName(),
          ObjectThumbnail( nullptr ),
          FileOffset( 0 )
    { }
 
    FObjectFullNameAndThumbnail( const FName InFullName, const FObjectThumbnail* InThumbnail )
        : ObjectFullName( InFullName ),
          ObjectThumbnail( InThumbnail ),
          FileOffset( 0 )
    { }
 
    CORE_API void CountBytes( FArchive& Ar ) const;
 
    friend FArchive& operator<<( FArchive& Ar, FObjectFullNameAndThumbnail& NameThumbPair )
    {
        if ( Ar.IsCountingMemory() )
        {
            NameThumbPair.CountBytes(Ar);
        }
        else
        {
            Ar << NameThumbPair.ObjectFullName << NameThumbPair.FileOffset;
        }
        return Ar;
    }
 
    friend FArchive& operator<<( FArchive& Ar, const FObjectFullNameAndThumbnail& NameThumbPair )
    {
        NameThumbPair.CountBytes(Ar);
        return Ar;
    }
};