/** Construct the UUID for the UPnP Universal Device Name (UDN).
*
* In order to get the same UUID each time we run, we bake the hostname
* and the path into the UUID using a simple hash.
*/
std::string Server::Impl::MakeUUID(const std::string& resource)
{
union {
unsigned char ch[16];
uint32_t ui[4];
} u;
char hostname[256];
hostname[0] = '\0';
gethostname(hostname, sizeof(hostname));
strcpy((char*)u.ch, "chorale ");
u.ui[2] = SimpleHash(hostname);
u.ui[3] = SimpleHash(resource.c_str());
return util::SPrintf("uuid:%08x-%04x-%04x-%04x-%04x%08x",
u.ui[0], u.ui[1] >> 16, u.ui[1] & 0xFFFF, u.ui[2] >> 16,
u.ui[2] & 0xFFFF, u.ui[3]);
}
void GenerateModelThread::CompressAndGenerateJS()
{
string utf8Name=assembledOBJFileName.toStdString();
int pos=utf8Name.find_last_of('\\');
utf8Name.erase(0,pos+1);
pos=utf8Name.find('.');
utf8Name=utf8Name.substr(0,pos);
string jsName=utf8Name+".js";
jsName="web\\models\\human\\"+jsName;
FILE *jsfile=fopen(jsName.c_str(),"w");
if(jsfile==NULL)
{
qDebug()<<"open failed";
}
FILE* fp = fopen(assembledOBJFileName.toStdString().c_str(), "r");
WavefrontObjFile obj(fp);
fclose(fp);
qDebug()<<StripLeadingDir(assembledOBJFileName.toStdString().c_str());
fprintf(jsfile,"MODELS[\'%s\'] = {\n",StripLeadingDir(assembledOBJFileName.toStdString().c_str()));
//puts(" materials: {");
fputs(" materials: {\n",jsfile);
const MaterialList& materials = obj.materials();
for (size_t i = 0; i < materials.size(); ++i) {
materials[i].DumpJson(jsfile);
if(i<materials.size()-1)
fprintf(jsfile,",");
}
// puts(" },");
fputs(" },\n",jsfile);
const MaterialBatches& batches = obj.material_batches();
// Pass 1: compute bounds.
webgl_loader::Bounds bounds;
bounds.Clear();
for (MaterialBatches::const_iterator iter = batches.begin();
iter != batches.end(); ++iter) {
const DrawBatch& draw_batch = iter->second;
bounds.Enclose(draw_batch.draw_mesh().attribs);
}
webgl_loader::BoundsParams bounds_params =
webgl_loader::BoundsParams::FromBounds(bounds);
fprintf(jsfile," decodeParams: ");
bounds_params.DumpJson(jsfile);
fputs(" urls: {\n",jsfile);
std::vector<char> utf8;
webgl_loader::VectorSink sink(&utf8);
// Pass 2: quantize, optimize, compress, report.
for (MaterialBatches::const_iterator iter = batches.begin();
iter != batches.end(); ++iter) {
size_t offset = 0;
utf8.clear();
const DrawMesh& draw_mesh = iter->second.draw_mesh();
if (draw_mesh.indices.empty()) continue;
QuantizedAttribList quantized_attribs;
webgl_loader::AttribsToQuantizedAttribs(draw_mesh.attribs, bounds_params,
&quantized_attribs);
VertexOptimizer vertex_optimizer(quantized_attribs);
const std::vector<GroupStart>& group_starts = iter->second.group_starts();
WebGLMeshList webgl_meshes;
std::vector<size_t> group_lengths;
for (size_t i = 1; i < group_starts.size(); ++i) {
const size_t here = group_starts[i-1].offset;
const size_t length = group_starts[i].offset - here;
group_lengths.push_back(length);
vertex_optimizer.AddTriangles(&draw_mesh.indices[here], length,
&webgl_meshes);
}
const size_t here = group_starts.back().offset;
const size_t length = draw_mesh.indices.size() - here;
const bool divisible_by_3 = length % 3 == 0;
CHECK(divisible_by_3);
group_lengths.push_back(length);
vertex_optimizer.AddTriangles(&draw_mesh.indices[here], length,
&webgl_meshes);
std::vector<std::string> material;
std::vector<size_t> attrib_start, attrib_length, index_start, index_length;
for (size_t i = 0; i < webgl_meshes.size(); ++i) {
const size_t num_attribs = webgl_meshes[i].attribs.size();
const size_t num_indices = webgl_meshes[i].indices.size();
const bool kBadSizes = num_attribs % 8 || num_indices % 3;
CHECK(!kBadSizes);
webgl_loader::CompressQuantizedAttribsToUtf8(webgl_meshes[i].attribs,
&sink);
webgl_loader::CompressIndicesToUtf8(webgl_meshes[i].indices, &sink);
material.push_back(iter->first);
attrib_start.push_back(offset);
attrib_length.push_back(num_attribs / 8);
index_start.push_back(offset + num_attribs);
index_length.push_back(num_indices / 3);
offset += num_attribs + num_indices;
}
const uint32 hash = SimpleHash(&utf8[0], utf8.size());
char buf[9] = { '\0' };
ToHex(hash, buf);
// TODO: this needs to handle paths.
string strUTF8Name=utf8Name+".utf8";
std::string out_fn = std::string(buf) + "." + strUTF8Name;
string out="web\\models\\human\\"+out_fn;
FILE* out_fp = fopen(out.c_str(), "wb");
fprintf(jsfile," \'%s\': [\n", out_fn.c_str());
size_t group_index = 0;
for (size_t i = 0; i < webgl_meshes.size(); ++i) {
fprintf(jsfile," { material: \'%s\',\n"
" attribRange: [" PRIuS ", " PRIuS "],\n"
" indexRange: [" PRIuS ", " PRIuS "],\n"
" bboxes: " PRIuS ",\n"
" names: [",
material[i].c_str(),
attrib_start[i], attrib_length[i],
index_start[i], index_length[i],
offset);
std::vector<size_t> buffered_lengths;
size_t group_start = 0;
while (group_index < group_lengths.size()) {
fprintf(jsfile,"\'%s\', ",
obj.LineToGroup(group_starts[group_index].group_line).c_str());
const size_t group_length = group_lengths[group_index];
const size_t next_start = group_start + group_length;
const size_t webgl_index_length = webgl_meshes[i].indices.size();
// TODO: bbox info is better placed at the head of the file,
// perhaps transposed. Also, when a group gets split between
// batches, the bbox gets stored twice.
webgl_loader::CompressAABBToUtf8(group_starts[group_index].bounds,
bounds_params, &sink);
offset += 6;
if (next_start < webgl_index_length) {
buffered_lengths.push_back(group_length);
group_start = next_start;
++group_index;
} else {
const size_t fits = webgl_index_length - group_start;
buffered_lengths.push_back(fits);
group_start = 0;
group_lengths[group_index] -= fits;
break;
}
}
fprintf(jsfile,"],\n lengths: [");
for (size_t k = 0; k < buffered_lengths.size(); ++k) {
fprintf(jsfile,PRIuS ", ", buffered_lengths[k]);
}
fputs("],\n },\n",jsfile);
}
fwrite(&utf8[0], 1, utf8.size(), out_fp);
fclose(out_fp);
fputs(" ],\n",jsfile);
}
fputs(" }\n};\n",jsfile);
fclose(jsfile);
}
