Method serialize

sdk/lowlevel/source/NvBlastActorSerializationBlock.cpp:255–494

//////// Actor member methods for serialization ////////

uint32_t Actor::serialize(void* buffer, uint32_t bufferSize, NvBlastLog logFn) const
{
	// Set up pointers and such
	const Asset* asset = getAsset();
	const SupportGraph& graph = asset->m_graph;
	const uint32_t* graphChunkIndices = graph.getChunkIndices();
	const uint32_t* graphAdjacencyPartition = graph.getAdjacencyPartition();
	const uint32_t* graphAdjacentNodeIndices = graph.getAdjacentNodeIndices();
	const uint32_t* graphAdjacentBondIndices = graph.getAdjacentBondIndices();
	const FamilyHeader* header = getFamilyHeader();
	const uint32_t* chunkActorIndices = header->getChunkActorIndices();
	const uint32_t thisActorIndex = getIndex();
	const bool boundToWorld = isBoundToWorld();

	// Make sure there are no dirty nodes
	if (m_graphNodeCount)
	{
		const uint32_t* firstDirtyNodeIndices = header->getFamilyGraph()->getFirstDirtyNodeIndices();
		if (!isInvalidIndex(firstDirtyNodeIndices[thisActorIndex]))
		{
			NVBLASTLL_LOG_ERROR(logFn, "Nv::Blast::Actor::serialize: instance graph has dirty nodes.  Call Nv::Blast::Actor::findIslands before serializing.");
			return 0;
		}
	}

	uint64_t offset = 0;

	// Header
	ActorSerializationHeader* serHeader = reinterpret_cast<ActorSerializationHeader*>(buffer);
	offset = align16(sizeof(ActorSerializationHeader));
	if (offset > bufferSize)
	{
		return 0;	// Buffer size insufficient
	}
	serHeader->m_formatVersion = ActorSerializationFormat::Current;
	serHeader->m_size = 0;	// Will be updated below
	serHeader->m_index = thisActorIndex;
	serHeader->m_visibleChunkCount = m_visibleChunkCount;
	serHeader->m_graphNodeCount = m_graphNodeCount;
	serHeader->m_leafChunkCount = m_leafChunkCount;

	// Visible chunk indices
	{
		serHeader->m_visibleChunkIndicesOffset = (uint32_t)offset;
		offset = align16(offset + m_visibleChunkCount*sizeof(uint32_t));
		if (offset > bufferSize)
		{
			NVBLASTLL_LOG_ERROR(logFn, "Nv::Blast::Actor::Actor::serialize: buffer size exceeded.");
			return 0;	// Buffer size insufficient
		}
		uint32_t* serVisibleChunkIndices = serHeader->getVisibleChunkIndices();
		uint32_t serVisibleChunkCount = 0;
		for (Actor::VisibleChunkIt i = *this; (bool)i; ++i)
		{
			NVBLAST_ASSERT(serVisibleChunkCount < m_visibleChunkCount);
			serVisibleChunkIndices[serVisibleChunkCount++] = (uint32_t)i;
		}
		NVBLAST_ASSERT(serVisibleChunkCount == m_visibleChunkCount);