dna::LODMapping Class Reference

#include <LODMapping.h>

Inheritance diagram for dna::LODMapping:

Collaboration diagram for dna::LODMapping:

Public Member Functions
	LODMapping (MemoryResource *memRes_)
std::uint16_t	getLODCount () const
void	resetIndices ()
void	resetLODs ()
void	reset ()
void	setLODCount (std::uint16_t lodCount)
void	discardLODs (const LODConstraint &lodConstraint)
ConstArrayView< std::uint16_t >	getIndices (std::uint16_t lod) const
std::uint16_t	getIndexListCount () const
void	clearIndices (std::uint16_t index)
void	addIndices (std::uint16_t index, const std::uint16_t *source, std::uint16_t count)
void	associateLODWithIndices (std::uint16_t lod, std::uint16_t index)
void	mapIndices (std::function< std::uint16_t(std::uint16_t)> mapper)
void	filterIndices (std::function< bool(std::uint16_t)> filterer)
UnorderedSet< std::uint16_t >	getCombinedDistinctIndices (MemoryResource *memRes) const

Protected Attributes
Vector< std::uint16_t >	lods
Matrix< std::uint16_t >	indices

Private Member Functions
void	cleanupIndices ()

Constructor & Destructor Documentation

LODMapping()

dna::LODMapping::LODMapping ( MemoryResource *  memRes_ )

explicit

                                              :
    lods{memRes_},
    indices{memRes_} {
}

Member Function Documentation

addIndices()

void dna::LODMapping::addIndices	(	std::uint16_t	index,
		const std::uint16_t *	source,
		std::uint16_t	count
	)

                                                                                           {
    if (index >= indices.size()) {
        indices.resize(index + 1ul);
    }
    indices[index].reserve(count);
    indices[index].insert(indices[index].end(), source, source + count);
}

References indices.

Referenced by dna::DenormalizedData< Reader >::populateJointVariableAttributeIndices(), and dna::DenormalizedData< Reader >::populateMeshBlendShapeMappingIndices().

associateLODWithIndices()

void dna::LODMapping::associateLODWithIndices	(	std::uint16_t	lod,
		std::uint16_t	index
	)

                                                                           {
    if (lod >= lods.size()) {
        lods.resize(lod + 1ul);
    }
    if (index >= indices.size()) {
        indices.resize(index + 1ul);
    }
    lods[lod] = index;
}

References indices, and lods.

Referenced by dna::DenormalizedData< Reader >::populateJointVariableAttributeIndices(), and dna::DenormalizedData< Reader >::populateMeshBlendShapeMappingIndices().

cleanupIndices()

void dna::LODMapping::cleanupIndices ( )

private

                                {
    for (std::size_t i = indices.size(); i > 0ul; --i) {
        const auto idx = (i - 1ul);
        if (std::find(lods.begin(), lods.end(), idx) == lods.end()) {
            indices.erase(extd::advanced(indices.begin(), idx));
            for (auto& l2i : lods) {
                if (l2i > idx) {
                    --l2i;
                }
            }
        }
    }
}

References extd::advanced(), indices, and lods.

Referenced by discardLODs().

clearIndices()

void dna::LODMapping::clearIndices

(

std::uint16_t

index

)

                                               {
    if (index < indices.size()) {
        indices[index].clear();
    } else {
        indices.resize(index + 1ul);
    }
}

References indices.

discardLODs()

void dna::LODMapping::discardLODs

(

const LODConstraint &

lodConstraint

)

                                                               {
    lodConstraint.applyTo(lods);
    cleanupIndices();
}

References dna::LODConstraint::applyTo(), cleanupIndices(), and lods.

Referenced by dna::FilteredInputArchive::process().

filterIndices()

void dna::LODMapping::filterIndices

(

std::function< bool(std::uint16_t)>

filterer

)

                                                                      {
    for (auto& row : indices) {
        for (auto it = row.begin(); it != row.end();) {
            if (filterer(*it)) {
                ++it;
            } else {
                it = row.erase(it);
            }
        }
    }
}

References indices.

getCombinedDistinctIndices()

UnorderedSet< std::uint16_t > dna::LODMapping::getCombinedDistinctIndices

(

MemoryResource *

memRes

)

const

                                                                                             {
    UnorderedSet<std::uint16_t> distinctIndices{memRes};
    for (const auto& row : indices) {
        distinctIndices.insert(row.begin(), row.end());
    }
    return distinctIndices;
}

References indices.

Referenced by dna::FilteredInputArchive::process().

getIndexListCount()

std::uint16_t dna::LODMapping::getIndexListCount

(

)

const

                                                {
    return static_cast<std::uint16_t>(indices.size());
}

References indices.

getIndices()

ConstArrayView< std::uint16_t > dna::LODMapping::getIndices

(

std::uint16_t

lod

)

const

                                                                        {
    if (lod >= lods.size()) {
        return {};
    }
    assert(lods[lod] < indices.size());
    const auto it = extd::advanced(indices.cbegin(), lods[lod]);
    return (it == indices.cend() ? ConstArrayView<std::uint16_t>{} : ConstArrayView<std::uint16_t>{it->data(), it->size()});
}

References extd::advanced(), indices, and lods.

Referenced by dna::FilteredInputArchive::process().

getLODCount()

std::uint16_t dna::LODMapping::getLODCount

(

)

const

                                          {
    return static_cast<std::uint16_t>(lods.size());
}

References lods.

mapIndices()

void dna::LODMapping::mapIndices

(

std::function< std::uint16_t(std::uint16_t)>

mapper

)

                                                                        {
    for (auto& row : indices) {
        for (auto& value : row) {
            value = mapper(value);
        }
    }
}

References indices.

Referenced by dna::AnimatedMapFilter::apply(), dna::BlendShapeFilter::apply(), dna::JointFilter::apply(), and dna::MeshFilter::apply().

reset()

void dna::LODMapping::reset

(

)

                       {
    lods.clear();
    indices.clear();
}

References indices, and lods.

Referenced by setLODCount().

resetIndices()

void dna::LODMapping::resetIndices

(

)

                              {
    indices.clear();
}

References indices.

resetLODs()

void dna::LODMapping::resetLODs

(

)

                           {
    lods.clear();
}

References lods.

setLODCount()

void dna::LODMapping::setLODCount

(

std::uint16_t

lodCount

)

                                                 {
    reset();
    lods.resize(lodCount);
    indices.resize(lodCount);
}

References indices, lods, and reset().

Referenced by dna::DenormalizedData< Reader >::populateJointVariableAttributeIndices(), and dna::DenormalizedData< Reader >::populateMeshBlendShapeMappingIndices().

Member Data Documentation

indices

Matrix<std::uint16_t> dna::LODMapping::indices

protected

Referenced by addIndices(), associateLODWithIndices(), cleanupIndices(), clearIndices(), filterIndices(), getCombinedDistinctIndices(), getIndexListCount(), getIndices(), mapIndices(), reset(), resetIndices(), dna::RawLODMapping::serialize(), and setLODCount().

lods

Vector<std::uint16_t> dna::LODMapping::lods

protected

Referenced by associateLODWithIndices(), cleanupIndices(), discardLODs(), getIndices(), getLODCount(), reset(), resetLODs(), dna::RawLODMapping::serialize(), and setLODCount().

---

The documentation for this class was generated from the following files:

• dna/LODMapping.h
• dna/LODMapping.cpp