path: root/indra/llmeshoptimizer/llmeshoptimizer.cpp

 /** 
* @file llmeshoptimizer.cpp
* @brief Wrapper around meshoptimizer
*
* $LicenseInfo:firstyear=2021&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2021, Linden Research, Inc.
* 
* 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;
* version 2.1 of the License only.
* 
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
* 
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* 
* Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
* $/LicenseInfo$
*/

#include "llmeshoptimizer.h"

#include "meshoptimizer.h"

#include "llmath.h"
#include "v2math.h"

LLMeshOptimizer::LLMeshOptimizer()
{
    // Todo: Looks like for memory management, we can add allocator and deallocator callbacks
    // Should be one time
    // meshopt_setAllocator(allocate, deallocate);
}

LLMeshOptimizer::~LLMeshOptimizer()
{
}

//static
void LLMeshOptimizer::generateShadowIndexBufferU32(U32 *destination,
    const U32 *indices,
    U64 index_count,
    const LLVector4a * vertex_positions,
    const LLVector4a * normals,
    const LLVector2 * text_coords,
    U64 vertex_count
)
{
    meshopt_Stream streams[3];

    S32 index = 0;
    if (vertex_positions)
    {
        streams[index].data = (const float*)vertex_positions;
        // Despite being LLVector4a, only x, y and z are in use
        streams[index].size = sizeof(F32) * 3;
        streams[index].stride = sizeof(F32) * 4;
        index++;
    }
    if (normals)
    {
        streams[index].data = (const float*)normals;
        streams[index].size = sizeof(F32) * 3;
        streams[index].stride = sizeof(F32) * 4;
        index++;
    }
    if (text_coords)
    {
        streams[index].data = (const float*)text_coords;
        streams[index].size = sizeof(F32) * 2;
        streams[index].stride = sizeof(F32) * 2;
        index++;
    }

    if (index == 0)
    {
        // invalid
        return;
    }

    meshopt_generateShadowIndexBufferMulti<unsigned int>(destination,
        indices,
        index_count,
        vertex_count,
        streams,
        index
        );
}

//static
void LLMeshOptimizer::generateShadowIndexBufferU16(U16 *destination,
    const U16 *indices,
    U64 index_count,
    const LLVector4a * vertex_positions,
    const LLVector4a * normals,
    const LLVector2 * text_coords,
    U64 vertex_count
)
{
    meshopt_Stream streams[3];

    S32 index = 0;
    if (vertex_positions)
    {
        streams[index].data = (const float*)vertex_positions;
        streams[index].size = sizeof(F32) * 3;
        streams[index].stride = sizeof(F32) * 4;
        index++;
    }
    if (normals)
    {
        streams[index].data = (const float*)normals;
        streams[index].size = sizeof(F32) * 3;
        streams[index].stride = sizeof(F32) * 4;
        index++;
    }
    if (text_coords)
    {
        streams[index].data = (const float*)text_coords;
        streams[index].size = sizeof(F32) * 2;
        streams[index].stride = sizeof(F32) * 2;
        index++;
    }

    if (index == 0)
    {
        // invalid
        return;
    }

    meshopt_generateShadowIndexBufferMulti<unsigned short>(destination,
        indices,
        index_count,
        vertex_count,
        streams,
        index);
}

void LLMeshOptimizer::optimizeVertexCacheU32(U32 * destination, const U32 * indices, U64 index_count, U64 vertex_count)
{
    meshopt_optimizeVertexCache<unsigned int>(destination, indices, index_count, vertex_count);
}

void LLMeshOptimizer::optimizeVertexCacheU16(U16 * destination, const U16 * indices, U64 index_count, U64 vertex_count)
{
    meshopt_optimizeVertexCache<unsigned short>(destination, indices, index_count, vertex_count);
}

size_t LLMeshOptimizer::generateRemapMultiU32(
    unsigned int* remap,
    const U32 * indices,
    U64 index_count,
    const LLVector4a * vertex_positions,
    const LLVector4a * normals,
    const LLVector2 * text_coords,
    U64 vertex_count)
{
    meshopt_Stream streams[] = {
       {(const float*)vertex_positions, sizeof(F32) * 3, sizeof(F32) * 4},
       {(const float*)normals, sizeof(F32) * 3, sizeof(F32) * 4},
       {(const float*)text_coords, sizeof(F32) * 2, sizeof(F32) * 2},
    };

    // Remap can function without indices,
    // but providing indices helps with removing unused vertices
    U64 indeces_cmp = indices ? index_count : vertex_count;

    // meshopt_generateVertexRemapMulti will throw an assert if (indices[i] >= vertex_count)
    return meshopt_generateVertexRemapMulti(&remap[0], indices, indeces_cmp, vertex_count, streams, sizeof(streams) / sizeof(streams[0]));
}

size_t LLMeshOptimizer::generateRemapMultiU16(
    unsigned int* remap,
    const U16 * indices,
    U64 index_count,
    const LLVector4a * vertex_positions,
    const LLVector4a * normals,
    const LLVector2 * text_coords,
    U64 vertex_count)
{
    S32 out_of_range_count = 0;
    U32* indices_u32 = NULL;
    if (indices)
    {
        indices_u32 = (U32*)ll_aligned_malloc_32(index_count * sizeof(U32));
        for (U64 i = 0; i < index_count; i++)
        {
            if (indices[i] < vertex_count)
            {
                indices_u32[i] = (U32)indices[i];
            }
            else
            {
                out_of_range_count++;
                indices_u32[i] = 0;
            }
        }
    }

    if (out_of_range_count)
    {
        LL_WARNS() << out_of_range_count << " indices are out of range." << LL_ENDL;
    }

    size_t unique = generateRemapMultiU32(remap, indices_u32, index_count, vertex_positions, normals, text_coords, vertex_count);

    ll_aligned_free_32(indices_u32);

    return unique;
}

void LLMeshOptimizer::remapIndexBufferU32(U32 * destination_indices,
    const U32 * indices,
    U64 index_count,
    const unsigned int* remap)
{
    meshopt_remapIndexBuffer<unsigned int>(destination_indices, indices, index_count, remap);
}

void LLMeshOptimizer::remapIndexBufferU16(U16 * destination_indices,
    const U16 * indices,
    U64 index_count,
    const unsigned int* remap)
{
    meshopt_remapIndexBuffer<unsigned short>(destination_indices, indices, index_count, remap);
}

void LLMeshOptimizer::remapPositionsBuffer(LLVector4a * destination_vertices,
    const LLVector4a * vertex_positions,
    U64 vertex_count,
    const unsigned int* remap)
{
    meshopt_remapVertexBuffer((float*)destination_vertices, (const float*)vertex_positions, vertex_count, sizeof(LLVector4a), remap);
}

void LLMeshOptimizer::remapNormalsBuffer(LLVector4a * destination_normalss,
    const LLVector4a * normals,
    U64 mormals_count,
    const unsigned int* remap)
{
    meshopt_remapVertexBuffer((float*)destination_normalss, (const float*)normals, mormals_count, sizeof(LLVector4a), remap);
}

void LLMeshOptimizer::remapUVBuffer(LLVector2 * destination_uvs,
    const LLVector2 * uv_positions,
    U64 uv_count,
    const unsigned int* remap)
{
    meshopt_remapVertexBuffer((float*)destination_uvs, (const float*)uv_positions, uv_count, sizeof(LLVector2), remap);
}

//static
U64 LLMeshOptimizer::simplifyU32(U32 *destination,
    const U32 *indices,
    U64 index_count,
    const LLVector4a *vertex_positions,
    U64 vertex_count,
    U64 vertex_positions_stride,
    U64 target_index_count,
    F32 target_error,
    bool sloppy,
    F32* result_error
)
{
    if (sloppy)
    {
        return meshopt_simplifySloppy<unsigned int>(destination,
            indices,
            index_count,
            (const float*)vertex_positions,
            vertex_count,
            vertex_positions_stride,
            target_index_count,
            target_error,
            result_error
            );
    }
    else
    {
        return meshopt_simplify<unsigned int>(destination,
            indices,
            index_count,
            (const float*)vertex_positions,
            vertex_count,
            vertex_positions_stride,
            target_index_count,
            target_error,
#if MESHOPTIMIZER_VERSION >= 180
            0,
#endif
            result_error
            );
    }
}

//static
U64 LLMeshOptimizer::simplify(U16 *destination,
                              const U16 *indices,
                              U64 index_count,
                              const LLVector4a *vertex_positions,
                              U64 vertex_count,
                              U64 vertex_positions_stride,
                              U64 target_index_count,
                              F32 target_error,
                              bool sloppy,
                              F32* result_error
    )
{
    if (sloppy)
    {
        return meshopt_simplifySloppy<unsigned short>(destination,
            indices,
            index_count,
            (const float*)vertex_positions,
            vertex_count,
            vertex_positions_stride,
            target_index_count,
            target_error,
            result_error
            );
    }
    else
    {
        return meshopt_simplify<unsigned short>(destination,
            indices,
            index_count,
            (const float*)vertex_positions,
            vertex_count,
            vertex_positions_stride,
            target_index_count,
            target_error,
#if MESHOPTIMIZER_VERSION >= 180
            0,
#endif
            result_error
            );
    }
}