anki-3d-engine/tools/scene/ExporterMesh.cpp

// Copyright (C) 2009-2017, Panagiotis Christopoulos Charitos and contributors.
// All rights reserved.
// Code licensed under the BSD License.
// http://www.anki3d.org/LICENSE

#include "Exporter.h"
#include <cmath>

enum class ComponentFormat : uint32_t
{
	NONE,

	R8,
	R8G8,
	R8G8B8,
	R8G8B8A8,

	R16,
	R16G16,
	R16G16B16,
	R16G16B16A16,

	R32,
	R32G32,
	R32G32B32,
	R32G32B32A32,

	R10G10B10A2,

	COUNT
};

enum class FormatTransform : uint32_t
{
	NONE,

	UNORM,
	SNORM,
	UINT,
	SINT,
	FLOAT,

	COUNT
};

struct Format
{
	ComponentFormat m_components = ComponentFormat::NONE;
	FormatTransform m_transform = FormatTransform::NONE;
};

const uint32_t FLAG_QUADS = 1;

struct Header
{
	char m_magic[8]; ///< Magic word.
	uint32_t m_flags;
	uint32_t m_flags2;
	Format m_positionsFormat;
	Format m_normalsFormat;
	Format m_tangentsFormat;
	Format m_colorsFormat; ///< Vertex color.
	Format m_uvsFormat;
	Format m_boneWeightsFormat;
	Format m_boneIndicesFormat;
	Format m_indicesFormat; ///< Vertex indices.

	uint32_t m_totalIndicesCount;
	uint32_t m_totalVerticesCount;
	uint32_t m_uvsChannelCount;
	uint32_t m_subMeshCount;

	uint8_t m_padding[32];
};

struct SubMesh
{
	uint32_t m_firstIndex = 0;
	uint32_t m_indicesCount = 0;
};

struct Vertex
{
	float m_position[3];
	uint16_t m_uv[2];
	uint32_t m_normal;
	uint32_t m_tangent;
};

struct BoneVertex : Vertex
{
	uint8_t m_weights[4] = {0, 0, 0, 0};
	uint16_t m_boneIndices[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
};

static_assert(sizeof(BoneVertex) == 9 * 4, "Wrong size");

static uint16_t toF16(float f)
{
	union Val32
	{
		int32_t i;
		float f;
		uint32_t u;
	};

	uint16_t out;
	Val32 v32;
	v32.f = f;
	int32_t i = v32.i;
	int32_t s = (i >> 16) & 0x00008000;
	int32_t e = ((i >> 23) & 0x000000ff) - (127 - 15);
	int32_t m = i & 0x007fffff;

	if(e <= 0)
	{
		if(e < -10)
		{
			out = 0;
		}
		else
		{
			m = (m | 0x00800000) >> (1 - e);

			if(m & 0x00001000)
			{
				m += 0x00002000;
			}

			out = s | (m >> 13);
		}
	}
	else if(e == 0xff - (127 - 15))
	{
		if(m == 0)
		{
			out = s | 0x7c00;
		}
		else
		{
			m >>= 13;
			out = s | 0x7c00 | m | (m == 0);
		}
	}
	else
	{
		if(m & 0x00001000)
		{
			m += 0x00002000;

			if(m & 0x00800000)
			{
				m = 0;
				e += 1;
			}
		}

		if(e > 30)
		{
			assert(0 && "Overflow");
			out = s | 0x7c00;
		}
		else
		{
			out = s | (e << 10) | (m >> 13);
		}
	}

	return out;
}

union SignedR10G10B10A10
{
	struct
	{
		int m_x : 10;
		int m_y : 10;
		int m_z : 10;
		int m_w : 2;
	} m_unpacked;
	uint32_t m_packed;
};

uint32_t toR10G10B10A2Sint(float r, float g, float b, float a)
{
	SignedR10G10B10A10 out;
	out.m_unpacked.m_x = int(round(r * 511.0));
	out.m_unpacked.m_y = int(round(g * 511.0));
	out.m_unpacked.m_z = int(round(b * 511.0));
	out.m_unpacked.m_w = int(round(a * 1.0));

	return out.m_packed;
}

void Exporter::exportMesh(const aiMesh& mesh, const aiMatrix4x4* transform, unsigned vertCountPerFace) const
{
	std::string name = mesh.mName.C_Str();
	std::fstream file;
	LOGI("Exporting mesh %s", name.c_str());

	// Open file
	file.open(m_outputDirectory + name + ".ankimesh", std::ios::out | std::ios::binary);

	Header header;
	memset(&header, 0, sizeof(header));

	// Checks
	if(mesh.mNumFaces == 0)
	{
		ERROR("Incorrect face number");
	}

	if(mesh.mVertices == 0)
	{
		ERROR("Incorrect vertex count number");
	}

	if(!mesh.HasPositions())
	{
		ERROR("Missing positions");
	}

	if(!mesh.HasNormals())
	{
		ERROR("Missing normals");
	}

	if(!mesh.HasTangentsAndBitangents())
	{
		ERROR("Missing tangents");
	}

	if(!mesh.HasTextureCoords(0))
	{
		ERROR("Missing UVs");
	}

	// Write header
	static const char* magic = "ANKIMES3";
	memcpy(&header.m_magic, magic, 8);

	if(vertCountPerFace == 4)
	{
		header.m_flags = FLAG_QUADS;
	}

	header.m_positionsFormat.m_components = ComponentFormat::R32G32B32;
	header.m_positionsFormat.m_transform = FormatTransform::FLOAT;

	header.m_normalsFormat.m_components = ComponentFormat::R10G10B10A2;
	header.m_normalsFormat.m_transform = FormatTransform::SNORM;

	header.m_tangentsFormat.m_components = ComponentFormat::R10G10B10A2;
	header.m_tangentsFormat.m_transform = FormatTransform::SNORM;

	header.m_uvsFormat.m_components = ComponentFormat::R16G16;
	header.m_uvsFormat.m_transform = FormatTransform::FLOAT;

	header.m_indicesFormat.m_components = ComponentFormat::R16;
	header.m_indicesFormat.m_transform = FormatTransform::UINT;

	header.m_totalIndicesCount = mesh.mNumFaces * vertCountPerFace;
	header.m_totalVerticesCount = mesh.mNumVertices;
	header.m_uvsChannelCount = 1;
	header.m_subMeshCount = 1;

	const bool hasBoneWeights = mesh.mNumBones > 0;
	if(hasBoneWeights)
	{
		header.m_boneIndicesFormat.m_components = ComponentFormat::R16G16B16A16;
		header.m_boneIndicesFormat.m_transform = FormatTransform::UINT;

		header.m_boneWeightsFormat.m_components = ComponentFormat::R8G8B8A8;
		header.m_boneWeightsFormat.m_transform = FormatTransform::UNORM;
	}

	file.write(reinterpret_cast<char*>(&header), sizeof(header));

	// Gather the bone weights
	struct VertWeights
	{
		float m_weights[4];
		uint32_t m_boneIndices[4];
		uint32_t m_boneCount = 0;
	};

	std::vector<VertWeights> weights;

	if(hasBoneWeights)
	{
		weights.resize(mesh.mNumVertices);

		for(unsigned i = 0; i < mesh.mNumBones; ++i)
		{
			const aiBone& bone = *mesh.mBones[i];
			for(unsigned j = 0; j < bone.mNumWeights; ++j)
			{
				const aiVertexWeight& aiWeight = bone.mWeights[j];
				assert(aiWeight.mVertexId < weights.size());
				VertWeights& vert = weights[aiWeight.mVertexId];

				if(vert.m_boneCount == 4)
				{
					ERROR("Vertex has more than 4 bone weights");
				}

				vert.m_boneIndices[vert.m_boneCount] = i;
				vert.m_weights[vert.m_boneCount] = aiWeight.mWeight;
				++vert.m_boneCount;
			}
		}
	}

	// Write sub meshes
	SubMesh smesh;
	smesh.m_firstIndex = 0;
	smesh.m_indicesCount = header.m_totalIndicesCount;
	file.write(reinterpret_cast<char*>(&smesh), sizeof(smesh));

	// Write indices
	for(unsigned i = 0; i < mesh.mNumFaces; i++)
	{
		const aiFace& face = mesh.mFaces[i];

		if(face.mNumIndices != vertCountPerFace)
		{
			ERROR("For some reason assimp returned wrong number of verts for a face (face.mNumIndices=%d). Probably"
				  "degenerates in input file",
				face.mNumIndices);
		}

		for(unsigned j = 0; j < vertCountPerFace; j++)
		{
			uint32_t index32 = face.mIndices[j];
			if(index32 > 0xFFFF)
			{
				ERROR("Index too big");
			}

			uint16_t index = index32;
			file.write(reinterpret_cast<char*>(&index), sizeof(index));
		}
	}

	// Write vertices
	aiMatrix3x3 normalMat;
	if(transform)
	{
		normalMat = aiMatrix3x3(*transform);
	}

	for(unsigned i = 0; i < mesh.mNumVertices; i++)
	{
		aiVector3D pos = mesh.mVertices[i];
		aiVector3D n = mesh.mNormals[i];
		aiVector3D t = mesh.mTangents[i];
		aiVector3D b = mesh.mBitangents[i];
		const aiVector3D& uv = mesh.mTextureCoords[0][i];

		if(transform)
		{
			pos = (*transform) * pos;
			n = normalMat * n;
			t = normalMat * t;
			b = normalMat * b;
		}

		if(m_flipyz)
		{
			static const aiMatrix4x4 toLefthanded(1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1);

			pos = toLefthanded * pos;
			n = toLefthanded * n;
			t = toLefthanded * t;
			b = toLefthanded * b;
		}

		BoneVertex vert;

		// Position
		vert.m_position[0] = pos[0];
		vert.m_position[1] = pos[1];
		vert.m_position[2] = pos[2];

		// Tex coords
		vert.m_uv[0] = toF16(uv[0]);
		vert.m_uv[1] = toF16(uv[1]);

		// Normal
		vert.m_normal = toR10G10B10A2Sint(n[0], n[1], n[2], 0.0);

		// Tangent
		float w = ((n ^ t) * b < 0.0) ? 1.0 : -1.0;
		vert.m_tangent = toR10G10B10A2Sint(t[0], t[1], t[2], w);

		// Write
		if(hasBoneWeights)
		{
			// Normalize weights
			float totalWeight = 0;
			for(unsigned j = 0; j < weights[i].m_boneCount; ++j)
			{
				totalWeight += weights[i].m_weights[j];
			}

			if(totalWeight > 0.0)
			{
				for(unsigned j = 0; j < weights[i].m_boneCount; ++j)
				{
					weights[i].m_weights[j] /= totalWeight;
				}
			}

			for(unsigned j = 0; j < weights[i].m_boneCount; ++j)
			{
				vert.m_boneIndices[j] = weights[i].m_boneIndices[j];
				vert.m_weights[j] = weights[i].m_weights[j] * 0xFF;
			}

			file.write(reinterpret_cast<char*>(&vert), sizeof(BoneVertex));
		}
		else
		{
			file.write(reinterpret_cast<char*>(&vert), sizeof(Vertex));
		}
	}
}