RenderDataFormat.h

//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2018 NVIDIA Corporation. All rights reserved.



#ifndef RENDER_DATA_FORMAT_H
#define RENDER_DATA_FORMAT_H

#include "ApexUsingNamespace.h"
#include "foundation/PxAssert.h"
#include "foundation/PxMat44.h"

namespace nvidia
{
namespace apex
{

PX_PUSH_PACK_DEFAULT

struct RenderDataFormat
{
    enum Enum
    {
        UNSPECIFIED =           0,  

        UBYTE1 =                1,  
        UBYTE2 =                2,  
        UBYTE3 =                3,  
        UBYTE4 =                4,  

        USHORT1 =               5,  
        USHORT2 =               6,  
        USHORT3 =               7,  
        USHORT4 =               8,  

        SHORT1 =                9,  
        SHORT2 =                10, 
        SHORT3 =                11, 
        SHORT4 =                12, 

        UINT1 =                 13, 
        UINT2 =                 14, 
        UINT3 =                 15, 
        UINT4 =                 16, 

        R8G8B8A8 =              17, 
        B8G8R8A8 =              18, 
        R32G32B32A32_FLOAT =    19, 
        B32G32R32A32_FLOAT =    20, 

        BYTE_UNORM1 =           21, 
        BYTE_UNORM2 =           22, 
        BYTE_UNORM3 =           23, 
        BYTE_UNORM4 =           24, 

        SHORT_UNORM1 =          25, 
        SHORT_UNORM2 =          26, 
        SHORT_UNORM3 =          27, 
        SHORT_UNORM4 =          28, 

        BYTE_SNORM1 =           29, 
        BYTE_SNORM2 =           30, 
        BYTE_SNORM3 =           31, 
        BYTE_SNORM4 =           32, 

        SHORT_SNORM1 =          33, 
        SHORT_SNORM2 =          34, 
        SHORT_SNORM3 =          35, 
        SHORT_SNORM4 =          36, 

        HALF1 =                 37, 
        HALF2 =                 38, 
        HALF3 =                 39, 
        HALF4 =                 40, 

        FLOAT1 =                41, 
        FLOAT2 =                42, 
        FLOAT3 =                43, 
        FLOAT4 =                44, 

        FLOAT4x4 =              45, 
        FLOAT3x4 =              46, 
        FLOAT3x3 =              47, 

        FLOAT4_QUAT =           48, 
        BYTE_SNORM4_QUATXYZW =  49, 
        SHORT_SNORM4_QUATXYZW = 50, 

        NUM_FORMATS
    };

    static PX_INLINE uint32_t getFormatDataSize(Enum format)
    {
        switch (format)
        {
        default:
            PX_ALWAYS_ASSERT();
        case UNSPECIFIED:
            return 0;

        case UBYTE1:
        case BYTE_UNORM1:
        case BYTE_SNORM1:
            return sizeof(uint8_t);
        case UBYTE2:
        case BYTE_UNORM2:
        case BYTE_SNORM2:
            return sizeof(uint8_t) * 2;
        case UBYTE3:
        case BYTE_UNORM3:
        case BYTE_SNORM3:
            return sizeof(uint8_t) * 3;
        case UBYTE4:
        case BYTE_UNORM4:
        case BYTE_SNORM4:
        case BYTE_SNORM4_QUATXYZW:
            return sizeof(uint8_t) * 4;

        case USHORT1:
        case SHORT1:
        case HALF1:
        case SHORT_UNORM1:
        case SHORT_SNORM1:
            return sizeof(uint16_t);
        case USHORT2:
        case SHORT2:
        case HALF2:
        case SHORT_UNORM2:
        case SHORT_SNORM2:
            return sizeof(uint16_t) * 2;
        case USHORT3:
        case SHORT3:
        case HALF3:
        case SHORT_UNORM3:
        case SHORT_SNORM3:
            return sizeof(uint16_t) * 3;
        case USHORT4:
        case SHORT4:
        case HALF4:
        case SHORT_UNORM4:
        case SHORT_SNORM4:
        case SHORT_SNORM4_QUATXYZW:
            return sizeof(uint16_t) * 4;

        case UINT1:
            return sizeof(uint32_t);
        case UINT2:
            return sizeof(uint32_t) * 2;
        case UINT3:
            return sizeof(uint32_t) * 3;
        case UINT4:
            return sizeof(uint32_t) * 4;

        case R8G8B8A8:
        case B8G8R8A8:
            return sizeof(uint8_t) * 4;

        case R32G32B32A32_FLOAT:
        case B32G32R32A32_FLOAT:
            return sizeof(float) * 4;

        case FLOAT1:
            return sizeof(float);
        case FLOAT2:
            return sizeof(float) * 2;
        case FLOAT3:
            return sizeof(float) * 3;
        case FLOAT4:
            return sizeof(float) * 4;

        case FLOAT4x4:
            return sizeof(PxMat44);

        case FLOAT3x4:
            return sizeof(float) * 12;

        case FLOAT3x3:
            return sizeof(PxMat33);

        case FLOAT4_QUAT:
            return sizeof(PxQuat);
        }
    }
};

PX_POP_PACK

}
} // end namespace nvidia::apex

#endif  // RENDER_DATA_FORMAT_H