1
0
KF2-Dev-Scripts/Engine/Classes/Texture2D.uc

545 lines
20 KiB
Ucode
Raw Normal View History

2020-12-13 15:01:13 +00:00
/**
* Copyright 1998-2013 Epic Games, Inc. All Rights Reserved.
*/
class Texture2D extends Texture
native(Texture)
hidecategories(Object);
/**
* A mip-map of the texture.
*/
struct native Texture2DMipMap
{
var native UntypedBulkData_Mirror Data{FTextureMipBulkData};
var native int SizeX;
var native int SizeY;
structcpptext
{
/**
* Special serialize function passing the owning UObject along as required by FUnytpedBulkData
* serialization.
*
* @param Ar Archive to serialize with
* @param Owner UObject this structure is serialized within
* @param MipIdx Current mip being serialized
*/
void Serialize( FArchive& Ar, UObject* Owner, INT MipIdx );
}
};
/** The texture's mip-map data. */
var native const IndirectArray_Mirror Mips{TIndirectArray<FTexture2DMipMap>};
/** Cached PVRTC compressed texture data */
var native const IndirectArray_Mirror CachedPVRTCMips{TIndirectArray<FTexture2DMipMap>};
/** Cached ATITC compressed texture data */
var native const IndirectArray_Mirror CachedATITCMips{TIndirectArray<FTexture2DMipMap>};
/** Cached ETC compressed texture data */
var native const IndirectArray_Mirror CachedETCMips{TIndirectArray<FTexture2DMipMap>};
/** The size that the Flash compressed texture data was cached at */
var native const int CachedFlashMipsMaxResolution;
/** Cached Flash compressed texture data */
var native const UntypedBulkData_Mirror CachedFlashMips{FTextureMipBulkData};
/** The width of the texture. */
var const int SizeX;
/** The height of the texture. */
var const int SizeY;
/** The original width of the texture source art we imported from. */
var const int OriginalSizeX;
/** The original height of the texture source art we imported from. */
var const int OriginalSizeY;
/** The format of the texture data. */
var const EPixelFormat Format;
/** The addressing mode to use for the X axis. */
var() TextureAddress AddressX;
/** The addressing mode to use for the Y axis. */
var() TextureAddress AddressY;
/** Is this texture editor only, and should not be cooked into the final packages */
var() const bool bIsEditorOnly;
/** Whether the texture is currently streamable or not. */
var transient const bool bIsStreamable;
/** Whether the current texture mip change request is pending cancelation. */
var transient const bool bHasCancelationPending;
/**
* Whether the texture has been loaded from a persistent archive. We keep track of this in order to not stream
* textures that are being re-imported over as they will have a linker but won't have been serialized from disk
* and are therefore not streamable.
*/
var transient const bool bHasBeenLoadedFromPersistentArchive;
/** Override whether to fully stream even if texture hasn't been rendered. */
var transient bool bForceMiplevelsToBeResident;
/** Global/ serialized version of ForceMiplevelsToBeResident. */
var() const bool bGlobalForceMipLevelsToBeResident;
/** WorldInfo timestamp that tells the streamer to force all miplevels to be resident up until that time. */
var private transient float ForceMipLevelsToBeResidentTimestamp;
/** Allows texture to be a source for Texture2DComposite. Will NOT be available for use in rendering! */
var() const bool bIsCompositingSource;
/** Whether the texture has been painted in the editor. */
var editoronly bool bHasBeenPaintedInEditor;
/** Name of texture file cache texture mips are stored in, NAME_None if it is not part of one. */
var name TextureFileCacheName;
/** ID generated whenever the texture is changed so that its bulk data can be updated in the TextureFileCache during cook */
var native const guid TextureFileCacheGuid;
/** Number of miplevels the texture should have resident. */
var transient const int RequestedMips;
/** Number of miplevels currently resident. */
var transient const int ResidentMips;
/** Number of mips to remove when recompressing (does not work with TC_NormalmapUncompressed) */
var() int MipsToRemoveOnCompress;
/** Command fence used to shut down properly */
var native const pointer ReleaseTexture2DFence{class FRenderCommandFence};
/**
* Thread-safe counter indicating the texture streaming state. The definitions below are mirrored in UnTex.h.
*
enum ETextureStreamingState
{
// The renderer hasn't created the resource yet.
TexState_InProgress_Initialization = -1,
// There are no pending requests/ all requests have been fulfilled.
TexState_ReadyFor_Requests = 0,
// Finalization has been kicked off and is in progress.
TexState_InProgress_Finalization = 1,
// Initial request has completed and finalization needs to be kicked off.
TexState_ReadyFor_Finalization = 2,
// We're currently loading in mip data.
TexState_InProgress_Loading = 3,
// ...
// States 3+N means we're currently loading in N mips
// ...
// Memory has been allocated and we're ready to start loading in mips.
TexState_ReadyFor_Loading = 100,
// We're currently allocating/preparing memory for the new mip count.
TexState_InProgress_Allocating = 101,
};
*/
var native transient const ThreadSafeCounter PendingMipChangeRequestStatus{mutable FThreadSafeCounter};
/** Data formatted only for 1 bit textures which are CPU based and never allocate GPU Memory **/
var private{private} array<byte> SystemMemoryData;
/**
* Mirror helper structure for linked list of texture objects. The linked list should NOT be traversed by the
* garbage collector, which is why Element is declared as a pointer.
*/
struct TextureLinkedListMirror
{
var native const POINTER Element;
var native const POINTER Next;
var native const POINTER PrevLink;
};
/** This texture's link in the global streamable texture list. */
var private{private} native const duplicatetransient noimport TextureLinkedListMirror StreamableTexturesLink{TLinkedList<UTexture2D*>};
/** FStreamingTexture index used by the texture streaming system. */
var private{private} const transient duplicatetransient int StreamingIndex;
/**
* Keep track of the first mip level stored in the packed miptail.
* it's set to highest mip level if no there's no packed miptail
*/
var const int MipTailBaseIdx;
/** memory used for directly loading bulk mip data */
var private const native transient pointer ResourceMem{FTexture2DResourceMem};
/** keep track of first mip level used for ResourceMem creation */
var private const int FirstResourceMemMip;
/** Used for various timing measurements, e.g. streaming latency. */
var private const native transient float Timer;
/**
* Tells the streaming system that it should force all mip-levels to be resident for a number of seconds.
* @param Seconds Duration in seconds
* @param CinematicTextureGroups Bitfield indicating which texture groups that use extra high-resolution mips
*/
native final function SetForceMipLevelsToBeResident( float Seconds, optional int CinematicTextureGroups = 0 );
cpptext
{
// Static private variables.
private:
/** First streamable texture link. Not handled by GC as BeginDestroy automatically unlinks. */
static TLinkedList<UTexture2D*>* FirstStreamableLink;
/** Current streamable texture link for iteration over textures. Not handled by GC as BeginDestroy automatically unlinks. */
static TLinkedList<UTexture2D*>* CurrentStreamableLink;
/** Number of streamable textures. */
static INT NumStreamableTextures;
public:
// UObject interface.
void InitializeIntrinsicPropertyValues();
void Serialize(FArchive& Ar) override;
#if !CONSOLE
// SetLinker is only virtual on consoles.
void SetLinker( ULinkerLoad* L, INT I ) override;
#endif
void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
/**
* Called after the garbage collection mark phase on unreachable objects.
*/
void BeginDestroy() override;
UBOOL IsReadyForFinishDestroy() override;
void FinishDestroy() override;
/**
* Called after object and all its dependencies have been serialized.
*/
void PostLoad() override;
/**
* Called after object has been duplicated.
*/
void PostDuplicate() override;
/**
* Generates a GUID for the texture if one doesn't already exist.
*
* @param bForceGeneration Whether we should generate a GUID even if it is already valid.
*/
void GenerateTextureFileCacheGUID(UBOOL bForceGeneration=FALSE);
// USurface interface
FLOAT GetSurfaceWidth() const override { return SizeX; }
FLOAT GetSurfaceHeight() const override { return SizeY; }
/**
* @return Width/height this surface was before cooking or other modifications
*/
FLOAT GetOriginalSurfaceWidth() const override { return OriginalSizeX; }
FLOAT GetOriginalSurfaceHeight() const override { return OriginalSizeY; }
// UTexture interface.
FTextureResource* CreateResource() override;
void Compress() override;
EMaterialValueType GetMaterialType() override { return MCT_Texture2D; }
/**
* Scale the actual texture data of the top mip. This allows non-uniform scaling - use with care :)
*/
void ResizeTexture(const FVector2D& Scale);
void ResizeTexture(FLOAT Scale)
{
FVector2D Scale2D(Scale, Scale);
ResizeTexture(Scale2D);
}
/**
* Creates a new resource for the texture, and updates any cached references to the resource.
*/
void UpdateResource() override;
/**
* Used by various commandlets to purge editor only and platform-specific data from various objects
*
* @param PlatformsToKeep Platforms for which to keep platform-specific data
* @param bStripLargeEditorData If TRUE, data used in the editor, but large enough to bloat download sizes, will be removed
*/
void StripData(UE3::EPlatformType PlatformsToKeep, UBOOL bStripLargeEditorData) override;
/**
* Gets the average brightness of the texture in linear space
*
* @param bIgnoreTrueBlack If TRUE, then pixels w/ 0,0,0 rgb values do not contribute.
* @param bUseGrayscale If TRUE, use gray scale else use the max color component.
*
* @return FLOAT The average brightness of the texture
*/
FLOAT GetAverageBrightness(UBOOL bIgnoreTrueBlack, UBOOL bUseGrayscale) override;
// UTexture2D interface.
void Init(UINT InSizeX,UINT InSizeY,EPixelFormat InFormat);
void LegacySerialize(FArchive& Ar);
/**
* return the texture/pixel format that should be used internally for an incoming texture load request, if different onload conversion is required
*
* @param Format source texture format
* @param Platform destination platform, useful during cooking
*/
static EPixelFormat GetEffectivePixelFormat( const EPixelFormat Format, UBOOL bSRGB, UE3::EPlatformType Platform = UE3::PLATFORM_Unknown );
/**
* Returns a one line description of an object for viewing in the thumbnail view of the generic browser
*/
FString GetDesc() override;
/**
* Returns detailed info to populate listview columns
*/
FString GetDetailedDescription( INT InIndex ) override;
/**
* Calculates the size of this texture in bytes if it had MipCount miplevels streamed in.
*
* @param MipCount Number of mips to calculate size for, counting from the smallest 1x1 mip-level and up.
* @return Size of MipCount mips in bytes
*/
INT CalcTextureMemorySize( INT MipCount ) const;
/**
* Calculates the size of this texture if it had MipCount miplevels streamed in.
*
* @param MipCount Which mips to calculate size for.
* @return Total size of all specified mips, in bytes
*/
INT CalcTextureMemorySize( ETextureMipCount MipCount ) const override;
/**
* Returns the size of this texture in bytes on 360 if it had MipCount miplevels streamed in.
*
* @param MipCount Number of toplevel mips to calculate size for
* @return size of top mipcount mips in bytes
*/
INT Get360Size( INT MipCount ) const;
/**
* Get the CRC of the source art pixels.
*
* @param [out] OutSourceCRC The CRC value of the source art pixels.
*
* @return UBOOL TRUE if successful, FALSE if failed (or no source art)
*/
UBOOL GetSourceArtCRC(DWORD& OutSourceCRC);
/**
* Returns whether or not the texture has source art at all
*
* @return TRUE if the texture has source art. FALSE, otherwise.
*/
UBOOL HasSourceArt() const override;
/**
* Compresses the source art, if needed
*/
void CompressSourceArt() override;
/**
* Returns uncompressed source art.
*
* @param OutSourceArt [out]A buffer containing uncompressed source art.
*/
void GetUncompressedSourceArt( TArray<BYTE>& OutSourceArt ) override;
/**
* Sets the given buffer as the uncompressed source art.
*
* @param UncompressedData Uncompressed source art data.
* @param DataSize Size of the UncompressedData.
*/
void SetUncompressedSourceArt( const void* UncompressedData, INT DataSize ) override;
/**
* Sets the given buffer as the compressed source art.
*
* @param CompressedData Compressed source art data.
* @param DataSize Size of the CompressedData.
*/
void SetCompressedSourceArt( const void* CompressedData, INT DataSize ) override;
/**
* See if the source art of the two textures matches...
*
* @param InTexture The texture to compare it to
*
* @return UBOOL TRUE if they matche, FALSE if not
*/
UBOOL HasSameSourceArt(UTexture2D* InTexture);
UBOOL HasAlphaChannel() const
{
return Format == PF_A8R8G8B8 || Format == PF_DXT3 || Format == PF_DXT5;
}
/**
* Returns if the texture should be automatically biased to -1..1 range
*/
UBOOL BiasNormalMap() const;
/**
* Returns whether the texture is ready for streaming aka whether it has had InitRHI called on it.
*
* @return TRUE if initialized and ready for streaming, FALSE otherwise
*/
//@zombie_ps4_begin
FORCEINLINE UBOOL IsReadyForStreaming()
{
// A value < 0 indicates that the resource is still in the process of being created
// for the first time.
return PendingMipChangeRequestStatus.GetValue() != TexState_InProgress_Initialization;
}
//@zombie_ps4_end
/**
* Waits until all streaming requests for this texture has been fully processed.
*/
void WaitForStreaming() override;
/**
* Updates the streaming status of the texture and performs finalization when appropriate. The function returns
* TRUE while there are pending requests in flight and updating needs to continue.
*
* @param bWaitForMipFading Whether to wait for Mip Fading to complete before finalizing.
* @return TRUE if there are requests in flight, FALSE otherwise
*/
UBOOL UpdateStreamingStatus( UBOOL bWaitForMipFading = FALSE ) override;
/**
* Tries to cancel a pending mip change request. Requests cannot be canceled if they are in the
* finalization phase.
*
* @param TRUE if cancelation was successful, FALSE otherwise
*/
UBOOL CancelPendingMipChangeRequest();
/**
* Returns the size of the object/ resource for display to artists/ LDs in the Editor.
*
* @return size of resource as to be displayed to artists/ LDs in the Editor.
*/
INT GetResourceSize() override;
/**
* Returns whether miplevels should be forced resident.
*
* @return TRUE if either transient or serialized override requests miplevels to be resident, FALSE otherwise
*/
UBOOL ShouldMipLevelsBeForcedResident() const;
/**
* Whether all miplevels of this texture have been fully streamed in, LOD settings permitting.
*/
UBOOL IsFullyStreamedIn();
/**
* Returns a reference to the global list of streamable textures.
*
* @return reference to global list of streamable textures.
*/
static TLinkedList<UTexture2D*>*& GetStreamableList();
/**
* Returns a reference to the current streamable link.
*
* @return reference to current streamable link
*/
static TLinkedList<UTexture2D*>*& GetCurrentStreamableLink();
/**
* Links texture to streamable list and updates streamable texture count.
*/
void LinkStreaming();
/**
* Unlinks texture from streamable list, resets CurrentStreamableLink if it matches
* StreamableTexturesLink and also updates the streamable texture count.
*/
void UnlinkStreaming();
/**
* Returns the number of streamable textures, maintained by link/ unlink code
*
* @return Number of streamable textures
*/
static INT GetNumStreamableTextures();
/**
* Cancels any pending texture streaming actions if possible.
* Returns when no more async loading requests are in flight.
*/
static void CancelPendingTextureStreaming();
/**
* Initialize the GPU resource memory that will be used for the bulk mip data
* This memory is allocated based on the SizeX,SizeY of the texture and the first mip used
*
* @param FirstMipIdx first mip that will be resident
* @return FTexture2DResourceMem container for the allocated GPU resource mem
*/
class FTexture2DResourceMem* InitResourceMem(INT FirstMipIdx);
/**
* Calculates and returns the corresponding ResourceMem parameters for this texture.
*
* @param FirstMipIdx Index of the largest mip-level stored within a seekfree (level) package
* @param OutSizeX [out] Width of the stored largest mip-level
* @param OutSizeY [out] Height of the stored largest mip-level
* @param OutNumMips [out] Number of stored mips
* @param OutTexCreateFlags [out] ETextureCreateFlags bit flags
* @return TRUE if the texture should use a ResourceMem. If FALSE, none of the out parameters will be filled in.
*/
UBOOL GetResourceMemSettings(INT FirstMipIdx, INT& OutSizeX, INT& OutSizeY, INT& OutNumMips, DWORD& OutTexCreateFlags);
/**
* Creates a platform-specific ResourceMem. If an AsyncCounter is provided, it will allocate asynchronously.
*
* @param SizeX Width of the stored largest mip-level
* @param SizeY Height of the stored largest mip-level
* @param NumMips Number of stored mips
* @param TexCreateFlags ETextureCreateFlags bit flags
* @param AsyncCounter If specified, starts an async allocation. If NULL, allocates memory immediately.
* @return Platform-specific ResourceMem.
*/
static FTexture2DResourceMem* CreateResourceMem(INT SizeX, INT SizeY, INT NumMips, EPixelFormat Format, DWORD TexCreateFlags, FThreadSafeCounter* AsyncCounter);
#if WITH_EDITOR
/** Recreates system memory data for textures that do not use GPU resources (1 bit textures). Should be called when data in the top level mip changes **/
void UpdateSystemMemoryData();
/**
* Asynchronously update a set of regions of a texture with new data.
* @param MipIndex - the mip number to update
* @param NumRegions - number of regions to update
* @param Regions - regions to update
* @param SrcPitch - the pitch of the source data in bytes
* @param SrcBpp - the size one pixel data in bytes
* @param SrcData - the source data
* @param bFreeData - if TRUE, the SrcData and Regions pointers will be freed after the update.
*/
void UpdateTextureRegions( INT MipIndex, UINT NumRegions, FUpdateTextureRegion2D* Regions, UINT SrcPitch, UINT SrcBpp, BYTE* SrcData, UBOOL bFreeData );
#endif
/** Called after an editor or undo operation is formed on texture
*/
void PostEditUndo() override;
/** Returns system memory data for read only purposes **/
const TArray<BYTE>& AccessSystemMemoryData() const { return SystemMemoryData; }
friend struct FStreamingManagerTexture;
friend struct FStreamingTexture;
}
/** creates and initializes a new Texture2D with the requested settings */
static native noexport final function Texture2D Create(int InSizeX, int InSizeY, optional EPixelFormat InFormat = PF_A8R8G8B8);
defaultproperties
{
StreamingIndex=-1
MipsToRemoveOnCompress=0
bIsEditorOnly=false
}