void read(socket_t hsock_i, void* data_i, size_t bytes)
{
#if BUFFERING
char* data = (char*)data_i;
buffered_socket_t* hsock = (buffered_socket_t*) hsock_i;
while (bytes) {
if (hsock->istart == hsock->iend) {
ssize_t n = ::recv(hsock->fd,hsock->ibuf,hsock->isize,MSG_NOSIGNAL);
if (n == 0) throw Disconnect();
else if (n < 0) THROW_RUNTIME_ERROR("error reading from socket");
hsock->istart = 0;
hsock->iend = n;
}
size_t bsize = hsock->iend-hsock->istart;
if (bytes < bsize) bsize = bytes;
memcpy(data,hsock->ibuf+hsock->istart,bsize);
data += bsize;
hsock->istart += bsize;
bytes -= bsize;
}
#else
char* data = (char*) data_i;
buffered_socket_t* hsock = (buffered_socket_t*) hsock_i;
while (bytes) {
ssize_t n = ::read(hsock->fd,data,bytes);
if (n == 0) throw Disconnect();
else if (n < 0) THROW_RUNTIME_ERROR("error reading from socket");
data+=n;
bytes-=n;
}
#endif
}
socket_t bind(unsigned short port)
{
initialize();
/*! create a new socket */
SOCKET sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == INVALID_SOCKET) THROW_RUNTIME_ERROR("cannot create socket");
/* When the server completes, the server socket enters a time-wait state during which the local
address and port used by the socket are believed to be in use by the OS. The wait state may
last several minutes. This socket option allows bind() to reuse the port immediately. */
#ifdef SO_REUSEADDR
{ int flag = true; ::setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&flag, sizeof(int)); }
#endif
/*! bind socket to port */
struct sockaddr_in serv_addr;
memset((char *) &serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = (unsigned short) htons(port);
serv_addr.sin_addr.s_addr = INADDR_ANY;
if (::bind(sockfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) < 0)
THROW_RUNTIME_ERROR("binding to port "+toString(port)+" failed");
/*! listen to port, up to 5 pending connections */
if (::listen(sockfd,5) < 0)
THROW_RUNTIME_ERROR("listening on socket failed");
return (socket_t) new buffered_socket_t(sockfd);
}
__forceinline void wait()
{
/* every thread entering the barrier decrements this count */
size_t i0 = i;
size_t cnt0 = enterCount--;
/* all threads except the last one are wait in the barrier */
if (cnt0 > 1)
{
if (WaitForSingleObject(events[i0], INFINITE) != WAIT_OBJECT_0)
THROW_RUNTIME_ERROR("WaitForSingleObjects failed");
}
/* the last thread starts all threads waiting at the barrier */
else
{
i = 1-i;
enterCount.store(barrierSize);
if (SetEvent(events[i0]) == 0)
THROW_RUNTIME_ERROR("SetEvent failed");
}
/* every thread leaving the barrier decrements this count */
size_t cnt1 = exitCount--;
/* the last thread that left the barrier resets the event again */
if (cnt1 == 1)
{
exitCount.store(barrierSize);
if (ResetEvent(events[i0]) == 0)
THROW_RUNTIME_ERROR("ResetEvent failed");
}
}
socket_t connect(const char* host, unsigned short port)
{
initialize();
/*! create a new socket */
SOCKET sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == INVALID_SOCKET) THROW_RUNTIME_ERROR("cannot create socket");
/*! perform DNS lookup */
struct hostent* server = ::gethostbyname(host);
if (server == nullptr) THROW_RUNTIME_ERROR("server "+std::string(host)+" not found");
/*! perform connection */
struct sockaddr_in serv_addr;
memset((char*)&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = (unsigned short) htons(port);
memcpy((char*)&serv_addr.sin_addr.s_addr, (char*)server->h_addr, server->h_length);
if (::connect(sockfd,(struct sockaddr*) &serv_addr,sizeof(serv_addr)) < 0)
THROW_RUNTIME_ERROR("connection to "+std::string(host)+":"+toString(port)+" failed");
/*! enable TCP_NODELAY */
#ifdef TCP_NODELAY
{ int flag = 1; ::setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (const char*)&flag, sizeof(int)); }
#endif
/*! we do not want SIGPIPE to be thrown */
#ifdef SO_NOSIGPIPE
{ int flag = 1; setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, (const char*) &flag, sizeof(int)); }
#endif
return (socket_t) new buffered_socket_t(sockfd);
}
int loadHairASCII(const FileName& fileName, OBJScene::HairSet* hairset, Vec3fa& offset)
{
/* open hair file */
FILE* f = fopen(fileName.c_str(),"r");
if (!f) THROW_RUNTIME_ERROR("could not open " + fileName.str());
char line[10000];
fgets(line,10000,f);
int numCurves = 0;
while (fgets(line,10000,f) && !feof(f))
{
/* comment */
if (line[0] == '#')
continue;
if (!strncmp(line,"Curve:",strlen("Curve:")))
{
char name[1000];
unsigned int tracks, points;
sscanf(line,"Curve: %s %d Tracks %d Points",name,&tracks,&points);
/* skip Tracks line */
fgets(line,10000,f);
const int vertex_start_id = hairset->v.size();
unsigned int id = 0;
for (int i=0; i<points; i++)
{
fgets(line,10000,f);
/* comment */
if (line[0] == '#' || !strncmp(line," Tracks:",strlen(" Tracks:")))
continue;
Vec3fa v;
if (i == 0) sscanf(line,"%d : Bezier %f %f %f %f",&id,&v.x,&v.y,&v.z,&v.w);
else sscanf(line,"%d : %f %f %f %f",&id,&v.x,&v.y,&v.z,&v.w);
//printf("%d %d : %f %f %f %f \n",id,vertex_start_id+id,v.x,v.y,v.z,v.w);
v.x-=offset.x;
v.y-=offset.y;
v.z-=offset.z;
hairset->v.push_back(v);
}
/* add indices to hair starts */
for (int i=0; i<points-1; i+=3)
hairset->hairs.push_back(OBJScene::Hair(vertex_start_id + i,numCurves));
if (id != points-1)
THROW_RUNTIME_ERROR("hair parsing error");
numCurves++;
}
}
fclose(f);
return numCurves;
}
Ref<SceneGraph::Node> CoronaLoader::loadObject(const Ref<XML>& xml)
{
if (xml->name != "object")
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid object node");
if (xml->parm("class") != "file")
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid object class");
const FileName fileName = load<FileName>(xml);
return SceneGraph::load(path+fileName);
}
void CoronaLoader::loadMaterialDefinition(const Ref<XML>& xml)
{
if (xml->name != "materialDefinition")
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid material definition: "+xml->name);
if (xml->children.size() != 1)
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid material definition");
const std::string name = xml->parm("name");
materialMap[name] = loadMaterial(xml->children[0]);
}
void CoronaLoader::loadMapDefinition(const Ref<XML>& xml)
{
if (xml->name != "mapDefinition")
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid map definition: "+xml->name);
if (xml->children.size() != 1)
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid map definition");
const std::string name = xml->parm("name");
std::shared_ptr<Texture> texture = loadMap(xml->children[0]);
if (texture) textureMap[name] = texture;
}
void createTriangleMeshTriangle4i(TriangleMesh* mesh, AccelData*& accel, Builder*& builder)
{
if (mesh->numTimeSteps != 1) THROW_RUNTIME_ERROR("internal error");
accel = new BVH4(Triangle4i::type,mesh->parent,LeafMode);
switch (mesh->flags) {
case RTC_GEOMETRY_STATIC: builder = BVH4Triangle4iMeshBuilderSAH(accel,mesh,LeafMode); break;
case RTC_GEOMETRY_DEFORMABLE: builder = BVH4Triangle4iMeshRefitSAH(accel,mesh,LeafMode); break;
case RTC_GEOMETRY_DYNAMIC: builder = BVH4Triangle4iMeshBuilderMortonGeneral(accel,mesh,LeafMode); break;
default: THROW_RUNTIME_ERROR("internal error");
}
}
void init(const boost::property_tree::ptree& pt) throw(std::runtime_error) {
if (m_acceptor.is_open())
m_acceptor.close();
std::string url = pt.get<std::string>("address", "");
std::string proto, addr, port, path;
if (url.empty() || !parse_url(url, proto, addr, port, path))
THROW_RUNTIME_ERROR("Invalid URL address: '" << url << "'");
if (proto != "uds")
THROW_RUNTIME_ERROR("Expected 'uds' protocol type!");
if (path.empty())
THROW_RUNTIME_ERROR("uds_server empty 'address' configuration");
m_endpoint.path(path);
}
/*! creates thread local storage */
tls_t createTls() {
pthread_key_t* key = new pthread_key_t;
if (pthread_key_create(key,NULL) != 0)
THROW_RUNTIME_ERROR("pthread_key_create");
return tls_t(key);
}
void TaskSchedulerSys::add(ssize_t threadIndex, QUEUE queue, Task* task)
{
if (task->event)
task->event->inc();
mutex.lock();
/*! resize array if too small */
if (end-begin == tasks.size())
{
size_t s0 = 1*tasks.size();
size_t s1 = 2*tasks.size();
tasks.resize(s1);
for (size_t i=begin; i!=end; i++)
tasks[i&(s1-1)] = tasks[i&(s0-1)];
}
/*! insert task to correct end of list */
switch (queue) {
case GLOBAL_FRONT: { size_t i = (--begin)&(tasks.size()-1); tasks[i] = task; break; }
case GLOBAL_BACK : { size_t i = (end++ )&(tasks.size()-1); tasks[i] = task; break; }
default : THROW_RUNTIME_ERROR("invalid task queue");
}
condition.broadcast();
mutex.unlock();
}
void Scene::createHairAccel()
{
if (g_hair_accel == "default")
{
if (isStatic()) {
int mode = 2*(int)isCompact() + 1*(int)isRobust();
switch (mode) {
case /*0b00*/ 0: accels.add(BVH4::BVH4OBBBezier1v(this,isHighQuality())); break;
case /*0b01*/ 1: accels.add(BVH4::BVH4OBBBezier1v(this,isHighQuality())); break;
case /*0b10*/ 2: accels.add(BVH4::BVH4OBBBezier1i(this,isHighQuality())); break;
case /*0b11*/ 3: accels.add(BVH4::BVH4OBBBezier1i(this,isHighQuality())); break;
}
}
else
{
int mode = 2*(int)isCompact() + 1*(int)isRobust();
switch (mode) {
case /*0b00*/ 0: accels.add(BVH4::BVH4Bezier1v(this)); break;
case /*0b01*/ 1: accels.add(BVH4::BVH4Bezier1v(this)); break;
case /*0b10*/ 2: accels.add(BVH4::BVH4Bezier1i(this)); break;
case /*0b11*/ 3: accels.add(BVH4::BVH4Bezier1i(this)); break;
}
}
}
else if (g_hair_accel == "bvh4.bezier1v" ) accels.add(BVH4::BVH4Bezier1v(this));
else if (g_hair_accel == "bvh4.bezier1i" ) accels.add(BVH4::BVH4Bezier1i(this));
else if (g_hair_accel == "bvh4obb.bezier1v" ) accels.add(BVH4::BVH4OBBBezier1v(this,false));
else if (g_hair_accel == "bvh4obb.bezier1i" ) accels.add(BVH4::BVH4OBBBezier1i(this,false));
else THROW_RUNTIME_ERROR("unknown hair acceleration structure "+g_hair_accel);
}
Ref<SceneGraph::Node> CoronaLoader::loadGroupNode(const Ref<XML>& xml)
{
if (xml->children.size() < 1)
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid group node");
/* load instances */
auto p = loadInstances(xml->children[0]);
Ref<SceneGraph::MaterialNode> material = p.first;
avector<AffineSpace3fa>& xfms = p.second;
/* load meshes */
Ref<SceneGraph::GroupNode> objects = new SceneGraph::GroupNode;
for (size_t i=1; i<xml->children.size(); i++)
objects->add(loadObject(xml->children[i]));
/* force material */
objects->setMaterial(material);
/* create instances */
Ref<SceneGraph::GroupNode> instances = new SceneGraph::GroupNode;
for (size_t i=0; i<xfms.size(); i++)
instances->add(new SceneGraph::TransformNode(xfms[i],objects.cast<SceneGraph::Node>()));
return instances.cast<SceneGraph::Node>();
}
void TextureAsset::load(XMLElement* fileElement, tinyxml2::XMLDocument& metaDocument)
{
Asset::load(fileElement, metaDocument);
texture = new sf::Texture();
THROW_RUNTIME_ERROR(texture->loadFromFile(rawAssetPath.c_str()) == false, "Unable to load: " + rawAssetPath);
}
void write(socket_t hsock_i, const void* data_i, size_t bytes)
{
#if BUFFERING
const char* data = (const char*) data_i;
buffered_socket_t* hsock = (buffered_socket_t*) hsock_i;
while (bytes) {
if (hsock->oend == hsock->osize) flush(hsock_i);
size_t bsize = hsock->osize-hsock->oend;
if (bytes < bsize) bsize = bytes;
memcpy(hsock->obuf+hsock->oend,data,bsize);
data += bsize;
hsock->oend += bsize;
bytes -= bsize;
}
#else
const char* data = (const char*) data_i;
buffered_socket_t* hsock = (buffered_socket_t*) hsock_i;
while (bytes) {
ssize_t n = ::write(hsock->fd,data,bytes);
if (n < 0) THROW_RUNTIME_ERROR("error writing to socket");
data+=n;
bytes-=n;
}
#endif
}
int ExceptionDialog::wait()
{
if ( !_valid )
{
throw std::invalid_argument("ExceptionDialog is not a valid dialog form!");
return -1;
}
MSG msg;
BOOL result;
while ( (result = GetMessage(&msg, (HWND)_native_handle, 0, 0)) != 0 && IsWindow((HWND)_native_handle) )
{
if ( result == -1 )
{
// Error occured
THROW_RUNTIME_ERROR( std::string("An error occured in GetMessage with code ") + std::to_string(GetLastError()) );
return -1;
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return msg.wParam;
}
MutexSys::~MutexSys( void )
{
if (pthread_mutex_destroy((pthread_mutex_t*)mutex) != 0)
THROW_RUNTIME_ERROR("pthread_mutex_destroy failed");
delete (pthread_mutex_t*)mutex;
}
size_t TaskScheduler::enableThreads(size_t N)
{
if (!instance) THROW_RUNTIME_ERROR("Embree threads not running.");
N = min(N,instance->numThreads);
//TaskScheduler::init(N);
return instance->numEnabledThreads = N;
}
Ref<SceneGraph::PerspectiveCameraNode> TutorialScene::getCamera(const std::string& name)
{
for (size_t i=0; i<cameras.size(); i++)
if (cameras[i]->name == name) return cameras[i];
THROW_RUNTIME_ERROR("camera \"" + name +"\" not found");
}
/*! loads an image from a file with auto-detection of format */
Ref<Image> loadImageFromDisk(const FileName& fileName) try
{
std::string ext = std::strlwr(fileName.ext());
#ifdef USE_OPENEXR
if (ext == "exr" ) return loadExr(fileName);
#endif
#ifdef USE_IMAGEMAGICK
if (ext == "bmp" ) return loadMagick(fileName);
if (ext == "gif" ) return loadMagick(fileName);
if (ext == "png" ) return loadMagick(fileName);
if (ext == "tga" ) return loadMagick(fileName);
if (ext == "tif" ) return loadMagick(fileName);
if (ext == "tiff") return loadMagick(fileName);
#endif
#ifdef USE_LIBJPEG
if (ext == "jpg" ) return loadJPEG(fileName);
#endif
if (ext == "pfm" ) return loadPFM(fileName);
if (ext == "ppm" ) return loadPPM(fileName);
THROW_RUNTIME_ERROR("image format " + ext + " not supported");
}
catch (const std::exception& e) {
std::cout << "cannot read file " << fileName << ": " << e.what() << std::endl;
return null;
}
/*! creates a hardware thread running on specific core */
thread_t createThread(thread_func f, void* arg, size_t stack_size, ssize_t threadID)
{
HANDLE thread = CreateThread(NULL, stack_size, (LPTHREAD_START_ROUTINE)threadStartup, new ThreadStartupData(f,arg), 0, NULL);
if (thread == NULL) THROW_RUNTIME_ERROR("cannot create thread");
if (threadID >= 0) setAffinity(thread, threadID);
return thread_t(thread);
}
void storeTga(const Ref<Image>& img, const FileName& fileName)
{
FILE* file = fopen(fileName.c_str(), "wb");
if (!file) THROW_RUNTIME_ERROR("error opening file " + fileName.str());
fwrite_uchar(0x00, file);
fwrite_uchar(0x00, file);
fwrite_uchar(0x02, file);
fwrite_ushort(0x0000, file);
fwrite_ushort(0x0000, file);
fwrite_ushort(0x0000, file);
fwrite_ushort(0x0000, file);
fwrite_uchar(0x00, file);
fwrite_ushort((unsigned short)img->width , file);
fwrite_ushort((unsigned short)img->height, file);
fwrite_uchar(0x18, file);
fwrite_uchar(0x20, file);
for (size_t y=0; y<img->height; y++) {
for (size_t x=0; x<img->width; x++) {
Color c = img->get(x,y);
fwrite_uchar((unsigned char)(clamp(c.b)*255.0f), file);
fwrite_uchar((unsigned char)(clamp(c.g)*255.0f), file);
fwrite_uchar((unsigned char)(clamp(c.r)*255.0f), file);
}
}
fclose(file);
}
/*! creates a hardware thread running on specific core */
thread_t createThread(thread_func f, void* arg, size_t stack_size, ssize_t threadID)
{
#ifdef __MIC__
threadID++; // start counting at 1 on MIC
#endif
/* set stack size */
pthread_attr_t attr;
pthread_attr_init(&attr);
if (stack_size > 0) pthread_attr_setstacksize (&attr, stack_size);
/* create thread */
pthread_t* tid = new pthread_t;
if (pthread_create(tid,&attr,(void*(*)(void*))threadStartup,new ThreadStartupData(f,arg,threadID)) != 0)
THROW_RUNTIME_ERROR("pthread_create");
/* attempt to set affinity */
#if defined(__LINUX__)
if (threadID >= 0) {
cpu_set_t cset;
CPU_ZERO(&cset);
CPU_SET(threadID, &cset);
pthread_setaffinity_np(*tid,sizeof(cpu_set_t),&cset);
}
#endif
return thread_t(tid);
}
Accel::Intersectors BVH4iTriangle1mcIntersectors(BVH4i* bvh,bool robust)
{
Accel::Intersectors intersectors;
intersectors.ptr = bvh;
intersectors.intersector1 = BVH4iTriangle1mcIntersector1;
if (bvh->device->tri_traverser == "default" || bvh->device->tri_traverser == "hybrid")
{
intersectors.intersector16 = BVH4iTriangle1mcIntersector16HybridMoeller;
intersectors.intersector16_filter = BVH4iTriangle1mcIntersector16HybridMoeller;
intersectors.intersector16_nofilter = BVH4iTriangle1mcIntersector16HybridMoellerNoFilter;
}
else if (bvh->device->tri_traverser == "chunk" )
{
intersectors.intersector16 = BVH4iTriangle1mcIntersector16ChunkMoeller;
intersectors.intersector16_filter = BVH4iTriangle1mcIntersector16ChunkMoeller;
intersectors.intersector16_nofilter = BVH4iTriangle1mcIntersector16ChunkMoellerNoFilter;
}
else if (bvh->device->tri_traverser == "single" )
{
intersectors.intersector16 = BVH4iTriangle1mcIntersector16SingleMoeller;
intersectors.intersector16_filter = BVH4iTriangle1mcIntersector16SingleMoeller;
intersectors.intersector16_nofilter = BVH4iTriangle1mcIntersector16SingleMoellerNoFilter;
}
else THROW_RUNTIME_ERROR("unknown traverser "+bvh->device->tri_traverser+" for BVH4i<Triangle1>");
return intersectors;
}
/*! destroys thread local storage identifier */
void destroyTls(tls_t tls)
{
assert(tls);
if (pthread_key_delete(*(pthread_key_t*)tls) != 0)
THROW_RUNTIME_ERROR("pthread_key_delete");
delete (pthread_key_t*)tls;
}
Texture::Format Texture::string_to_format(const std::string& str)
{
if (str == "RGBA8") return RGBA8;
else if (str == "RGB8") return RGB8;
else if (str == "FLOAT32") return FLOAT32;
else THROW_RUNTIME_ERROR("invalid texture format string");
}
/* load XML from token stream */
Ref<XML> parseXML(Ref<Stream<int> > chars, std::string id, bool hasHeader = true, bool hasTail = false)
{
/* create lexer for XML file */
std::vector<std::string> symbols;
symbols.push_back("<!--");
symbols.push_back("-->");
symbols.push_back("<?");
symbols.push_back("?>");
symbols.push_back("</");
symbols.push_back("/>");
symbols.push_back("<");
symbols.push_back(">");
symbols.push_back("=");
Ref<Stream<Token> > cin = new TokenStream(chars,TokenStream::alpha + TokenStream::ALPHA + "_" + id, TokenStream::separators, symbols);
if (hasHeader) parseHeader(cin);
parseComments(cin);
Ref<XML> xml = parseXML(cin);
parseComments(cin);
if (!hasTail)
if (cin->peek() != Token::Eof()) THROW_RUNTIME_ERROR(cin->peek().Location().str()+": end of file expected");
return xml;
}
/* main function in embree namespace */
int main(int argc, char** argv)
{
/* for best performance set FTZ and DAZ flags in MXCSR control and status register */
_MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
_MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
/* create stream for parsing */
Ref<ParseStream> stream = new ParseStream(new CommandLineStream(argc, argv));
/* parse command line */
parseCommandLine(stream, FileName());
/* load default scene if none specified */
if (filename.ext() == "") {
FileName file = FileName::executableFolder() + FileName("models/cornell_box.ecs");
parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path());
}
/* configure number of threads */
if (g_numThreads)
g_rtcore += ",threads=" + std::to_string((long long)g_numThreads);
if (g_numBenchmarkFrames)
g_rtcore += ",benchmark=1";
g_rtcore += g_subdiv_mode;
/* load scene */
if (strlwr(filename.ext()) == std::string("obj")) {
g_scene->add(loadOBJ(filename,g_subdiv_mode != ""));
}
else if (strlwr(filename.ext()) == std::string("xml")) {
g_scene->add(loadXML(filename,one));
}
else if (filename.ext() != "")
THROW_RUNTIME_ERROR("invalid scene type: "+strlwr(filename.ext()));
/* initialize ray tracing core */
init(g_rtcore.c_str());
/* send model */
g_obj_scene.add(g_scene.dynamicCast<SceneGraph::Node>(),g_instancing_mode);
g_scene = nullptr;
set_scene(&g_obj_scene);
/* benchmark mode */
if (g_numBenchmarkFrames)
renderBenchmark(outFilename);
/* render to disk */
if (outFilename.str() != "")
renderToFile(outFilename);
/* interactive mode */
if (g_interactive) {
initWindowState(argc,argv,tutorialName, g_width, g_height, g_fullscreen);
enterWindowRunLoop(g_anim_mode);
}
return 0;
}
template<> AffineSpace3fa CoronaLoader::load<AffineSpace3fa>(const Ref<XML>& xml)
{
if (xml->body.size() != 12) THROW_RUNTIME_ERROR(xml->loc.str()+": wrong AffineSpace body");
return AffineSpace3fa(LinearSpace3fa(xml->body[0].Float(),xml->body[1].Float(),xml->body[ 2].Float(),
xml->body[4].Float(),xml->body[5].Float(),xml->body[ 6].Float(),
xml->body[8].Float(),xml->body[9].Float(),xml->body[10].Float()),
Vec3fa(xml->body[3].Float(),xml->body[7].Float(),xml->body[11].Float()));
}
