VTFFile.h

Go to the documentation of this file.

/*
 * VTFLib
 * Copyright (C) 2005-2010 Neil Jedrzejewski & Ryan Gregg

 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later
 * version.
 */

// ============================================================
// NOTE: This file is commented for compatibility with Doxygen.
// ============================================================
#ifndef VTFLIB_VTFFILE_H
#define VTFLIB_VTFFILE_H

#include "stdafx.h"
#include "Readers.h"
#include "Writers.h"
#include "VTFFormat.h"

#ifdef __cplusplus
extern "C" {
#endif


#pragma pack(1)
typedef struct tagSVTFImageFormatInfo
{
    const vlChar *lpName;           
    vlUInt  uiBitsPerPixel;         
    vlUInt  uiBytesPerPixel;        
    vlUInt  uiRedBitsPerPixel;      
    vlUInt  uiGreenBitsPerPixel;    
    vlUInt  uiBlueBitsPerPixel;     
    vlUInt  uiAlphaBitsPerPixel;    
    vlBool  bIsCompressed;          
    vlBool  bIsSupported;           
} SVTFImageFormatInfo;
#pragma pack()


#pragma pack(1)
typedef struct tagSVTFCreateOptions
{
    vlUInt uiVersion[2];                                
    VTFImageFormat ImageFormat;                         

    vlUInt uiFlags;                                     
    vlUInt uiStartFrame;                                
    vlSingle sBumpScale;                                
    vlSingle sReflectivity[3];                          

    vlBool bMipmaps;                                    
    VTFMipmapFilter MipmapFilter;                       
    VTFSharpenFilter MipmapSharpenFilter;               

    vlBool bThumbnail;                                  
    vlBool bReflectivity;                               

    vlBool bResize;                                     
    VTFResizeMethod ResizeMethod;                       
    VTFMipmapFilter ResizeFilter;                       
    VTFSharpenFilter ResizeSharpenFilter;               
    vlUInt uiResizeWidth;                               
    vlUInt uiResizeHeight;                              

    vlBool bResizeClamp;                                
    vlUInt uiResizeClampWidth;                          
    vlUInt uiResizeClampHeight;                         

    vlBool bGammaCorrection;                            
    vlSingle sGammaCorrection;                          

    vlBool bNormalMap;                                  
    VTFKernelFilter KernelFilter;                       
    VTFHeightConversionMethod HeightConversionMethod;   
    VTFNormalAlphaResult NormalAlphaResult;             
    vlByte bNormalMinimumZ;                             
    vlSingle sNormalScale;                              
    vlBool bNormalWrap;                                 
    vlBool bNormalInvertX;                              
    vlBool bNormalInvertY;                              
    vlBool bNormalInvertZ;                              

    vlBool bSphereMap;                                  
} SVTFCreateOptions;
#pragma pack()

#ifdef __cplusplus
}
#endif

namespace VTFLib
{

    class VTFLIB_API CVTFFile
    {
    private:

        SVTFHeader *Header;                     // VTF header
    
        vlUInt uiImageBufferSize;               // Size of VTF image data buffer
        vlByte *lpImageData;                    // VTF image buffer

        vlUInt uiThumbnailBufferSize;           // Size of VTF thumbnail image data buffer
        vlByte *lpThumbnailImageData;           // VTF thumbnail image buffer

    public:

        CVTFFile();     


        CVTFFile(const CVTFFile &VTFFile);


        CVTFFile(const CVTFFile &VTFFile, VTFImageFormat ImageFormat);

        ~CVTFFile();    

    public:
        

        vlBool Create(vlUInt uiWidth, vlUInt uiHeight, vlUInt uiFrames = 1, vlUInt uiFaces = 1, vlUInt uiSlices = 1, VTFImageFormat ImageFormat = IMAGE_FORMAT_RGBA8888, vlBool bThumbnail = vlTrue, vlBool bMipmaps = vlTrue, vlBool bNullImageData = vlFalse);
        

        vlBool Create(vlUInt uiWidth, vlUInt uiHeight, vlByte *lpImageDataRGBA8888, const SVTFCreateOptions &VTFCreateOptions);


        vlBool Create(vlUInt uiWidth, vlUInt uiHeight, vlUInt uiFrames, vlUInt uiFaces, vlUInt vlSlices, vlByte **lpImageDataRGBA8888, const SVTFCreateOptions &VTFCreateOptions);
        
        vlVoid Destroy();


        vlBool IsLoaded() const;


        vlBool Load(const vlChar *cFileName, vlBool bHeaderOnly = vlFalse);


        vlBool Load(const vlVoid *lpData, vlSize uiBufferSize, vlBool bHeaderOnly = vlFalse);


        vlBool Load(vlVoid *pUserData, vlBool bHeaderOnly = vlFalse);


        vlBool Save(const vlChar *cFileName) const;


        vlBool Save(vlVoid *lpData, vlSize uiBufferSize, vlSize &uiSize) const;


        vlBool Save(vlVoid *pUserData) const;

    private:
        vlBool IsPowerOfTwo(vlUInt uiSize);
        vlUInt NextPowerOfTwo(vlUInt uiSize);

        vlVoid ComputeResources();   

        // Interface with out reader/writer classes
        vlBool Load(IO::Readers::IReader *Reader, vlBool bHeaderOnly);
        vlBool Save(IO::Writers::IWriter *Writer) const;

    public:


        vlBool GetHasImage() const;

        vlUInt GetMajorVersion() const;  
        vlUInt GetMinorVersion() const;  
        vlUInt GetSize() const;          

        vlUInt GetWidth() const;    
        vlUInt GetHeight() const;   
        vlUInt GetDepth() const;    

        vlUInt GetFrameCount() const;   
        vlUInt GetFaceCount() const;    
        vlUInt GetMipmapCount() const;  

        vlUInt GetStartFrame() const;               
        vlVoid SetStartFrame(vlUInt uiStartFrame);  

        vlUInt GetFlags() const;    
        vlVoid SetFlags(vlUInt uiFlags);    


        vlBool GetFlag(VTFImageFlag ImageFlag) const;


        vlVoid SetFlag(VTFImageFlag ImageFlag, vlBool bState);

        vlSingle GetBumpmapScale() const;   
        

        vlVoid SetBumpmapScale(vlSingle sBumpmapScale);


        vlVoid GetReflectivity(vlSingle &sX, vlSingle &sY, vlSingle &sZ) const;


        vlVoid SetReflectivity(vlSingle sX, vlSingle sY, vlSingle sZ);

        VTFImageFormat GetFormat() const;   
        

        vlByte *GetData(vlUInt uiFrame, vlUInt uiFace, vlUInt uiSlice, vlUInt uiMipmapLevel) const;
        

        vlVoid SetData(vlUInt uiFrame, vlUInt uiFace, vlUInt uiSlice, vlUInt uiMipmapLevel, vlByte *lpData);

    public:
        
        vlBool GetHasThumbnail() const;     

        vlUInt GetThumbnailWidth() const;   
        vlUInt GetThumbnailHeight() const;  

        VTFImageFormat GetThumbnailFormat() const;  


        vlByte *GetThumbnailData() const;


        vlVoid SetThumbnailData(vlByte *lpData);

    public:
        vlBool GetSupportsResources() const;            

        vlUInt GetResourceCount() const;                
        vlUInt GetResourceType(vlUInt uiIndex) const;   
        vlBool GetHasResource(vlUInt uiType) const;     


        vlVoid *GetResourceData(vlUInt uiType, vlUInt &uiSize) const;


        vlVoid *SetResourceData(vlUInt uiType, vlUInt uiSize, vlVoid *lpData);

    public:


        vlBool GenerateMipmaps(VTFMipmapFilter MipmapFilter = MIPMAP_FILTER_BOX, VTFSharpenFilter SharpenFilter = SHARPEN_FILTER_NONE);


        vlBool GenerateMipmaps(vlUInt uiFace, vlUInt uiFrame, VTFMipmapFilter MipmapFilter = MIPMAP_FILTER_BOX, VTFSharpenFilter SharpenFilter = SHARPEN_FILTER_NONE);


        vlBool GenerateThumbnail();


        vlBool GenerateNormalMap(VTFKernelFilter KernelFilter = KERNEL_FILTER_3X3, VTFHeightConversionMethod HeightConversionMethod = HEIGHT_CONVERSION_METHOD_AVERAGE_RGB, VTFNormalAlphaResult NormalAlphaResult = NORMAL_ALPHA_RESULT_WHITE);
        

        vlBool GenerateNormalMap(vlUInt uiFrame, VTFKernelFilter KernelFilter = KERNEL_FILTER_3X3, VTFHeightConversionMethod HeightConversionMethod = HEIGHT_CONVERSION_METHOD_AVERAGE_RGB, VTFNormalAlphaResult NormalAlphaResult = NORMAL_ALPHA_RESULT_WHITE);

        vlBool GenerateSphereMap();     

    public:

        vlBool ComputeReflectivity();   
    
    public:


        static SVTFImageFormatInfo const &GetImageFormatInfo(VTFImageFormat ImageFormat);


        static vlUInt ComputeImageSize(vlUInt uiWidth, vlUInt uiHeight, vlUInt uiDepth, VTFImageFormat ImageFormat);


        static vlUInt ComputeImageSize(vlUInt uiWidth, vlUInt uiHeight, vlUInt uiDepth, vlUInt uiMipmaps, VTFImageFormat ImageFormat);


        static vlUInt ComputeMipmapCount(vlUInt uiWidth, vlUInt uiHeight, vlUInt uiDepth);  


        static vlVoid ComputeMipmapDimensions(vlUInt uiWidth, vlUInt uiHeight, vlUInt uiDepth, vlUInt uiMipmapLevel, vlUInt &uiMipmapWidth, vlUInt &uiMipmapHeight, vlUInt &uiMipmapDepth);
        

        static vlUInt ComputeMipmapSize(vlUInt uiWidth, vlUInt uiHeight, vlUInt uiDepth, vlUInt uiMipmapLevel, VTFImageFormat ImageFormat);

    private:

        // Calculates where in the VTF image the data begins
        vlUInt ComputeDataOffset(vlUInt uiFrame, vlUInt uiFace, vlUInt uiSlice, vlUInt uiMipmapLevel, VTFImageFormat ImageFormat) const;

    public:


        static vlBool ConvertToRGBA8888(const vlByte *lpSource, vlByte *lpDest, vlUInt uiWidth, vlUInt uiHeight, VTFImageFormat SourceFormat);


        static vlBool ConvertFromRGBA8888(const vlByte *lpSource, vlByte *lpDest, vlUInt uiWidth, vlUInt uiHeight, VTFImageFormat DestFormat);


        static vlBool Convert(const vlByte *lpSource, vlByte *lpDest, vlUInt uiWidth, vlUInt uiHeight, VTFImageFormat SourceFormat, VTFImageFormat DestFormat);


        static vlBool ConvertToNormalMap(const vlByte *lpSourceRGBA8888, vlByte *lpDestRGBA8888, vlUInt uiWidth, vlUInt uiHeight, VTFKernelFilter KernelFilter = KERNEL_FILTER_3X3, VTFHeightConversionMethod HeightConversionMethod = HEIGHT_CONVERSION_METHOD_AVERAGE_RGB, VTFNormalAlphaResult NormalAlphaResult = NORMAL_ALPHA_RESULT_WHITE, vlByte bMinimumZ = 0, vlSingle sScale = 2.0f, vlBool bWrap = vlFalse, vlBool bInvertX = vlFalse, vlBool bInvertY = vlFalse, vlBool bInvertZ = vlFalse);


        static vlBool Resize(const vlByte *lpSourceRGBA8888, vlByte *lpDestRGBA8888, vlUInt uiSourceWidth, vlUInt uiSourceHeight, vlUInt uiDestWidth, vlUInt uiDestHeight, VTFMipmapFilter ResizeFilter = MIPMAP_FILTER_TRIANGLE, VTFSharpenFilter SharpenFilter = SHARPEN_FILTER_NONE);

    private:
        
        // DXTn format decompression functions
        static vlBool DecompressDXT1(const vlByte *src, vlByte *dst, vlUInt uiWidth, vlUInt uiHeight);
        static vlBool DecompressDXT3(const vlByte *src, vlByte *dst, vlUInt uiWidth, vlUInt uiHeight);
        static vlBool DecompressDXT5(const vlByte *src, vlByte *dst, vlUInt uiWidth, vlUInt uiHeight);

        // DXTn format compression function
        static vlBool CompressDXTn(const vlByte *lpSource, vlByte *lpDest, vlUInt uiWidth, vlUInt uiHeight, VTFImageFormat DestFormat);

    public:


        static vlVoid CorrectImageGamma(vlByte *lpImageDataRGBA8888, vlUInt uiWidth, vlUInt uiHeight, vlSingle sGammaCorrection);


        static vlVoid ComputeImageReflectivity(const vlByte *lpImageDataRGBA8888, vlUInt uiWidth, vlUInt uiHeight, vlSingle &sX, vlSingle &sY, vlSingle &sZ);

        static vlVoid FlipImage(vlByte *lpImageDataRGBA8888, vlUInt uiWidth, vlUInt uiHeight);      
        static vlVoid MirrorImage(vlByte *lpImageDataRGBA8888, vlUInt uiWidth, vlUInt uiHeight);    
    };
}

#endif