UE4 FColor数据保存成图片

1、TArray<FColor>或是FColor*可通过ImageWrapper直接保存成图片

void URenderCineCameraLibrary::SaveColorToFile(FColor* SourceColor, uint32 Width, uint32 Height)
{
    check(SourceColor != nullptr);
    
    /*// FColor* SurfaceColor ...png
    for (FColor& Color : SurfaceColor)
    {
        Color.A = 255;
    }

    TArray<uint8> TextureData;
    TextureData.AddUninitialized(Width * Height * sizeof(FColor));
    FMemory::Memcpy(TextureData.GetData(), (uint8*)SourceColor, Width * Height * sizeof(FColor));
    if (TextureData.Num() <= 0)
    {
        UE_LOG(LogTemp, Error, TEXT("TextureData is empty ..."));
        return;
    }*/

    // save png
    IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
    TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::JPEG);
    ImageWrapper->SetRaw(SourceColor, Width * Height * sizeof(FColor), Width, Height, ERGBFormat::BGRA, 8);
    

    const TArray64<uint8>& PNGData = ImageWrapper->GetCompressed(100);

    FString FileName = TEXT("D:\\CineCapture1.jpg");
    FFileHelper::SaveArrayToFile(PNGData, *FileName);
    ImageWrapper.Reset();
}

 

2、将UTexture2D保存成图片

void URenderCineCameraLibrary::SaveTextureToFile(UTexture2D* SourceTex)
{
    check(SourceTex);
    int32 Width = SourceTex->GetSizeX();
    int32 Height = SourceTex->GetSizeY();

    FTexture2DMipMap& MipMap = SourceTex->GetPlatformData()->Mips[0];
    void* Data = MipMap.BulkData.Lock(LOCK_READ_ONLY);

    TArray<uint8> TextureData;
    TextureData.AddUninitialized(Width * Height * sizeof(FColor));
    FMemory::Memcpy(TextureData.GetData(), (uint8*)Data, Width * Height * sizeof(FColor));
    if (TextureData.Num() <= 0)
    {
        UE_LOG(LogTemp, Error, TEXT("TextureData is empty ..."));
        return;
    }

    // save png
    IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
    TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::JPEG);
    ImageWrapper->SetRaw(TextureData.GetData(), Width * Height * sizeof(FColor), Width, Height, ERGBFormat::BGRA, 8);


    const TArray64<uint8>& PNGData = ImageWrapper->GetCompressed(100);

    FString FileName = TEXT("D:\\CineTexture.jpg");
    FFileHelper::SaveArrayToFile(PNGData, *FileName);
    ImageWrapper.Reset();
    

    MipMap.BulkData.Unlock();
}

 

3、创建UTextureRenderTarget2D、设置及保存为图片

void URenderCineCameraLibrary::ConstructRT2D()
{
    if (m_CineTexRT2D == nullptr)
    {
        m_CineTexRT2D = NewObject<UTextureRenderTarget2D>();
        m_CineTexRT2D->AddToRoot();
        m_CineTexRT2D->ClearColor = FLinearColor::Transparent;
        m_CineTexRT2D->TargetGamma = 0.f;
        m_CineTexRT2D->InitCustomFormat(/*m_CaptureViewport->m_ViewportX*/1920, /*m_CaptureViewport->m_ViewportY*/1080, PF_B8G8R8A8, false);
    }    

    check(GCineWorld != nullptr);
    check(m_CineCamTex != nullptr);
    CopyTextureToRenderTargetTexture(m_CineCamTex, m_CineTexRT2D, GCineWorld->FeatureLevel);

// save 
    //SaveRenderTargetToFile(m_CineTexRT2D, TEXT("D:\\RT_Cine.jpg"));
}

//

void URenderCineCameraLibrary::CopyTextureToRenderTargetTexture(UTexture* SourceTexture, UTextureRenderTarget2D* RenderTargetTexture, ERHIFeatureLevel::Type FeatureLevel)
{
    check(SourceTexture != nullptr);
    check(RenderTargetTexture != nullptr);

    // Grab the actual render target resource from the texture.  Note that we're absolutely NOT ALLOWED to
    // dereference this pointer.  We're just passing it along to other functions that will use it on the render
    // thread.  The only thing we're allowed to do is check to see if it's nullptr or not.
    FTextureRenderTargetResource* RenderTargetResource = RenderTargetTexture->GameThread_GetRenderTargetResource();
    check(RenderTargetResource != nullptr);

    // Create a canvas for the render target and clear it to black
    FCanvas Canvas(RenderTargetResource, nullptr, FGameTime(), FeatureLevel);

    const uint32 Width = RenderTargetTexture->GetSurfaceWidth();
    const uint32 Height = RenderTargetTexture->GetSurfaceHeight();

    // @todo MeshPaint: Need full color/alpha writes enabled to get alpha
    // @todo MeshPaint: Texels need to line up perfectly to avoid bilinear artifacts
    // @todo MeshPaint: Potential gamma issues here
    // @todo MeshPaint: Probably using CLAMP address mode when reading from source (if texels line up, shouldn't matter though.)

    // @todo MeshPaint: Should use scratch texture built from original source art (when possible!)
    //        -> Current method will have compression artifacts!

    // Grab the texture resource.  We only support 2D textures and render target textures here.
    FTexture* TextureResource = nullptr;
    UTexture2D* Texture2D = Cast<UTexture2D>(SourceTexture);
    if (Texture2D != nullptr)
    {
        TextureResource = Texture2D->GetResource();
    }
    else
    {
        UTextureRenderTarget2D* TextureRenderTarget2D = Cast<UTextureRenderTarget2D>(SourceTexture);
        TextureResource = TextureRenderTarget2D->GameThread_GetRenderTargetResource();
    }
    check(TextureResource != nullptr);

    // Draw a quad to copy the texture over to the render target
    {
        const float MinU = 0.0f;
        const float MinV = 0.0f;
        const float MaxU = 1.0f;
        const float MaxV = 1.0f;
        const float MinX = 0.0f;
        const float MinY = 0.0f;
        const float MaxX = Width;
        const float MaxY = Height;

        FCanvasUVTri Tri1;
        FCanvasUVTri Tri2;
        Tri1.V0_Pos = FVector2D(MinX, MinY);
        Tri1.V0_UV = FVector2D(MinU, MinV);
        Tri1.V1_Pos = FVector2D(MaxX, MinY);
        Tri1.V1_UV = FVector2D(MaxU, MinV);
        Tri1.V2_Pos = FVector2D(MaxX, MaxY);
        Tri1.V2_UV = FVector2D(MaxU, MaxV);

        Tri2.V0_Pos = FVector2D(MaxX, MaxY);
        Tri2.V0_UV = FVector2D(MaxU, MaxV);
        Tri2.V1_Pos = FVector2D(MinX, MaxY);
        Tri2.V1_UV = FVector2D(MinU, MaxV);
        Tri2.V2_Pos = FVector2D(MinX, MinY);
        Tri2.V2_UV = FVector2D(MinU, MinV);
        Tri1.V0_Color = Tri1.V1_Color = Tri1.V2_Color = Tri2.V0_Color = Tri2.V1_Color = Tri2.V2_Color = FLinearColor::White;
        TArray< FCanvasUVTri > List;
        List.Add(Tri1);
        List.Add(Tri2);
        FCanvasTriangleItem TriItem(List, TextureResource);
        TriItem.BlendMode = SE_BLEND_Opaque;
        Canvas.DrawItem(TriItem);
    }

    // Tell the rendering thread to draw any remaining batched elements
    Canvas.Flush_GameThread(true);

    ENQUEUE_RENDER_COMMAND(UpdateMeshPaintRTCommand)(
        [RenderTargetResource](FRHICommandListImmediate& RHICmdList)
        {
            // Copy (resolve) the rendered image from the frame buffer to its render target texture
            RHICmdList.CopyToResolveTarget(
                RenderTargetResource->GetRenderTargetTexture(),        // Source texture
                RenderTargetResource->TextureRHI,                    // Dest texture
                FResolveParams());                                    // Resolve parameters
        });
}

//
bool URenderCineCameraLibrary::SaveRenderTargetToFile(UTextureRenderTarget2D* rt, const FString& fileDestination)
{
    FTextureRenderTargetResource* rtResource = rt->GameThread_GetRenderTargetResource();
    FReadSurfaceDataFlags readPixelFlags(RCM_UNorm);

    TArray<FColor> outBMP;
    outBMP.AddUninitialized(rt->GetSurfaceWidth() * rt->GetSurfaceHeight());
    rtResource->ReadPixels(outBMP, readPixelFlags);


    IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
    TSharedPtr<IImageWrapper> ImageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::JPEG);
    ImageWrapper->SetRaw(outBMP.GetData(), outBMP.GetAllocatedSize(), rt->GetSurfaceWidth(), rt->GetSurfaceHeight(), ERGBFormat::BGRA, 8);

    const TArray64<uint8>& PNGData = ImageWrapper->GetCompressed(100);
    bool imageSavedOk = FFileHelper::SaveArrayToFile(PNGData, *fileDestination);
    ImageWrapper.Reset();


    /*FIntPoint destSize(rt->GetSurfaceWidth(), rt->GetSurfaceHeight());
    TArray<uint8> CompressedBitmap;
    FImageUtils::CompressImageArray(destSize.X, destSize.Y, outBMP, CompressedBitmap);
    bool imageSavedOk = FFileHelper::SaveArrayToFile(CompressedBitmap, *fileDestination);*/

    return imageSavedOk;
}