// ----------------------------------------------------------------

// From Game Programming in C++ by Sanjay Madhav

// Copyright (C) 2017 Sanjay Madhav. All rights reserved.

//

// Released under the BSD License

// See LICENSE in root directory for full details.

// ----------------------------------------------------------------

#include "Mesh.h"

#include "Renderer.h"

#include "Texture.h"

#include "VertexArray.h"

#include <rapidjson/document.h>

#include <SDL/SDL_log.h>

#include "Math.h"

#include "LevelLoader.h"

#include <fstream>

namespace

{

union Vertex

{

float f;

uint8_t b[4];

};

const int BinaryVersion = 1;

struct MeshBinHeader

{

// Signature for file type

char mSignature[4] = { 'G', 'M', 'S', 'H' };

// Version

uint32_t mVersion = BinaryVersion;

// Vertex layout type

VertexArray::Layout mLayout = VertexArray::PosNormTex;

// Info about how many of each we have

uint32_t mNumTextures = 0;

uint32_t mNumVerts = 0;

uint32_t mNumIndices = 0;

// Box/radius of mesh, used for collision

AABB mBox{ Vector3::Zero, Vector3::Zero };

float mRadius = 0.0f;

float mSpecPower = 100.0f;

};

}

Mesh::Mesh()

:mBox(Vector3::Infinity, Vector3::NegInfinity)

,mVertexArray(nullptr)

,mRadius(0.0f)

,mSpecPower(100.0f)

{

}

Mesh::~Mesh()

{

}

bool Mesh::Load(const std::string& fileName, Renderer* renderer)

{

mFileName = fileName;

// Try loading the binary file first

if (LoadBinary(fileName + ".bin", renderer))

{

return true;

}

rapidjson::Document doc;

if (!LevelLoader::LoadJSON(fileName, doc))

{

SDL_Log("Failed to load mesh %s", fileName.c_str());

return false;

}

int ver = doc["version"].GetInt();

// Check the version

if (ver != 1)

{

SDL_Log("Mesh %s not version 1", fileName.c_str());

return false;

}

mShaderName = doc["shader"].GetString();

// Set the vertex layout/size based on the format in the file

VertexArray::Layout layout = VertexArray::PosNormTex;

size_t vertSize = 8;

std::string vertexFormat = doc["vertexformat"].GetString();

if (vertexFormat == "PosNormSkinTex")

{

layout = VertexArray::PosNormSkinTex;

// This is the number of "Vertex" unions, which is 8 + 2 (for skinning)s

vertSize = 10;

}

// Load textures

const rapidjson::Value& textures = doc["textures"];

if (!textures.IsArray() || textures.Size() < 1)

{

SDL_Log("Mesh %s has no textures, there should be at least one", fileName.c_str());

return false;

}

mSpecPower = static_cast<float>(doc["specularPower"].GetDouble());

std::vector<std::string> textureNames;

for (rapidjson::SizeType i = 0; i < textures.Size(); i++)

{

// Is this texture already loaded?

std::string texName = textures[i].GetString();

textureNames.emplace_back(texName);

Texture* t = renderer->GetTexture(texName);

if (t == nullptr)

{

// If it's null, use the default texture

t = renderer->GetTexture("Assets/Default.png");

}

mTextures.emplace_back(t);

}

// Load in the vertices

const rapidjson::Value& vertsJson = doc["vertices"];

if (!vertsJson.IsArray() || vertsJson.Size() < 1)

{

SDL_Log("Mesh %s has no vertices", fileName.c_str());

return false;

}

std::vector<Vertex> vertices;

vertices.reserve(vertsJson.Size() * vertSize);

mRadius = 0.0f;

for (rapidjson::SizeType i = 0; i < vertsJson.Size(); i++)

{

// For now, just assume we have 8 elements

const rapidjson::Value& vert = vertsJson[i];

if (!vert.IsArray())

{

SDL_Log("Unexpected vertex format for %s", fileName.c_str());

return false;

}

Vector3 pos(vert[0].GetDouble(), vert[1].GetDouble(), vert[2].GetDouble());

mRadius = Math::Max(mRadius, pos.LengthSq());

mBox.UpdateMinMax(pos);

if (layout == VertexArray::PosNormTex)

{

Vertex v;

// Add the floats

for (rapidjson::SizeType j = 0; j < vert.Size(); j++)

{

v.f = static_cast<float>(vert[j].GetDouble());

vertices.emplace_back(v);

}

}

else

{

Vertex v;

// Add pos/normal

for (rapidjson::SizeType j = 0; j < 6; j++)

{

v.f = static_cast<float>(vert[j].GetDouble());

vertices.emplace_back(v);

}

// Add skin information

for (rapidjson::SizeType j = 6; j < 14; j += 4)

{

v.b[0] = vert[j].GetUint();

v.b[1] = vert[j + 1].GetUint();

v.b[2] = vert[j + 2].GetUint();

v.b[3] = vert[j + 3].GetUint();

vertices.emplace_back(v);

}

// Add tex coords

for (rapidjson::SizeType j = 14; j < vert.Size(); j++)

{

v.f = vert[j].GetDouble();

vertices.emplace_back(v);

}

}

}

// We were computing length squared earlier

mRadius = Math::Sqrt(mRadius);

// Load in the indices

const rapidjson::Value& indJson = doc["indices"];

if (!indJson.IsArray() || indJson.Size() < 1)

{

SDL_Log("Mesh %s has no indices", fileName.c_str());

return false;

}

std::vector<unsigned int> indices;

indices.reserve(indJson.Size() * 3);

for (rapidjson::SizeType i = 0; i < indJson.Size(); i++)

{

const rapidjson::Value& ind = indJson[i];

if (!ind.IsArray() || ind.Size() != 3)

{

SDL_Log("Invalid indices for %s", fileName.c_str());

return false;

}

indices.emplace_back(ind[0].GetUint());

indices.emplace_back(ind[1].GetUint());

indices.emplace_back(ind[2].GetUint());

}

// Now create a vertex array

unsigned int numVerts = static_cast<unsigned>(vertices.size()) / vertSize;

mVertexArray = new VertexArray(vertices.data(), numVerts,

layout, indices.data(), static_cast<unsigned>(indices.size()));

// Save the binary mesh

SaveBinary(fileName + ".bin", vertices.data(),

numVerts, layout, indices.data(),

static_cast<unsigned>(indices.size()),

textureNames, mBox, mRadius,

mSpecPower);

return true;

}

void Mesh::Unload()

{

delete mVertexArray;

mVertexArray = nullptr;

}

Texture* Mesh::GetTexture(size_t index)

{

if (index < mTextures.size())

{

return mTextures[index];

}

else

{

return nullptr;

}

}

void Mesh::SaveBinary(const std::string& fileName, const void* verts,

uint32_t numVerts, VertexArray::Layout layout,

const uint32_t* indices, uint32_t numIndices,

const std::vector<std::string>& textureNames,

const AABB& box, float radius,

float specPower)

{

// Create header struct

MeshBinHeader header;

header.mLayout = layout;

header.mNumTextures =

static_cast<unsigned>(textureNames.size());

header.mNumVerts = numVerts;

header.mNumIndices = numIndices;

header.mBox = box;

header.mRadius = radius;

// Open binary file for writing

std::ofstream outFile(fileName, std::ios::out

| std::ios::binary);

if (outFile.is_open())

{

// Write the header

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

// For each texture, we need to write the size of the name

// followed by the string (null-terminated)

for (const auto& tex : textureNames)

{

// (Assume file names won't have more than 32k characters)

uint16_t nameSize = static_cast<uint16_t>(tex.length()) + 1;

outFile.write(reinterpret_cast<char*>(&nameSize), sizeof(nameSize));

outFile.write(tex.c_str(), nameSize - 1);

outFile.write("\0", 1);

}

// Figure out number of bytes for each vertex, based on layout

unsigned vertexSize = VertexArray::GetVertexSize(layout);

// Write vertices

outFile.write(reinterpret_cast<const char*>(verts),

numVerts * vertexSize);

// Write indices

outFile.write(reinterpret_cast<const char*>(indices),

numIndices * sizeof(uint32_t));

}

}

bool Mesh::LoadBinary(const std::string& fileName, Renderer* renderer)

{

std::ifstream inFile(fileName, std::ios::in |

std::ios::binary);

if (inFile.is_open())

{

// Read in header

MeshBinHeader header;

inFile.read(reinterpret_cast<char*>(&header), sizeof(header));

// Validate the header signature and version

char* sig = header.mSignature;

if (sig[0] != 'G' || sig[1] != 'M' || sig[2] != 'S' ||

sig[3] != 'H' || header.mVersion != BinaryVersion)

{

return false;

}

// Read in the texture file names

for (uint32_t i = 0; i < header.mNumTextures; i++)

{

// Get the file name size

uint16_t nameSize = 0;

inFile.read(reinterpret_cast<char*>(&nameSize), sizeof(nameSize));

// Make a buffer of this size

char* texName = new char[nameSize];

// Read in the texture name

inFile.read(texName, nameSize);

// Get this texture

Texture* t = renderer->GetTexture(texName);

if (t == nullptr)

{

// If it's null, use the default texture

t = renderer->GetTexture("Assets/Default.png");

}

mTextures.emplace_back(t);

delete[] texName;

}

// Now read in the vertices

unsigned vertexSize = VertexArray::GetVertexSize(header.mLayout);

char* verts = new char[header.mNumVerts * vertexSize];

inFile.read(verts, header.mNumVerts * vertexSize);

// Now read in the indices

uint32_t* indices = new uint32_t[header.mNumIndices];

inFile.read(reinterpret_cast<char*>(indices),

header.mNumIndices * sizeof(uint32_t));

// Now create the vertex array

mVertexArray = new VertexArray(verts, header.mNumVerts,

header.mLayout, indices, header.mNumIndices);

// Cleanup memory

delete[] verts;

delete[] indices;

// Set mBox/mRadius/specular from header

mBox = header.mBox;

mRadius = header.mRadius;

mSpecPower = header.mSpecPower;

return true;

}

return false;

}