Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files Community
1
name
stringlengths
1
473k
code
stringlengths
7
647k
asm
stringlengths
4
3.39M
file
stringlengths
8
196
Assimp::IFC::Schema_2x3::IfcShapeRepresentation::~IfcShapeRepresentation()
IfcShapeRepresentation() : Object("IfcShapeRepresentation") {}
pushq %rbx movq %rdi, %rbx leaq 0x38637d(%rip), %rax # 0x79a600 movq %rax, (%rdi) leaq 0x38639b(%rip), %rax # 0x79a628 movq %rax, 0xa0(%rdi) movq 0x68(%rdi), %rdi testq %rdi, %rdi je 0x4142a9 movq 0x78(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x40(%rbx), %rdi leaq 0x50(%rbx), %rax cmpq %rax, %rdi je 0x4142c1 movq (%rax), %rsi incq %rsi callq 0x1a5190 movq 0x18(%rbx), %rdi addq $0x28, %rbx cmpq %rbx, %rdi je 0x4142da movq (%rbx), %rsi incq %rsi popq %rbx jmp 0x1a5190 popq %rbx retq
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h
non-virtual thunk to Assimp::IFC::Schema_2x3::IfcShapeRepresentation::~IfcShapeRepresentation()
IfcShapeRepresentation() : Object("IfcShapeRepresentation") {}
pushq %rbx movq %rdi, %rbx leaq 0x3862a9(%rip), %rax # 0x79a600 movq %rax, -0x80(%rdi) leaq 0x3862c6(%rip), %rax # 0x79a628 movq %rax, 0x20(%rdi) movq -0x18(%rdi), %rdi testq %rdi, %rdi je 0x41437b movq -0x8(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq -0x40(%rbx), %rdi leaq -0x30(%rbx), %rax cmpq %rax, %rdi je 0x414393 movq (%rax), %rsi incq %rsi callq 0x1a5190 movq -0x68(%rbx), %rdi addq $-0x58, %rbx cmpq %rbx, %rdi je 0x4143ac movq (%rbx), %rsi incq %rsi popq %rbx jmp 0x1a5190 popq %rbx retq
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h
non-virtual thunk to Assimp::IFC::Schema_2x3::IfcShapeRepresentation::~IfcShapeRepresentation()
IfcShapeRepresentation() : Object("IfcShapeRepresentation") {}
pushq %rbx movq %rdi, %rbx leaq 0x3861cd(%rip), %rax # 0x79a600 movq %rax, -0x90(%rdi) leaq 0x3861e7(%rip), %rax # 0x79a628 movq %rax, 0x10(%rdi) movq -0x28(%rdi), %rdi testq %rdi, %rdi je 0x41445a movq -0x18(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq -0x50(%rbx), %rdi leaq -0x40(%rbx), %rax cmpq %rax, %rdi je 0x414472 movq (%rax), %rsi incq %rsi callq 0x1a5190 movq -0x78(%rbx), %rdi addq $-0x68, %rbx cmpq %rbx, %rdi je 0x41448b movq (%rbx), %rsi incq %rsi popq %rbx jmp 0x1a5190 popq %rbx retq nop
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h
virtual thunk to Assimp::IFC::Schema_2x3::IfcShapeRepresentation::~IfcShapeRepresentation()
IfcShapeRepresentation() : Object("IfcShapeRepresentation") {}
pushq %rbx movq (%rdi), %rax movq -0x18(%rax), %rax leaq (%rdi,%rax), %rbx leaq 0x3860df(%rip), %rcx # 0x79a600 movq %rcx, (%rdi,%rax) leaq 0x3860fc(%rip), %rcx # 0x79a628 movq %rcx, 0xa0(%rdi,%rax) movq 0x68(%rdi,%rax), %rdi testq %rdi, %rdi je 0x41454a movq 0x78(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x40(%rbx), %rdi leaq 0x50(%rbx), %rax cmpq %rax, %rdi je 0x414562 movq (%rax), %rsi incq %rsi callq 0x1a5190 movq 0x18(%rbx), %rdi addq $0x28, %rbx cmpq %rbx, %rdi je 0x41457b movq (%rbx), %rsi incq %rsi popq %rbx jmp 0x1a5190 popq %rbx retq nop
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h
Assimp::IFC::Schema_2x3::IfcDistributionPort::IfcDistributionPort()
IfcDistributionPort() : Object("IfcDistributionPort") {}
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x2d1b04(%rip), %rax # 0x6e6a70 movq %rax, 0x148(%rdi) xorl %r14d, %r14d movq %r14, 0x150(%rdi) leaq 0x1a2781(%rip), %rax # 0x5b7705 movq %rax, 0x158(%rdi) leaq 0x385f46(%rip), %rsi # 0x79aed8 callq 0x415028 movq %r14, 0x118(%rbx) leaq 0x385e2b(%rip), %rax # 0x79add0 movq %rax, (%rbx) leaq 0x385f11(%rip), %rax # 0x79aec0 movq %rax, 0x148(%rbx) leaq 0x385e3b(%rip), %rax # 0x79adf8 movq %rax, 0x88(%rbx) leaq 0x385e55(%rip), %rax # 0x79ae20 movq %rax, 0x98(%rbx) leaq 0x385e6f(%rip), %rax # 0x79ae48 movq %rax, 0xd0(%rbx) leaq 0x385e89(%rip), %rax # 0x79ae70 movq %rax, 0x100(%rbx) leaq 0x385ea3(%rip), %rax # 0x79ae98 movq %rax, 0x110(%rbx) leaq 0x130(%rbx), %rax movq %rax, 0x120(%rbx) movq %r14, 0x128(%rbx) movb %r14b, 0x130(%rbx) movb %r14b, 0x140(%rbx) addq $0x8, %rsp popq %rbx popq %r14 retq nop
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h
Assimp::IFC::(anonymous namespace)::Line::Eval(double) const
IfcVector3 Eval(IfcFloat u) const { return p + u*v; }
movq %rdi, %rax movsd 0x40(%rsi), %xmm1 mulsd %xmm0, %xmm1 addsd 0x28(%rsi), %xmm1 movupd 0x18(%rsi), %xmm2 movupd 0x30(%rsi), %xmm3 unpcklpd %xmm0, %xmm0 # xmm0 = xmm0[0,0] mulpd %xmm3, %xmm0 addpd %xmm2, %xmm0 movupd %xmm0, (%rdi) movsd %xmm1, 0x10(%rdi) retq nop
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCCurve.cpp
Assimp::IFC::CleanupWindowContour(Assimp::IFC::ProjectedWindowContour&)
void CleanupWindowContour(ProjectedWindowContour& window) { std::vector<IfcVector2> scratch; std::vector<IfcVector2>& contour = window.contour; ClipperLib::Polygon subject; ClipperLib::Clipper clipper; ClipperLib::ExPolygons clipped; for(const IfcVector2& pip : contour) { subject.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); } clipper.AddPolygon(subject,ClipperLib::ptSubject); clipper.Execute(ClipperLib::ctUnion,clipped,ClipperLib::pftNonZero,ClipperLib::pftNonZero); // This should yield only one polygon or something went wrong if (clipped.size() != 1) { // Empty polygon? drop the contour altogether if(clipped.empty()) { IFCImporter::LogError("error during polygon clipping, window contour is degenerate"); window.FlagInvalid(); return; } // Else: take the first only IFCImporter::LogError("error during polygon clipping, window contour is not convex"); } ExtractVerticesFromClipper(clipped[0].outer, scratch); // Assume the bounding box doesn't change during this operation }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x128, %rsp # imm = 0x128 movq %rdi, %rbx xorpd %xmm0, %xmm0 movapd %xmm0, 0x40(%rsp) xorl %eax, %eax movq %rax, 0x50(%rsp) movq %rax, 0x10(%rsp) movapd %xmm0, (%rsp) leaq 0x68(%rsp), %r14 movq %r14, %rdi callq 0x506202 xorpd %xmm0, %xmm0 movapd %xmm0, 0x20(%rsp) movq $0x0, 0x30(%rsp) movq (%rbx), %r13 movq 0x8(%rbx), %rbp cmpq %rbp, %r13 je 0x43c9c2 movq %rsp, %r15 leaq 0x58(%rsp), %r12 movsd (%r13), %xmm0 movsd 0x18a1d2(%rip), %xmm1 # 0x5c6b08 mulsd %xmm1, %xmm0 cvttsd2si %xmm0, %rax movq %rax, %rcx sarq $0x3f, %rcx movsd 0x123f22(%rip), %xmm2 # 0x560870 subsd %xmm2, %xmm0 cvttsd2si %xmm0, %rdx andq %rcx, %rdx orq %rax, %rdx movsd 0x8(%r13), %xmm0 mulsd %xmm1, %xmm0 cvttsd2si %xmm0, %rax movq %rax, %rcx subsd %xmm2, %xmm0 cvttsd2si %xmm0, %rsi sarq $0x3f, %rcx andq %rcx, %rsi orq %rax, %rsi movq %rdx, 0x58(%rsp) movq %rsi, 0x60(%rsp) movq 0x8(%rsp), %rsi cmpq 0x10(%rsp), %rsi je 0x43c9aa movupd 0x58(%rsp), %xmm0 movupd %xmm0, (%rsi) addq $0x10, 0x8(%rsp) jmp 0x43c9b5 movq %r15, %rdi movq %r12, %rdx callq 0x442e84 addq $0x10, %r13 cmpq %rbp, %r13 jne 0x43c928 movq 0x68(%rsp), %rax addq -0x18(%rax), %r14 movq %rsp, %rsi movq %r14, %rdi xorl %edx, %edx callq 0x505840 leaq 0x68(%rsp), %rdi leaq 0x20(%rsp), %rdx movl $0x1, %esi movl $0x1, %ecx movl $0x1, %r8d callq 0x5066a0 movq 0x20(%rsp), %rdi movq 0x28(%rsp), %rax movq %rax, %rcx subq %rdi, %rcx cmpq $0x30, %rcx je 0x43ca23 cmpq %rax, %rdi je 0x43ca82 leaq 0x18a1f3(%rip), %rdi # 0x5c6c0c callq 0x3733a6 movq 0x20(%rsp), %rdi leaq 0x40(%rsp), %rsi xorl %edx, %edx callq 0x43ba8f leaq 0x20(%rsp), %rdi callq 0x44228a leaq 0x68(%rsp), %rdi callq 0x50632a movq (%rsp), %rdi testq %rdi, %rdi je 0x43ca59 movq 0x10(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x40(%rsp), %rdi testq %rdi, %rdi je 0x43ca70 movq 0x50(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 addq $0x128, %rsp # imm = 0x128 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x18a147(%rip), %rdi # 0x5c6bd0 callq 0x3733a6 movq (%rbx), %rax cmpq %rax, 0x8(%rbx) je 0x43ca2f movq %rax, 0x8(%rbx) jmp 0x43ca2f movq %rax, %rbx jmp 0x43cad1 jmp 0x43caa4 movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x44228a leaq 0x68(%rsp), %rdi callq 0x50632a movq (%rsp), %rdi testq %rdi, %rdi je 0x43cad1 movq 0x10(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x40(%rsp), %rdi testq %rdi, %rdi je 0x43cae8 movq 0x50(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCOpenings.cpp
Assimp::IFC::FindLikelyCrossingLines(__gnu_cxx::__normal_iterator<Assimp::IFC::ProjectedWindowContour*, std::vector<Assimp::IFC::ProjectedWindowContour, std::allocator<Assimp::IFC::ProjectedWindowContour>>>)
void FindLikelyCrossingLines(ContourVector::iterator current) { SkipList& skiplist = (*current).skiplist; IfcVector2 last_proj_point; const Contour::const_iterator cbegin = (*current).contour.begin(), cend = (*current).contour.end(); for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) { const IfcVector2& proj_point = *cit; if (cit != cbegin) { IfcVector2 vdelta = proj_point - last_proj_point; if (LikelyDiagonal(vdelta)) { skiplist[std::distance(cbegin, cit) - 1] = true; } } last_proj_point = proj_point; } // handle last segment if (LikelyDiagonal(*cbegin - last_proj_point)) { skiplist[skiplist.size()-1] = true; } }
pushq %rbx movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000 movq (%rdi), %rdx movq 0x8(%rdi), %rsi cmpq %rsi, %rdx je 0x43df2d xorpd %xmm3, %xmm3 xorl %r8d, %r8d movapd 0x122760(%rip), %xmm0 # 0x5605e0 movsd 0x188ca8(%rip), %xmm1 # 0x5c6b30 leaq 0x3f(%rax), %r9 movsd (%rdx,%r8), %xmm2 testq %r8, %r8 je 0x43df0d movapd %xmm2, %xmm4 movhpd 0x8(%rdx,%r8), %xmm4 # xmm4 = xmm4[0],mem[0] subpd %xmm3, %xmm4 andpd %xmm0, %xmm4 pshufd $0xee, %xmm4, %xmm3 # xmm3 = xmm4[2,3,2,3] movapd %xmm4, %xmm5 subsd %xmm3, %xmm5 andpd %xmm0, %xmm5 maxsd %xmm4, %xmm3 mulsd %xmm1, %xmm3 ucomisd %xmm5, %xmm3 jbe 0x43df0d movq %r8, %r10 sarq $0x4, %r10 leaq -0x1(%r10), %rcx addq $0x3e, %r10 testq %rcx, %rcx cmovnsq %rcx, %r10 sarq $0x6, %r10 shlq $0x3, %r10 addq 0x38(%rdi), %r10 movq %rcx, %r11 andq %r9, %r11 xorl %ebx, %ebx cmpq %rax, %r11 setbe %bl movl $0x1, %r11d shlq %cl, %r11 orq %r11, -0x8(%r10,%rbx,8) movsd (%rdx,%r8), %xmm2 leaq (%rdx,%r8), %rcx addq $0x10, %rcx movhpd -0x8(%rcx), %xmm2 # xmm2 = xmm2[0],mem[0] addq $0x10, %r8 movapd %xmm2, %xmm3 cmpq %rsi, %rcx jne 0x43de8c jmp 0x43df31 xorpd %xmm2, %xmm2 movupd (%rdx), %xmm0 subpd %xmm2, %xmm0 movapd 0x12269f(%rip), %xmm1 # 0x5605e0 andpd %xmm1, %xmm0 pshufd $0xee, %xmm0, %xmm2 # xmm2 = xmm0[2,3,2,3] movapd %xmm0, %xmm3 subsd %xmm2, %xmm3 andpd %xmm1, %xmm3 maxsd %xmm0, %xmm2 mulsd 0x188bce(%rip), %xmm2 # 0x5c6b30 ucomisd %xmm3, %xmm2 jbe 0x43dfb2 movq 0x38(%rdi), %rdx movq 0x48(%rdi), %rsi movl 0x50(%rdi), %edi subq %rdx, %rsi leaq (%rdi,%rsi,8), %rcx decq %rcx leaq (%rdi,%rsi,8), %rsi addq $0x3e, %rsi testq %rcx, %rcx cmovnsq %rcx, %rsi sarq $0x6, %rsi leaq 0x3f(%rax), %rdi andq %rcx, %rdi xorl %r8d, %r8d cmpq %rax, %rdi setbe %r8b movl $0x1, %eax shlq %cl, %rax leaq (%rdx,%rsi,8), %rcx orq %rax, -0x8(%rcx,%r8,8) popq %rbx retq
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCOpenings.cpp
Assimp::FBXImporter::SetupProperties(Assimp::Importer const*)
void FBXImporter::SetupProperties(const Importer* pImp) { settings.readAllLayers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS, true); settings.readAllMaterials = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS, false); settings.readMaterials = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_MATERIALS, true); settings.readTextures = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_TEXTURES, true); settings.readCameras = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_CAMERAS, true); settings.readLights = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_LIGHTS, true); settings.readAnimations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS, true); settings.strictMode = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_STRICT_MODE, false); settings.preservePivots = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, true); settings.optimizeEmptyAnimationCurves = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES, true); settings.useLegacyEmbeddedTextureNaming = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING, false); settings.removeEmptyBones = pImp->GetPropertyBool(AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES, true); settings.convertToMeters = pImp->GetPropertyBool(AI_CONFIG_FBX_CONVERT_TO_M, false); }
pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx leaq 0x17e6c6(%rip), %rsi # 0x5c7c05 movq %r14, %rdi movl $0x1, %edx callq 0x23ba82 testl %eax, %eax setne 0x79(%rbx) leaq 0x17e6d0(%rip), %rsi # 0x5c7c29 movq %r14, %rdi xorl %edx, %edx callq 0x23ba82 testl %eax, %eax setne 0x7a(%rbx) leaq 0x17e6d7(%rip), %rsi # 0x5c7c47 movq %r14, %rdi movl $0x1, %edx callq 0x23ba82 testl %eax, %eax setne 0x7b(%rbx) leaq 0x17e6d7(%rip), %rsi # 0x5c7c61 movq %r14, %rdi movl $0x1, %edx callq 0x23ba82 testl %eax, %eax setne 0x7c(%rbx) leaq 0x17e6d6(%rip), %rsi # 0x5c7c7a movq %r14, %rdi movl $0x1, %edx callq 0x23ba82 testl %eax, %eax setne 0x7d(%rbx) leaq 0x17e6d4(%rip), %rsi # 0x5c7c92 movq %r14, %rdi movl $0x1, %edx callq 0x23ba82 testl %eax, %eax setne 0x7e(%rbx) leaq 0x17e6d1(%rip), %rsi # 0x5c7ca9 movq %r14, %rdi movl $0x1, %edx callq 0x23ba82 testl %eax, %eax setne 0x7f(%rbx) leaq 0x17e6d2(%rip), %rsi # 0x5c7cc4 movq %r14, %rdi xorl %edx, %edx callq 0x23ba82 testl %eax, %eax setne 0x78(%rbx) leaq 0x17e6d2(%rip), %rsi # 0x5c7cdb movq %r14, %rdi movl $0x1, %edx callq 0x23ba82 testl %eax, %eax setne 0x81(%rbx) leaq 0x17e6d0(%rip), %rsi # 0x5c7cf6 movq %r14, %rdi movl $0x1, %edx callq 0x23ba82 testl %eax, %eax setne 0x82(%rbx) leaq 0x17e6de(%rip), %rsi # 0x5c7d21 movq %r14, %rdi xorl %edx, %edx callq 0x23ba82 testl %eax, %eax setne 0x83(%rbx) leaq 0x17e6f9(%rip), %rsi # 0x5c7d56 movq %r14, %rdi movl $0x1, %edx callq 0x23ba82 testl %eax, %eax setne 0x84(%rbx) leaq 0x17e700(%rip), %rsi # 0x5c7d7a movq %r14, %rdi xorl %edx, %edx callq 0x23ba82 testl %eax, %eax setne 0x85(%rbx) addq $0x8, %rsp popq %rbx popq %r14 retq nop
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXImporter.cpp
Assimp::FBX::GetRequiredScope(Assimp::FBX::Element const&)
Scope::Scope(Parser& parser,bool topLevel) { if(!topLevel) { TokenPtr t = parser.CurrentToken(); if (t->Type() != TokenType_OPEN_BRACKET) { ParseError("expected open bracket",t); } } TokenPtr n = parser.AdvanceToNextToken(); if(n == NULL) { ParseError("unexpected end of file"); } // note: empty scopes are allowed while(n->Type() != TokenType_CLOSE_BRACKET) { if (n->Type() != TokenType_KEY) { ParseError("unexpected token, expected TOK_KEY",n); } const std::string& str = n->StringContents(); elements.insert(ElementMap::value_type(str,new_Element(*n,parser))); // Element() should stop at the next Key token (or right after a Close token) n = parser.CurrentToken(); if(n == NULL) { if (topLevel) { return; } ParseError("unexpected end of file",parser.LastToken()); } } }
pushq %r15 pushq %r14 pushq %rbx subq $0x20, %rsp movq 0x20(%rdi), %rax testq %rax, %rax je 0x44ad33 addq $0x20, %rsp popq %rbx popq %r14 popq %r15 retq movq %rdi, %rbx leaq 0x10(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x17d74d(%rip), %rsi # 0x5c8493 leaq 0x17d75d(%rip), %rdx # 0x5c84aa movq %rsp, %r14 movq %r14, %rdi callq 0x209290 movq %r14, %rdi movq %rbx, %rsi callq 0x44a180 movq %rax, %rbx movq (%rsp), %rdi cmpq %r15, %rdi je 0x44ad7c movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXParser.cpp
Assimp::FBX::FBXConverter::ConvertVideo(Assimp::FBX::Video const&)
unsigned int FBXConverter::ConvertVideo(const Video& video) { // generate empty output texture aiTexture* out_tex = new aiTexture(); textures.push_back(out_tex); // assuming the texture is compressed out_tex->mWidth = static_cast<unsigned int>(video.ContentLength()); // total data size out_tex->mHeight = 0; // fixed to 0 // steal the data from the Video to avoid an additional copy out_tex->pcData = reinterpret_cast<aiTexel*>(const_cast<Video&>(video).RelinquishContent()); // try to extract a hint from the file extension const std::string& filename = video.RelativeFilename().empty() ? video.FileName() : video.RelativeFilename(); std::string ext = BaseImporter::GetExtension(filename); if (ext == "jpeg") { ext = "jpg"; } if (ext.size() <= 3) { memcpy(out_tex->achFormatHint, ext.c_str(), ext.size()); } out_tex->mFilename.Set(filename.c_str()); return static_cast<unsigned int>(textures.size() - 1); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rsi, %r14 movq %rdi, %rbx movl $0x428, %edi # imm = 0x428 callq 0x1a5230 movq %rax, %r15 xorl %r12d, %r12d movq %r12, (%rax) movq %r12, 0x18(%rax) movl %r12d, 0x20(%rax) movb $0x0, 0x24(%rax) leaq 0x25(%rax), %rdi movl $0x3ff, %edx # imm = 0x3FF movl $0x1b, %esi callq 0x1a54e0 movl %r12d, 0x8(%r15) movq %r15, (%rsp) movq 0x88(%rbx), %rsi cmpq 0x90(%rbx), %rsi je 0x458da4 movq %r15, (%rsi) addq $0x8, 0x88(%rbx) jmp 0x458db9 leaq 0x80(%rbx), %rdi movq %rsp, %r15 movq %r15, %rdx callq 0x2afa3e movq (%r15), %r15 movl 0xa8(%r14), %eax movl %eax, (%r15) movq (%rsp), %rax movl $0x0, 0x4(%rax) movq 0xb0(%r14), %rax movq $0x0, 0xb0(%r14) movq (%rsp), %rcx movq %rax, 0x18(%rcx) xorl %eax, %eax cmpq $0x0, 0x60(%r14) sete %al shll $0x5, %eax addq %rax, %r14 addq $0x58, %r14 leaq 0x8(%rsp), %r15 movq %r15, %rdi movq %r14, %rsi callq 0x24818a leaq 0x13b27d(%rip), %rsi # 0x594090 movq %r15, %rdi callq 0x1a60c0 testl %eax, %eax jne 0x458e3c leaq 0x8(%rsp), %rdi movq 0x8(%rdi), %rdx leaq 0x111fcc(%rip), %rcx # 0x56adfb movl $0x3, %r8d xorl %esi, %esi callq 0x1a5830 movq 0x10(%rsp), %rdx cmpq $0x3, %rdx ja 0x458e59 movq (%rsp), %rdi addq $0x8, %rdi movq 0x8(%rsp), %rsi callq 0x1a5110 movq (%r14), %r14 movq %r14, %rdi callq 0x1a56a0 cmpl $0x3ff, %eax # imm = 0x3FF jg 0x458e8d movq (%rsp), %r12 movl %eax, 0x20(%r12) leaq 0x24(%r12), %rdi movslq %eax, %r15 movq %r14, %rsi movq %r15, %rdx callq 0x1a5110 movb $0x0, 0x24(%r12,%r15) movq 0x80(%rbx), %r14 movq 0x88(%rbx), %rbx leaq 0x18(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x458eb6 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 subq %r14, %rbx shrq $0x3, %rbx decl %ebx movl %ebx, %eax addq $0x28, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq movq %rax, %rbx leaq 0x18(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x458eeb movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXConverter.cpp
Assimp::FBX::ShapeGeometry::ShapeGeometry(unsigned long, Assimp::FBX::Element const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::FBX::Document const&)
ShapeGeometry::ShapeGeometry(uint64_t id, const Element& element, const std::string& name, const Document& doc) : Geometry(id, element, name, doc) { const Scope *sc = element.Compound(); if (nullptr == sc) { DOMError("failed to read Geometry object (class: Shape), no data scope found"); } const Element& Indexes = GetRequiredElement(*sc, "Indexes", &element); const Element& Normals = GetRequiredElement(*sc, "Normals", &element); const Element& Vertices = GetRequiredElement(*sc, "Vertices", &element); ParseVectorDataArray(m_indices, Indexes); ParseVectorDataArray(m_vertices, Vertices); ParseVectorDataArray(m_normals, Normals); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rdx, %r13 movq %rdi, %rbx callq 0x46ac14 leaq 0x331c3e(%rip), %rax # 0x79e890 movq %rax, (%rbx) leaq 0x58(%rbx), %rax movq %rax, 0x28(%rsp) leaq 0x70(%rbx), %rax movq %rax, 0x20(%rsp) leaq 0x88(%rbx), %rax movq %rax, 0x30(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x58(%rbx) movups %xmm0, 0x68(%rbx) movups %xmm0, 0x78(%rbx) movups %xmm0, 0x88(%rbx) movq $0x0, 0x98(%rbx) movq 0x20(%r13), %rbp leaq 0x10(%rsp), %r12 movq %rsp, %rdi testq %rbp, %rbp je 0x46cd9c movq %r12, (%rdi) leaq 0x15e9bf(%rip), %rsi # 0x5cb672 leaq 0x15e9bf(%rip), %rdx # 0x5cb679 callq 0x209290 movq %rsp, %rsi movq %rbp, %rdi movq %r13, %rdx callq 0x44ad84 movq %rax, %r14 movq (%rsp), %rdi cmpq %r12, %rdi je 0x46cce6 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rsp, %rdi movq %r12, (%rdi) leaq 0x161db4(%rip), %rsi # 0x5ceaa7 leaq 0x161db4(%rip), %rdx # 0x5ceaae callq 0x209290 movq %rsp, %rsi movq %rbp, %rdi movq %r13, %rdx callq 0x44ad84 movq %rax, %r15 movq (%rsp), %rdi cmpq %r12, %rdi je 0x46cd26 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rsp, %rdi movq %r12, (%rdi) leaq 0x13c055(%rip), %rsi # 0x5a8d88 leaq 0x13c056(%rip), %rdx # 0x5a8d90 callq 0x209290 movq %rsp, %rsi movq %rbp, %rdi movq %r13, %rdx callq 0x44ad84 movq %rax, %r13 movq (%rsp), %rdi cmpq %r12, %rdi je 0x46cd66 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x30(%rsp), %rdi movq %r14, %rsi callq 0x44bb49 movq 0x28(%rsp), %rdi movq %r13, %rsi callq 0x44a6c6 movq 0x20(%rsp), %rdi movq %r15, %rsi callq 0x44a6c6 addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %r12, (%rdi) leaq 0x15e889(%rip), %rsi # 0x5cb62f leaq 0x15e8c4(%rip), %rdx # 0x5cb671 callq 0x209290 movq %rsp, %rdi xorl %esi, %esi callq 0x477c39 jmp 0x46cdc8 jmp 0x46cde5 jmp 0x46cdc8 jmp 0x46cde5 jmp 0x46cdc8 jmp 0x46cde5 movq %rax, %r13 movq (%rsp), %rdi cmpq %r12, %rdi je 0x46cde8 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x46cde8 jmp 0x46cde5 movq %rax, %r13 movq 0x30(%rsp), %rax movq (%rax), %rdi testq %rdi, %rdi je 0x46ce04 movq 0x98(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x20(%rsp), %rax movq (%rax), %rdi testq %rdi, %rdi je 0x46ce20 movq 0x80(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x28(%rsp), %rax movq (%rax), %rdi testq %rdi, %rdi je 0x46ce39 movq 0x68(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x46ad5a movq %r13, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXMeshGeometry.cpp
Assimp::FBX::LayeredTexture::fillTexture(Assimp::FBX::Document const&)
void LayeredTexture::fillTexture(const Document& doc) { const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID()); for(size_t i = 0; i < conns.size();++i) { const Connection* con = conns.at(i); const Object* const ob = con->SourceObject(); if(!ob) { DOMWarning("failed to read source object for texture link, ignoring",&element); continue; } const Texture* const tex = dynamic_cast<const Texture*>(ob); textures.push_back(tex); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx movq 0x30(%rdi), %rdx leaq 0x30(%rsp), %r14 movq %r14, %rdi callq 0x467ae6 movq (%r14), %rdi cmpq %rdi, 0x8(%r14) je 0x470138 leaq 0x38(%rbx), %rax movq %rax, 0x8(%rsp) leaq 0x20(%rsp), %r12 xorl %r14d, %r14d leaq 0x10(%rsp), %r13 leaq 0x32e5a0(%rip), %rbp # 0x79e630 leaq 0x32e8a9(%rip), %r15 # 0x79e940 movq (%rdi,%r14,8), %rdi callq 0x467c06 testq %rax, %rax je 0x4700ce movq %rax, %rdi movq %rbp, %rsi movq %r15, %rdx xorl %ecx, %ecx callq 0x1a6190 movq %rax, 0x10(%rsp) movq 0x40(%rbx), %rsi cmpq 0x48(%rbx), %rsi je 0x47010e movq %rax, (%rsi) addq $0x8, 0x40(%rbx) jmp 0x47011b movq %r12, 0x10(%rsp) movq %r13, %rdi leaq 0x15b844(%rip), %rsi # 0x5cb921 leaq 0x15b874(%rip), %rdx # 0x5cb958 callq 0x209290 movq 0x8(%rbx), %rsi movq %r13, %rdi callq 0x477dc2 movq 0x10(%rsp), %rdi cmpq %r12, %rdi je 0x47011b movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x47011b movq 0x8(%rsp), %rdi movq %r13, %rdx callq 0x472140 incq %r14 movq 0x30(%rsp), %rdi movq 0x38(%rsp), %rax subq %rdi, %rax sarq $0x3, %rax cmpq %rax, %r14 jb 0x470097 testq %rdi, %rdi je 0x47014a movq 0x40(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x470179 jmp 0x470179 movq %rax, %rbx movq 0x10(%rsp), %rdi cmpq %r12, %rdi je 0x47017c movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x47017c movq %rax, %rbx movq 0x30(%rsp), %rdi testq %rdi, %rdi je 0x470193 movq 0x40(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXMaterial.cpp
Assimp::FBX::Scope::FindElementCaseInsensitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const Element* FindElementCaseInsensitive(const std::string& elementName) const { const char* elementNameCStr = elementName.c_str(); for (auto element = elements.begin(); element != elements.end(); ++element) { if (!ASSIMP_strincmp(element->first.c_str(), elementNameCStr, MAXLEN)) { return element->second; } } return NULL; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %r14 movq 0x18(%rdi), %r15 addq $0x8, %r14 cmpq %r14, %r15 je 0x47186e movq (%rsi), %r12 xorl %ebx, %ebx movq 0x20(%r15), %rdi testq %rdi, %rdi je 0x4718a4 testq %r12, %r12 je 0x471885 movl $0x400, %edx # imm = 0x400 movq %r12, %rsi callq 0x1a61b0 testl %eax, %eax je 0x471872 movq %r15, %rdi callq 0x1a60d0 movq %rax, %r15 cmpq %r14, %rax jne 0x47183d jmp 0x471876 xorl %ebx, %ebx jmp 0x471876 movq 0x40(%r15), %rbx movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq leaq 0x121735(%rip), %rdi # 0x592fc1 leaq 0x12167a(%rip), %rsi # 0x592f0d leaq 0x1272fc(%rip), %rcx # 0x598b96 movl $0xc0, %edx callq 0x1a5270 leaq 0x12677f(%rip), %rdi # 0x59802a leaq 0x12165b(%rip), %rsi # 0x592f0d leaq 0x1272dd(%rip), %rcx # 0x598b96 movl $0xbf, %edx callq 0x1a5270 nop
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXParser.h
Assimp::FBX::Model::~Model()
Model::~Model() { }
pushq %rbx movq %rdi, %rbx leaq 0x32c15f(%rip), %rax # 0x79ea10 movq %rax, (%rdi) movq 0xc8(%rdi), %rdi testq %rdi, %rdi je 0x4728c5 callq 0x280464 movq 0xa0(%rbx), %rdi leaq 0xb0(%rbx), %rax cmpq %rax, %rdi je 0x4728e3 movq (%rax), %rsi incq %rsi callq 0x1a5190 movq 0x80(%rbx), %rdi leaq 0x90(%rbx), %rax cmpq %rax, %rdi je 0x472901 movq (%rax), %rsi incq %rsi callq 0x1a5190 movq 0x68(%rbx), %rdi testq %rdi, %rdi je 0x472916 movq 0x78(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x50(%rbx), %rdi testq %rdi, %rdi je 0x47292b movq 0x60(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x38(%rbx), %rdi testq %rdi, %rdi je 0x472940 movq 0x48(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi popq %rbx jmp 0x465b1c nop
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXModel.cpp
Assimp::FBX::AnimationCurve::~AnimationCurve()
AnimationCurve::~AnimationCurve() { // empty }
pushq %rbx movq %rdi, %rbx leaq 0x32b7fd(%rip), %rax # 0x79ea60 movq %rax, (%rdi) movq 0x80(%rdi), %rdi testq %rdi, %rdi je 0x473281 movq 0x90(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x68(%rbx), %rdi testq %rdi, %rdi je 0x473296 movq 0x78(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x50(%rbx), %rdi testq %rdi, %rdi je 0x4732ab movq 0x60(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x38(%rbx), %rdi testq %rdi, %rdi je 0x4732c0 movq 0x48(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi popq %rbx jmp 0x465b1c nop
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXAnimation.cpp
Assimp::FBX::AnimationLayer::AnimationLayer(unsigned long, Assimp::FBX::Element const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::FBX::Document const&)
AnimationLayer::AnimationLayer(uint64_t id, const Element& element, const std::string& name, const Document& doc) : Object(id, element, name) , doc(doc) { const Scope& sc = GetRequiredScope(element); // note: the props table here bears little importance and is usually absent props = GetPropertyTable(doc,"AnimationLayer.FbxAnimLayer",element,sc, true); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x30, %rsp movq %r8, %r15 movq %rdx, %r14 movq %rdi, %rbx callq 0x465adc leaq 0x32b1cc(%rip), %rax # 0x79ead0 movq %rax, (%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0x38(%rbx) movq %r15, 0x48(%rbx) movq %r14, %rdi callq 0x44ad17 movq %rax, %r12 leaq 0x20(%rsp), %r13 movq %r13, -0x10(%r13) leaq 0x158562(%rip), %rsi # 0x5cbe8f leaq 0x158576(%rip), %rdx # 0x5cbeaa leaq 0x10(%rsp), %rdi callq 0x209290 movq %rsp, %rdi leaq 0x10(%rsp), %rdx movq %r15, %rsi movq %r14, %rcx movq %r12, %r8 movl $0x1, %r9d callq 0x477e64 movaps (%rsp), %xmm0 xorps %xmm1, %xmm1 movaps %xmm1, (%rsp) movq 0x40(%rbx), %rdi movups %xmm0, 0x38(%rbx) testq %rdi, %rdi je 0x473986 callq 0x280464 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x473986 callq 0x280464 movq 0x10(%rsp), %rdi cmpq %r13, %rdi je 0x47399d movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x30, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq movq %rax, %r14 movq 0x10(%rsp), %rdi cmpq %r13, %rdi je 0x4739cc movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x4739cc jmp 0x4739c9 movq %rax, %r14 movq 0x40(%rbx), %rdi testq %rdi, %rdi je 0x4739da callq 0x280464 movq %rbx, %rdi callq 0x465b1c movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXAnimation.cpp
Assimp::FBX::AnimationStack::AnimationStack(unsigned long, Assimp::FBX::Element const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::FBX::Document const&)
AnimationStack::AnimationStack(uint64_t id, const Element& element, const std::string& name, const Document& doc) : Object(id, element, name) { const Scope& sc = GetRequiredScope(element); // note: we don't currently use any of these properties so we shouldn't bother if it is missing props = GetPropertyTable(doc,"AnimationStack.FbxAnimStack",element,sc, true); // resolve attached animation layers const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(),"AnimationLayer"); layers.reserve(conns.size()); for(const Connection* con : conns) { // link should not go to a property if (con->PropertyName().length()) { continue; } const Object* const ob = con->SourceObject(); if(!ob) { DOMWarning("failed to read source object for AnimationLayer->AnimationStack link, ignoring",&element); continue; } const AnimationLayer* const anim = dynamic_cast<const AnimationLayer*>(ob); if(!anim) { DOMWarning("source object for ->AnimationStack link is not an AnimationLayer",&element); continue; } layers.push_back(anim); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %r8, %r14 movq %rdx, %r15 movq %rdi, %rbx callq 0x465adc leaq 0x32ae65(%rip), %rax # 0x79eb08 movq %rax, (%rbx) leaq 0x48(%rbx), %rax movq %rax, 0x38(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x38(%rbx) movups %xmm0, 0x48(%rbx) movq $0x0, 0x58(%rbx) movq %r15, %rdi callq 0x44ad17 movq %rax, %r12 leaq 0x10(%rsp), %r13 movq %r13, -0x10(%r13) leaq 0x158266(%rip), %rsi # 0x5cbf43 leaq 0x15827a(%rip), %rdx # 0x5cbf5e movq %rsp, %rdi callq 0x209290 leaq 0x20(%rsp), %rdi movq %rsp, %rdx movq %r14, %rsi movq %r15, %rcx movq %r12, %r8 movl $0x1, %r9d callq 0x477e64 movaps 0x20(%rsp), %xmm0 xorps %xmm1, %xmm1 movaps %xmm1, 0x20(%rsp) movq 0x40(%rbx), %rdi movups %xmm0, 0x38(%rbx) testq %rdi, %rdi je 0x473d36 callq 0x280464 movq 0x28(%rsp), %rdi testq %rdi, %rdi je 0x473d36 callq 0x280464 movq (%rsp), %rdi cmpq %r13, %rdi je 0x473d4c movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x30(%rbx), %rdx leaq 0x158289(%rip), %rcx # 0x5cbfe0 leaq 0x20(%rsp), %rdi movq %r14, %rsi callq 0x467a8c movq 0x28(%rsp), %rsi subq 0x20(%rsp), %rsi sarq $0x3, %rsi movq 0x38(%rsp), %rdi callq 0x474092 movq 0x20(%rsp), %r12 movq 0x28(%rsp), %rbp cmpq %rbp, %r12 je 0x473e6f movq %rsp, %r14 movq (%r12), %rdi cmpq $0x0, 0x10(%rdi) je 0x473dab addq $0x8, %r12 cmpq %rbp, %r12 jne 0x473d92 jmp 0x473e6a callq 0x467c06 testq %rax, %rax je 0x473deb movq %rax, %rdi leaq 0x32a871(%rip), %rsi # 0x79e630 leaq 0x32ad52(%rip), %rdx # 0x79eb18 xorl %ecx, %ecx callq 0x1a6190 movq %rax, 0x40(%rsp) testq %rax, %rax je 0x473e12 movq 0x50(%rbx), %rsi cmpq 0x58(%rbx), %rsi je 0x473e56 movq %rax, (%rsi) addq $0x8, 0x50(%rbx) jmp 0x473d9d movq %r13, (%rsp) movq %r14, %rdi leaq 0x158166(%rip), %rsi # 0x5cbf5f leaq 0x1581ad(%rip), %rdx # 0x5cbfad callq 0x209290 movq %r14, %rdi movq %r15, %rsi callq 0x477dc2 jmp 0x473e37 movq %r13, (%rsp) movq %r14, %rdi leaq 0x15818e(%rip), %rsi # 0x5cbfae leaq 0x1581c7(%rip), %rdx # 0x5cbfee callq 0x209290 movq %r14, %rdi movq %r15, %rsi callq 0x477dc2 movq (%rsp), %rdi cmpq %r13, %rdi je 0x473d9d movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x473d9d movq 0x38(%rsp), %rdi leaq 0x40(%rsp), %rdx callq 0x474518 jmp 0x473d9d movq 0x20(%rsp), %r12 testq %r12, %r12 je 0x473e84 movq 0x30(%rsp), %rsi subq %r12, %rsi movq %r12, %rdi callq 0x1a5190 addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x473ed7 jmp 0x473eaf movq %rax, %r15 movq (%rsp), %rdi cmpq %r13, %rdi je 0x473ef1 movq 0x10(%rsp), %rsi incq %rsi jmp 0x473eec jmp 0x473eaf movq %rax, %r15 jmp 0x473ef1 jmp 0x473ed7 jmp 0x473eba jmp 0x473ed7 movq %rax, %r15 movq (%rsp), %rdi cmpq %r13, %rdi je 0x473eda movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x473eda jmp 0x473ed7 movq %rax, %r15 movq 0x20(%rsp), %rdi testq %rdi, %rdi je 0x473ef1 movq 0x30(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x38(%rsp), %rax movq (%rax), %rdi testq %rdi, %rdi je 0x473f0a movq 0x58(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x40(%rbx), %rdi testq %rdi, %rdi je 0x473f18 callq 0x280464 movq %rbx, %rdi callq 0x465b1c movq %r15, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXAnimation.cpp
Assimp::FBX::CameraSwitcher::~CameraSwitcher()
CameraSwitcher::~CameraSwitcher() { // empty }
pushq %rbx movq %rdi, %rbx leaq 0x32a0c3(%rip), %rax # 0x79eb78 movq %rax, (%rdi) movq 0x70(%rdi), %rdi leaq 0x80(%rbx), %rax cmpq %rax, %rdi je 0x474ad3 movq (%rax), %rsi incq %rsi callq 0x1a5190 movq 0x50(%rbx), %rdi leaq 0x60(%rbx), %rax cmpq %rax, %rdi je 0x474aeb movq (%rax), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi popq %rbx jmp 0x4747c4
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXNodeAttribute.cpp
Assimp::FBX::BlendShapeChannel::BlendShapeChannel(unsigned long, Assimp::FBX::Element const&, Assimp::FBX::Document const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BlendShapeChannel::BlendShapeChannel(uint64_t id, const Element& element, const Document& doc, const std::string& name) : Deformer(id, element, doc, name) { const Scope& sc = GetRequiredScope(element); const Element* const DeformPercent = sc["DeformPercent"]; if (DeformPercent) { percent = ParseTokenAsFloat(GetRequiredToken(*DeformPercent, 0)); } const Element* const FullWeights = sc["FullWeights"]; if (FullWeights) { ParseVectorDataArray(fullWeights, *FullWeights); } const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(), "Geometry"); shapeGeometries.reserve(conns.size()); for (const Connection* con : conns) { const ShapeGeometry* const sg = ProcessSimpleConnection<ShapeGeometry>(*con, false, "Shape -> BlendShapeChannel", element); if (sg) { shapeGeometries.push_back(sg); continue; } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rcx, %r14 movq %rdx, %r12 movq %rdi, %rbx callq 0x474bc4 leaq 0x329723(%rip), %rax # 0x79ed28 movq %rax, (%rbx) leaq 0x50(%rbx), %r15 leaq 0x68(%rbx), %rax movq %rax, 0x28(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x50(%rbx) movups %xmm0, 0x60(%rbx) movups %xmm0, 0x70(%rbx) movq %r12, %rdi movq %r15, 0x20(%rsp) callq 0x44ad17 movq %rax, %r13 leaq 0x10(%rsp), %rax movq %rax, -0x10(%rax) leaq 0x1540a9(%rip), %rsi # 0x5c96ed leaq 0x1540af(%rip), %rdx # 0x5c96fa movq %rsp, %rdi callq 0x209290 movq %r14, %r15 movq %rsp, %rsi movq %r13, %rdi callq 0x44ca1e movq %r13, %rbp addq $0x8, %rbp cmpq %rbp, %rax je 0x475673 movq 0x40(%rax), %r14 jmp 0x475676 xorl %r14d, %r14d movq (%rsp), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi je 0x475691 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 testq %r14, %r14 je 0x4756ad movq %r14, %rdi xorl %esi, %esi callq 0x44c713 movq %rax, %rdi callq 0x44ae6d movss %xmm0, 0x48(%rbx) movq %rsp, %rdi leaq 0x10(%rsp), %rax movq %rax, (%rdi) leaq 0x156b5d(%rip), %rsi # 0x5cc21c leaq 0x156b61(%rip), %rdx # 0x5cc227 callq 0x209290 movq %rsp, %rsi movq %r13, %rdi callq 0x44ca1e cmpq %rbp, %rax je 0x4756e1 movq 0x40(%rax), %r14 jmp 0x4756e4 xorl %r14d, %r14d movq %r15, %r13 movq 0x20(%rsp), %r15 movq (%rsp), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi je 0x475707 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 testq %r14, %r14 je 0x475717 movq %r15, %rdi movq %r14, %rsi callq 0x44b8a4 movq 0x30(%rbx), %rdx leaq 0x1558b9(%rip), %rcx # 0x5cafdb movq %rsp, %rdi movq %r13, %rsi callq 0x467a8c movq 0x8(%rsp), %rsi subq (%rsp), %rsi sarq $0x3, %rsi movq 0x28(%rsp), %rdi callq 0x47652a movq (%rsp), %r13 movq 0x8(%rsp), %r15 cmpq %r15, %r13 je 0x4757aa leaq 0x156acf(%rip), %rbp # 0x5cc228 leaq 0x30(%rsp), %r14 movq (%r13), %rdi xorl %esi, %esi movq %rbp, %rdx movq %r12, %rcx xorl %r8d, %r8d callq 0x4765c5 movq %rax, 0x30(%rsp) testq %rax, %rax je 0x47579d movq 0x70(%rbx), %rsi cmpq 0x78(%rbx), %rsi je 0x475790 movq %rax, (%rsi) addq $0x8, 0x70(%rbx) jmp 0x47579d movq 0x28(%rsp), %rdi movq %r14, %rdx callq 0x476c1a addq $0x8, %r13 cmpq %r15, %r13 jne 0x47575e movq (%rsp), %r13 testq %r13, %r13 je 0x4757bf movq 0x10(%rsp), %rsi subq %r13, %rsi movq %r13, %rdi callq 0x1a5190 addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x4757f7 jmp 0x4757fc jmp 0x4757f7 jmp 0x4757d8 jmp 0x4757f7 movq %rax, %r12 movq (%rsp), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi je 0x475815 movq 0x10(%rsp), %rsi incq %rsi jmp 0x475810 jmp 0x4757f7 jmp 0x4757f7 movq %rax, %r12 jmp 0x475815 movq %rax, %r12 movq (%rsp), %rdi testq %rdi, %rdi je 0x475815 movq 0x10(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x28(%rsp), %rax movq (%rax), %rdi testq %rdi, %rdi je 0x47582e movq 0x78(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x20(%rsp), %rax movq (%rax), %rdi testq %rdi, %rdi je 0x475847 movq 0x60(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x474d1a movq %r12, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXDeformer.cpp
Assimp::FBX::TokenizeBinary(std::vector<Assimp::FBX::Token const*, std::allocator<Assimp::FBX::Token const*>>&, char const*, unsigned long)
void TokenizeBinary(TokenList& output_tokens, const char* input, size_t length) { ai_assert(input); if(length < 0x1b) { TokenizeError("file is too short",0); } //uint32_t offset = 0x15; /* const char* cursor = input + 0x15; const uint32_t flags = ReadWord(input, cursor, input + length); const uint8_t padding_0 = ReadByte(input, cursor, input + length); // unused const uint8_t padding_1 = ReadByte(input, cursor, input + length); // unused*/ if (strncmp(input,"Kaydara FBX Binary",18)) { TokenizeError("magic bytes not found",0); } const char* cursor = input + 18; /*Result ignored*/ ReadByte(input, cursor, input + length); /*Result ignored*/ ReadByte(input, cursor, input + length); /*Result ignored*/ ReadByte(input, cursor, input + length); /*Result ignored*/ ReadByte(input, cursor, input + length); /*Result ignored*/ ReadByte(input, cursor, input + length); const uint32_t version = ReadWord(input, cursor, input + length); const bool is64bits = version >= 7500; const char *end = input + length; while (cursor < end ) { if (!ReadScope(output_tokens, input, cursor, input + length, is64bits)) { break; } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp cmpq $0x1a, %rdx jbe 0x476e2f movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 leaq 0x15101d(%rip), %rsi # 0x5c7d95 movl $0x12, %edx movq %r14, %rdi callq 0x1a53a0 testl %eax, %eax jne 0x476e58 leaq 0x12(%r14), %rax movq %rsp, %r12 movq %rax, (%r12) addq %r14, %rbx movq %r14, %rdi movq %r12, %rsi movq %rbx, %rdx callq 0x476f98 movq %r14, %rdi movq %r12, %rsi movq %rbx, %rdx callq 0x476f98 movq %r14, %rdi movq %r12, %rsi movq %rbx, %rdx callq 0x476f98 movq %r14, %rdi movq %r12, %rsi movq %rbx, %rdx callq 0x476f98 movq %r14, %rdi movq %r12, %rsi movq %rbx, %rdx callq 0x476f98 movq %r14, %rdi movq %r12, %rsi movq %rbx, %rdx callq 0x47701a cmpq %rbx, (%r12) jae 0x476e22 movl %eax, %ebp movq %rsp, %r12 xorl %r8d, %r8d cmpl $0x1d4c, %ebp # imm = 0x1D4C setae %r8b movq %r15, %rdi movq %r14, %rsi movq %r12, %rdx movq %rbx, %rcx callq 0x4770a1 testb %al, %al je 0x476e22 cmpq %rbx, (%rsp) jb 0x476dfa addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq leaq 0x10(%rsp), %r14 movq %r14, -0x10(%r14) leaq 0x1554ed(%rip), %rsi # 0x5cc32c leaq 0x1554f7(%rip), %rdx # 0x5cc33d movq %rsp, %rdi callq 0x209290 movq %rsp, %rdi xorl %esi, %esi callq 0x476eab leaq 0x10(%rsp), %r14 movq %r14, -0x10(%r14) leaq 0x1554d6(%rip), %rsi # 0x5cc33e leaq 0x1554e4(%rip), %rdx # 0x5cc353 movq %rsp, %rdi callq 0x209290 movq %rsp, %rdi xorl %esi, %esi callq 0x476eab jmp 0x476e85 jmp 0x476ea0 movq %rax, %rbx movq (%rsp), %rdi cmpq %r14, %rdi je 0x476ea3 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x476ea3 movq %rax, %rbx movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXBinaryTokenizer.cpp
Assimp::FBX::(anonymous namespace)::TokenizeError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
AI_WONT_RETURN void TokenizeError(const std::string& message, size_t offset) { throw DeadlyImportError(Util::AddOffset("FBX-Tokenize",message,offset)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rsi, %r14 movq %rdi, %r15 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x10(%rsp), %r12 movq %r12, -0x10(%r12) leaq 0x1517d8(%rip), %rsi # 0x5c86b3 leaq 0x1517dd(%rip), %rdx # 0x5c86bf movq %rsp, %rdi callq 0x209290 leaq 0x20(%rsp), %rdi movq %rsp, %rsi movq %r15, %rdx movq %r14, %rcx callq 0x4647db movb $0x1, %bpl leaq 0x20(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x266824(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x2667f0(%rip), %rsi # 0x6dd710 movq 0x335039(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 leaq 0x30(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x476f4d movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movq (%rsp), %rdi cmpq %r12, %rdi je 0x476f63 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x476f88 jmp 0x476f90 movq %rax, %r14 movq (%rsp), %rdi cmpq %r12, %rdi je 0x476f88 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x476f88 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXBinaryTokenizer.cpp
Assimp::FBX::(anonymous namespace)::ReadString(char const*&, char const*&, char const*, char const*&, char const*, bool, bool)
unsigned int ReadString(const char*& sbegin_out, const char*& send_out, const char* input, const char*& cursor, const char* end, bool long_length = false, bool allow_null = false) { const uint32_t len_len = long_length ? 4 : 1; if(Offset(cursor, end) < len_len) { TokenizeError("cannot ReadString, out of bounds reading length",input, cursor); } const uint32_t length = long_length ? ReadWord(input, cursor, end) : ReadByte(input, cursor, end); if (Offset(cursor, end) < length) { TokenizeError("cannot ReadString, length is out of bounds",input, cursor); } sbegin_out = cursor; cursor += length; send_out = cursor; if(!allow_null) { for (unsigned int i = 0; i < length; ++i) { if(sbegin_out[i] == '\0') { TokenizeError("failed ReadString, unexpected NUL character in string",input, cursor); } } } return length; }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rcx, %r14 movq %rdx, %rbx movq %r8, %rax subq (%rcx), %rax movl %r9d, %ecx leaq (%rcx,%rcx,2), %rcx incq %rcx cmpq %rcx, %rax jb 0x477ac3 movq %r8, %r13 movq %rsi, %r12 movq %rdi, %r15 movq %rbx, %rdi movq %r14, %rsi movq %r8, %rdx testb %r9b, %r9b je 0x477a3e callq 0x47701a jmp 0x477a46 callq 0x476f98 movzbl %al, %eax movq (%r14), %rcx subq %rcx, %r13 movl %eax, %eax cmpq %rax, %r13 jb 0x477af0 movb 0x50(%rsp), %dl movq %rcx, (%r15) movq (%r14), %rcx addq %rax, %rcx movq %rcx, (%r14) movq %rcx, (%r12) testq %rax, %rax sete %cl orb %dl, %cl jne 0x477a88 movq (%r15), %rcx xorl %edx, %edx cmpb $0x0, (%rcx,%rdx) je 0x477a96 incq %rdx cmpq %rdx, %rax jne 0x477a7a addq $0x20, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq leaq 0x10(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x154a75(%rip), %rsi # 0x5cc51b leaq 0x154aa3(%rip), %rdx # 0x5cc550 movq %rsp, %rdi callq 0x209290 movq (%r14), %rsi subq %rbx, %rsi movq %rsp, %rdi callq 0x476eab leaq 0x10(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x1549ed(%rip), %rsi # 0x5cc4c0 leaq 0x154a15(%rip), %rdx # 0x5cc4ef movq %rsp, %rdi callq 0x209290 movq (%r14), %rsi subq %rbx, %rsi movq %rsp, %rdi callq 0x476eab leaq 0x10(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x1549f0(%rip), %rsi # 0x5cc4f0 leaq 0x154a13(%rip), %rdx # 0x5cc51a movq %rsp, %rdi callq 0x209290 movq (%r14), %rsi subq %rbx, %rsi movq %rsp, %rdi callq 0x476eab jmp 0x477b25 jmp 0x477b40 jmp 0x477b25 jmp 0x477b40 movq %rax, %rbx movq (%rsp), %rdi cmpq %r15, %rdi je 0x477b43 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x477b43 movq %rax, %rbx movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXBinaryTokenizer.cpp
Assimp::Q3DImporter::Face::Face(unsigned int)
explicit Face(unsigned int s) : indices (s) , uvindices (s) , mat (0) { }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl %esi, %r14d leaq 0x7(%rsp), %rdx movq %r14, %rsi callq 0x257162 leaq 0x18(%rbx), %rdi leaq 0x6(%rsp), %rdx movq %r14, %rsi callq 0x257162 movl $0x0, 0x30(%rbx) addq $0x8, %rsp popq %rbx popq %r14 retq movq %rax, %r14 movq (%rbx), %rdi testq %rdi, %rdi je 0x47a61c movq 0x10(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Q3D/Q3DLoader.h
Assimp::Q3BSPFileImporter::findFirstMapInArchive(Assimp::ZipArchiveIOSystem&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Q3BSPFileImporter::findFirstMapInArchive(ZipArchiveIOSystem &bspArchive, std::string &mapName ) { mapName = ""; std::vector<std::string> fileList; bspArchive.getFileListExtension( fileList, "bsp" ); if (fileList.empty()) { return false; } std::vector<std::string>::iterator it( fileList.begin() ); for ( ; it != fileList.end(); ++it ) { const std::string::size_type pos = (*it).find( "maps/" ); if ( std::string::npos != pos ) { std::string::size_type extPos = (*it).find( ".bsp" ); if ( std::string::npos != extPos ) { mapName = *it; return true; } } } return false; }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rdx, %rbx movq %rsi, %r14 movq 0x8(%rdx), %rdx leaq 0x12d3a2(%rip), %rcx # 0x5a8b41 movq %rbx, %rdi xorl %esi, %esi xorl %r8d, %r8d callq 0x1a5830 xorps %xmm0, %xmm0 movaps %xmm0, (%rsp) movq $0x0, 0x10(%rsp) leaq 0x30(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x151127(%rip), %rsi # 0x5cc8f3 leaq 0x151123(%rip), %rdx # 0x5cc8f6 leaq 0x20(%rsp), %rdi callq 0x209290 movq %rsp, %rsi leaq 0x20(%rsp), %rdx movq %r14, %rdi callq 0x5153ee movq 0x20(%rsp), %rdi cmpq %r15, %rdi je 0x47b804 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movq (%rsp), %r14 cmpq 0x8(%rsp), %r14 je 0x47b858 leaq 0x1510d6(%rip), %r15 # 0x5cc8ec leaq 0x1510d5(%rip), %r12 # 0x5cc8f2 movl $0x5, %ecx movq %r14, %rdi movq %r15, %rsi xorl %edx, %edx callq 0x1a55c0 cmpq $-0x1, %rax je 0x47b84d movl $0x4, %ecx movq %r14, %rdi movq %r12, %rsi xorl %edx, %edx callq 0x1a55c0 cmpq $-0x1, %rax jne 0x47b85c addq $0x20, %r14 cmpq 0x8(%rsp), %r14 jne 0x47b81d xorl %ebp, %ebp jmp 0x47b86a movb $0x1, %bpl movq %rbx, %rdi movq %r14, %rsi callq 0x1a64a0 movq %rsp, %rdi callq 0x23c89e movl %ebp, %eax addq $0x40, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq jmp 0x47b89f movq %rax, %rbx movq 0x20(%rsp), %rdi cmpq %r15, %rdi je 0x47b8a2 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x47b8a2 movq %rax, %rbx movq %rsp, %rdi callq 0x23c89e movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Q3BSP/Q3BSPFileImporter.cpp
Assimp::Q3BSPFileImporter::importTextureFromArchive(Assimp::Q3BSP::Q3BSPModel const*, Assimp::ZipArchiveIOSystem*, aiScene*, aiMaterial*, int)
bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *model, ZipArchiveIOSystem *archive, aiScene*, aiMaterial *pMatHelper, int textureId ) { if (nullptr == archive || nullptr == pMatHelper ) { return false; } if ( textureId < 0 || textureId >= static_cast<int>( model->m_Textures.size() ) ) { return false; } bool res = true; sQ3BSPTexture *pTexture = model->m_Textures[ textureId ]; if ( !pTexture ) { return false; } std::vector<std::string> supportedExtensions; supportedExtensions.push_back( ".jpg" ); supportedExtensions.push_back( ".png" ); supportedExtensions.push_back( ".tga" ); std::string textureName, ext; if ( expandFile( archive, pTexture->strName, supportedExtensions, textureName, ext ) ) { IOStream *pTextureStream = archive->Open( textureName.c_str() ); if ( pTextureStream ) { size_t texSize = pTextureStream->FileSize(); aiTexture *pTexture = new aiTexture; pTexture->mHeight = 0; pTexture->mWidth = static_cast<unsigned int>(texSize); unsigned char *pData = new unsigned char[ pTexture->mWidth ]; size_t readSize = pTextureStream->Read( pData, sizeof( unsigned char ), pTexture->mWidth ); (void)readSize; ai_assert( readSize == pTexture->mWidth ); pTexture->pcData = reinterpret_cast<aiTexel*>( pData ); pTexture->achFormatHint[ 0 ] = ext[ 1 ]; pTexture->achFormatHint[ 1 ] = ext[ 2 ]; pTexture->achFormatHint[ 2 ] = ext[ 3 ]; pTexture->achFormatHint[ 3 ] = '\0'; res = true; aiString name; name.data[ 0 ] = '*'; name.length = 1 + ASSIMP_itoa10( name.data + 1, static_cast<unsigned int>(MAXLEN-1), static_cast<int32_t>(mTextures.size()) ); archive->Close( pTextureStream ); pMatHelper->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) ); mTextures.push_back( pTexture ); } else { // If it doesn't exist in the archive, it is probably just a reference to an external file. // We'll leave it up to the user to figure out which extension the file has. aiString name; strncpy( name.data, pTexture->strName, sizeof name.data ); name.length = strlen( name.data ); pMatHelper->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) ); } } return res; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x478, %rsp # imm = 0x478 testq %rdx, %rdx sete %al testq %r8, %r8 sete %cl orb %al, %cl testl %r9d, %r9d sets %al orb %cl, %al jne 0x47cd2d movq 0x78(%rsi), %rax movq 0x80(%rsi), %rcx subq %rax, %rcx shrq $0x3, %rcx cmpl %r9d, %ecx jle 0x47cd2d movl %r9d, %ecx movq (%rax,%rcx,8), %r13 testq %r13, %r13 je 0x47cd2d movq %r8, %rbx movq %rdx, %r15 movq %rdi, %r12 xorps %xmm0, %xmm0 movaps %xmm0, 0x10(%rsp) movq $0x0, 0x20(%rsp) leaq 0x80(%rsp), %r14 movq %r14, -0x10(%r14) leaq 0xee3df(%rip), %rsi # 0x56adfa leaq 0xee3dc(%rip), %rdx # 0x56adfe leaq 0x70(%rsp), %rdi callq 0x209290 leaq 0x10(%rsp), %rdi leaq 0x70(%rsp), %rsi callq 0x2c1e68 movq 0x70(%rsp), %rdi cmpq %r14, %rdi je 0x47ca55 movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x70(%rsp), %rdi movq %r14, (%rdi) leaq 0x12359a(%rip), %rsi # 0x59fffe leaq 0x123597(%rip), %rdx # 0x5a0002 callq 0x209290 leaq 0x10(%rsp), %rdi leaq 0x70(%rsp), %rsi callq 0x2c1e68 movq 0x70(%rsp), %rdi cmpq %r14, %rdi je 0x47ca99 movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x70(%rsp), %rdi movq %r14, (%rdi) leaq 0x125264(%rip), %rsi # 0x5a1d0c leaq 0x125261(%rip), %rdx # 0x5a1d10 callq 0x209290 leaq 0x10(%rsp), %rdi leaq 0x70(%rsp), %rsi callq 0x2c1e68 movq %r12, 0x68(%rsp) movq 0x70(%rsp), %rdi cmpq %r14, %rdi je 0x47cae2 movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x58(%rsp), %rcx movq %rcx, -0x10(%rcx) xorl %eax, %eax movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0x38(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0x70(%rsp), %r12 movq %r14, (%r12) movq %r13, %rdi callq 0x1a56a0 leaq (%rax,%r13), %rdx movq %r12, %rdi movq %r13, %rsi callq 0x209290 leaq 0x70(%rsp), %rdx leaq 0x10(%rsp), %rcx leaq 0x48(%rsp), %r8 leaq 0x28(%rsp), %r9 movq %r15, %rsi callq 0x47d0c8 movl %eax, %ebp movq 0x70(%rsp), %rdi cmpq %r14, %rdi je 0x47cb5a movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl je 0x47cd95 movq 0x48(%rsp), %rsi movq (%r15), %rax leaq 0x12dbef(%rip), %rdx # 0x5aa761 movq %r15, %rdi callq *0x20(%rax) movq %rax, %r14 testq %rax, %rax je 0x47cd41 movq (%r14), %rax movq %r14, %rdi callq *0x30(%rax) movq %rax, %rbp movq %r14, (%rsp) movl $0x428, %edi # imm = 0x428 callq 0x1a5230 movq %rax, %r13 movq $0x0, 0x18(%rax) xorl %r14d, %r14d movl %r14d, 0x20(%rax) movb $0x0, 0x24(%rax) movq %rax, %rdi addq $0x25, %rdi movl $0x3ff, %edx # imm = 0x3FF movl $0x1b, %esi callq 0x1a54e0 movl %r14d, 0x8(%r13) movq %r13, 0x8(%rsp) movl %r14d, 0x4(%r13) movl %ebp, (%r13) movl %ebp, %r12d movq %r12, %rdi callq 0x1a57a0 movq %rax, %rbp movq (%rsp), %rdi movq (%rdi), %rax movl $0x1, %edx movq %rbp, %rsi movq %r12, %rcx callq *0x10(%rax) movl (%r13), %ecx cmpq %rcx, %rax movq 0x68(%rsp), %r14 jne 0x47cdde movq %rbp, 0x18(%r13) movq 0x28(%rsp), %rax movb 0x1(%rax), %cl movb %cl, 0x8(%r13) movb 0x2(%rax), %cl movb %cl, 0x9(%r13) movb 0x3(%rax), %al movb %al, 0xa(%r13) movb $0x0, 0xb(%r13) leaq 0x75(%rsp), %rbp movl $0x3ff, %edx # imm = 0x3FF movq %rbp, %rdi movl $0x1b, %esi callq 0x1a54e0 movb $0x2a, -0x1(%rbp) movq 0xc0(%r14), %rcx subq 0xb8(%r14), %rcx shrq $0x3, %rcx movl $0x1, %esi testl %ecx, %ecx jns 0x47cc79 leaq 0x76(%rsp), %rbp movb $0x2d, -0x1(%rbp) negl %ecx movl $0x2, %esi leaq 0xb8(%r14), %r13 movl $0x3b9aca00, %r8d # imm = 0x3B9ACA00 xorl %edi, %edi movl %ecx, %eax cltd idivl %r8d testl %eax, %eax setne %r9b cmpl $0x1, %r8d sete %r10b orb %r10b, %dil orb %r9b, %dil testb $0x1, %dil je 0x47ccba addb $0x30, %al movb %al, (%rbp) incq %rbp incl %esi movl %edx, %ecx cmpl $0x1, %r8d je 0x47ccda movslq %r8d, %rax imulq $0x66666667, %rax, %r8 # imm = 0x66666667 movq %r8, %rax shrq $0x3f, %rax sarq $0x22, %r8 addl %eax, %r8d cmpl $0x3ff, %esi # imm = 0x3FF jb 0x47cc88 movb $0x0, (%rbp) movl %esi, 0x70(%rsp) movq (%r15), %rax movq %r15, %rdi movq (%rsp), %rsi callq *0x28(%rax) leaq 0x113dfe(%rip), %rdx # 0x590af4 leaq 0x70(%rsp), %rsi movq %rbx, %rdi movl $0x1, %ecx xorl %r8d, %r8d callq 0x246b54 movq 0xc0(%r14), %rsi cmpq 0xc8(%r14), %rsi je 0x47cd88 movq 0x8(%rsp), %rax movq %rax, (%rsi) addq $0x8, 0xc0(%r14) jmp 0x47cd95 xorl %eax, %eax addq $0x478, %rsp # imm = 0x478 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x74(%rsp), %r14 movl $0x0, -0x4(%r14) movl $0x400, %edx # imm = 0x400 movq %r14, %rdi movq %r13, %rsi callq 0x1a5220 movq %r14, %rdi callq 0x1a56a0 movl %eax, -0x4(%r14) leaq 0x113d83(%rip), %rdx # 0x590af4 leaq 0x70(%rsp), %rsi movq %rbx, %rdi movl $0x1, %ecx xorl %r8d, %r8d callq 0x246b54 jmp 0x47cd95 leaq 0x8(%rsp), %rdx movq %r13, %rdi callq 0x2afa3e movq 0x28(%rsp), %rdi leaq 0x38(%rsp), %rax cmpq %rax, %rdi je 0x47cdb1 movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x48(%rsp), %rdi leaq 0x58(%rsp), %rax cmpq %rax, %rdi je 0x47cdcd movq 0x58(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x10(%rsp), %rdi callq 0x23c89e movb $0x1, %al jmp 0x47cd2f leaq 0x14fd55(%rip), %rdi # 0x5ccb3a leaq 0x14fb20(%rip), %rsi # 0x5cc90c leaq 0x14fd64(%rip), %rcx # 0x5ccb57 movl $0x256, %edx # imm = 0x256 callq 0x1a5270 jmp 0x47ce2a jmp 0x47ce2a jmp 0x47ce2a jmp 0x47ce2a jmp 0x47ce2a jmp 0x47ce2a jmp 0x47ce2a movq %rax, %rbx movq 0x70(%rsp), %rdi cmpq %r14, %rdi je 0x47ce2d movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x47ce2d movq %rax, %rbx movq 0x28(%rsp), %rdi leaq 0x38(%rsp), %rax cmpq %rax, %rdi je 0x47ce49 movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x48(%rsp), %rdi leaq 0x58(%rsp), %rax cmpq %rax, %rdi je 0x47ce89 movq 0x58(%rsp), %rsi jmp 0x47ce7c jmp 0x47ce67 jmp 0x47ce86 jmp 0x47ce67 jmp 0x47ce86 movq %rax, %rbx movq 0x70(%rsp), %rdi cmpq %r14, %rdi je 0x47ce89 movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x47ce89 movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x23c89e movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/Q3BSP/Q3BSPFileImporter.cpp
UnknownChunk(Assimp::StreamReader<false, false>*, SIBChunk const&)
static void UnknownChunk(StreamReaderLE* /*stream*/, const SIBChunk& chunk) { char temp[5] = { static_cast<char>(( chunk.Tag>>24 ) & 0xff), static_cast<char>(( chunk.Tag>>16 ) & 0xff), static_cast<char>(( chunk.Tag>>8 ) & 0xff), static_cast<char>(chunk.Tag & 0xff), '\0' }; ASSIMP_LOG_WARN((Formatter::format(), "SIB: Skipping unknown '",temp,"' chunk.")); }
pushq %r14 pushq %rbx subq $0x1a8, %rsp # imm = 0x1A8 movl %edi, %eax movl %edi, %ecx shrl $0x18, %ecx movb %cl, 0xb(%rsp) movl %edi, %ecx shrl $0x10, %ecx movb %cl, 0xc(%rsp) movb %ah, 0xd(%rsp) movb %al, 0xe(%rsp) movb $0x0, 0xf(%rsp) callq 0x241234 movq %rax, %rbx leaq 0x30(%rsp), %r14 movq %r14, %rdi callq 0x1a6170 leaq 0x14ac0a(%rip), %rsi # 0x5cd214 movl $0x17, %edx movq %r14, %rdi callq 0x1a61e0 leaq 0xb(%rsp), %r14 movq %r14, %rdi callq 0x1a56a0 leaq 0x30(%rsp), %rdi movq %r14, %rsi movq %rax, %rdx callq 0x1a61e0 leaq 0x14abf1(%rip), %rsi # 0x5cd22c leaq 0x30(%rsp), %rdi movl $0x8, %edx callq 0x1a61e0 leaq 0x38(%rsp), %rsi leaq 0x10(%rsp), %rdi callq 0x1a5690 movq 0x10(%rsp), %rsi movq %rbx, %rdi callq 0x241182 leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x482681 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x329908(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 addq $0x1a8, %rsp # imm = 0x1A8 popq %rbx popq %r14 retq movq %rax, %rbx leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4826cd movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x4826cd movq %rax, %rbx movq 0x3298bc(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/SIB/SIBImporter.cpp
ReadString(Assimp::StreamReader<false, false>*, unsigned int)
static aiString ReadString(StreamReaderLE *stream, uint32_t numWChars) { if ( nullptr == stream || 0 == numWChars ) { static const aiString empty; return empty; } // Allocate buffers (max expansion is 1 byte -> 4 bytes for UTF-8) std::vector<unsigned char> str; str.reserve( numWChars * 4 + 1 ); uint16_t *temp = new uint16_t[ numWChars ]; for ( uint32_t n = 0; n < numWChars; ++n ) { temp[ n ] = stream->GetU2(); } // Convert it and NUL-terminate. const uint16_t *start( temp ), *end( temp + numWChars ); utf8::utf16to8( start, end, back_inserter( str ) ); str[ str.size() - 1 ] = '\0'; // Return the final string. aiString result = aiString((const char *)&str[0]); delete[] temp; return result; }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rdi, %rbx testq %rsi, %rsi setne %al testl %edx, %edx setne %cl testb %cl, %al jne 0x482754 movb 0x359980(%rip), %al # 0x7dc098 testb %al, %al je 0x48285d movl 0x35956a(%rip), %eax # 0x7dbc90 movl $0x3ff, %r14d # imm = 0x3FF cmpl %r14d, %eax cmovbl %eax, %r14d movl %r14d, (%rbx) leaq 0x4(%rbx), %rdi leaq 0x359553(%rip), %rsi # 0x7dbc94 movq %r14, %rdx callq 0x1a5110 movb $0x0, 0x4(%rbx,%r14) jmp 0x48284f movl %edx, %r14d movq %rsi, %r15 xorps %xmm0, %xmm0 movq %rsp, %rdi movaps %xmm0, (%rdi) movq $0x0, 0x10(%rdi) leal 0x1(,%r14,4), %esi callq 0x270990 movl %r14d, %r12d leaq (%r12,%r12), %rdi callq 0x1a57a0 movq %rax, %r14 xorl %r13d, %r13d movq %r15, %rdi callq 0x3205e2 movw %ax, (%r14,%r13,2) incq %r13 cmpq %r13, %r12 jne 0x48278a leaq (%r14,%r12,2), %rsi movq %rsp, %rdx movq %r14, %rdi callq 0x482cf9 movq 0x8(%rsp), %rax movb $0x0, -0x1(%rax) movq (%rsp), %r15 leaq 0x30(%rsp), %r13 movq %r13, -0x10(%r13) testq %r15, %r15 je 0x4827d9 movq %r15, %rdi callq 0x1a56a0 movq %rax, %rdx addq %r15, %rdx jmp 0x4827de movl $0x1, %edx leaq 0x20(%rsp), %rdi movq %r15, %rsi callq 0x209290 movq 0x28(%rsp), %rax testl $0xfffffc00, %eax # imm = 0xFFFFFC00 movl $0x3ff, %r12d # imm = 0x3FF cmovel %eax, %r12d movl %r12d, (%rbx) leaq 0x4(%rbx), %rdi movq 0x20(%rsp), %r15 movq %r15, %rsi movq %r12, %rdx callq 0x1a5110 movb $0x0, 0x4(%rbx,%r12) cmpq %r13, %r15 je 0x482831 movq 0x30(%rsp), %rsi incq %rsi movq %r15, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5610 movq (%rsp), %rdi testq %rdi, %rdi je 0x48284f movq 0x10(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 addq $0x40, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq callq 0x1a9469 jmp 0x482720 jmp 0x48286f jmp 0x48286f jmp 0x48286f jmp 0x48286f movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x482888 movq 0x10(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/SIB/SIBImporter.cpp
Assimp::SMDImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*)
void SMDImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) { this->pScene = pScene; ReadSmd(pFile, pIOHandler); // If there are no triangles it seems to be an animation SMD, // containing only the animation skeleton. if (asTriangles.empty()) { if (asBones.empty()) { throw DeadlyImportError("SMD: No triangles and no bones have " "been found in the file. This file seems to be invalid."); } // Set the flag in the scene structure which indicates // that there is nothing than an animation skeleton pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; } if (!asBones.empty()) { // Check whether all bones have been initialized for (std::vector<SMD::Bone>::const_iterator i = asBones.begin(); i != asBones.end();++i) { if (!(*i).mName.length()) { ASSIMP_LOG_WARN("SMD: Not all bones have been initialized"); break; } } // now fix invalid time values and make sure the animation starts at frame 0 FixTimeValues(); } // build output nodes (bones are added as empty dummy nodes) CreateOutputNodes(); if (!(pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE)) { // create output meshes CreateOutputMeshes(); // build an output material list CreateOutputMaterials(); // use root node that renders all meshes pScene->mRootNode->mNumMeshes = pScene->mNumMeshes; pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes]; for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) { pScene->mRootNode->mMeshes[i] = i; } } // build the output animation CreateOutputAnimations(pFile, pIOHandler); if ((pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE) && !noSkeletonMesh) { SkeletonMeshBuilder skeleton(pScene); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x50, %rsp movq %rcx, %r15 movq %rdx, %rbx movq %rsi, %r12 movq %rdi, %r14 movq %rdx, 0x98(%rdi) movq %rcx, %rdx callq 0x483e3a movq 0xc0(%r14), %rax cmpq 0xc8(%r14), %rax jne 0x483c8a movq 0xd8(%r14), %rax cmpq 0xe0(%r14), %rax je 0x483dab orb $0x1, (%rbx) movq 0xd8(%r14), %rax movq 0xe0(%r14), %rcx cmpq %rcx, %rax je 0x483ccd cmpq $0x0, 0x8(%rax) je 0x483cb1 addq $0x90, %rax cmpq %rcx, %rax jne 0x483c9d jmp 0x483cc5 callq 0x241234 leaq 0x149665(%rip), %rsi # 0x5cd322 movq %rax, %rdi callq 0x241182 movq %r14, %rdi callq 0x4840e4 movq %r14, %rdi callq 0x484158 testb $0x1, (%rbx) jne 0x483d2c movq %r14, %rdi callq 0x484260 movq %r14, %rdi callq 0x48503c movl 0x10(%rbx), %edi movq 0x8(%rbx), %rax movl %edi, 0x460(%rax) shlq $0x2, %rdi callq 0x1a57a0 movq 0x8(%rbx), %rcx movq %rax, 0x468(%rcx) cmpl $0x0, 0x10(%rbx) je 0x483d2c xorl %eax, %eax movq 0x8(%rbx), %rcx movq 0x468(%rcx), %rcx movl %eax, (%rcx,%rax,4) incq %rax movl 0x10(%rbx), %ecx cmpq %rcx, %rax jb 0x483d13 movq %r14, %rdi movq %r12, %rsi movq %r15, %rdx callq 0x485346 testb $0x1, (%rbx) je 0x483d9e cmpb $0x0, 0x109(%r14) jne 0x483d9e movq %rsp, %r14 movq %r14, %rdi movq %rbx, %rsi xorl %edx, %edx xorl %ecx, %ecx callq 0x51b20c movq 0x30(%r14), %rdi testq %rdi, %rdi je 0x483d71 movq 0x40(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x18(%rsp), %rdi testq %rdi, %rdi je 0x483d88 movq 0x28(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq (%rsp), %rdi testq %rdi, %rdi je 0x483d9e movq 0x10(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 addq $0x50, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x10(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x1494ff(%rip), %rsi # 0x5cd2c7 leaq 0x149552(%rip), %rdx # 0x5cd321 movq %rsp, %rdi callq 0x209290 movb $0x1, %bpl movq %rsp, %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x25994c(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x259918(%rip), %rsi # 0x6dd710 movq 0x328161(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq (%rsp), %rdi cmpq %r15, %rdi je 0x483e20 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x483e2a jmp 0x483e32 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp
Assimp::SMDImporter::CreateOutputNodes()
void SMDImporter::CreateOutputNodes() { pScene->mRootNode = new aiNode(); // now add all bones as dummy sub nodes to the graph AddBoneChildren(pScene->mRootNode,(uint32_t)-1); for (auto &bone : asBones) { bone.mOffsetMatrix.Inverse(); } // if we have only one bone we can even remove the root node if (pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE && 1 == pScene->mRootNode->mNumChildren) { aiNode* pcOldRoot = pScene->mRootNode; pScene->mRootNode = pcOldRoot->mChildren[0]; pcOldRoot->mChildren[0] = nullptr; delete pcOldRoot; pScene->mRootNode->mParent = nullptr; } else { ::strcpy(pScene->mRootNode->mName.data, "<SMD_root>"); pScene->mRootNode->mName.length = 10; } }
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx movl $0x478, %edi # imm = 0x478 callq 0x1a5230 movq %rax, %r14 movq %rax, %rdi callq 0x2402f8 movq 0x98(%rbx), %rax movq %r14, 0x8(%rax) movq 0x98(%rbx), %rax movq 0x8(%rax), %rsi movq %rbx, %rdi movl $0xffffffff, %edx # imm = 0xFFFFFFFF callq 0x4855a4 movq 0xd8(%rbx), %r14 movq 0xe0(%rbx), %r15 cmpq %r15, %r14 je 0x4841bd leaq 0x48(%r14), %rdi callq 0x25b84e addq $0x90, %r14 jmp 0x4841a6 movq 0x98(%rbx), %rax testb $0x1, (%rax) movq 0x8(%rax), %r14 je 0x48421b cmpl $0x1, 0x450(%r14) jne 0x48421b movq 0x458(%r14), %rcx movq (%rcx), %rcx movq %rcx, 0x8(%rax) movq 0x458(%r14), %rax xorl %r15d, %r15d movq %r15, (%rax) movq %r14, %rdi callq 0x240468 movl $0x478, %esi # imm = 0x478 movq %r14, %rdi callq 0x1a5190 movq 0x98(%rbx), %rax movq 0x8(%rax), %rax movq %r15, 0x448(%rax) jmp 0x484242 movabsq $0x6f6f725f444d533c, %rax # imm = 0x6F6F725F444D533C movq %rax, 0x4(%r14) movl $0x3e746f, 0xb(%r14) # imm = 0x3E746F movq 0x98(%rbx), %rax movq 0x8(%rax), %rax movl $0xa, (%rax) popq %rbx popq %r14 popq %r15 retq movq %rax, %rbx movl $0x478, %esi # imm = 0x478 movq %r14, %rdi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp
Assimp::SMDImporter::GetAnimationFileList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*, std::vector<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void SMDImporter::GetAnimationFileList(const std::string &pFile, IOSystem* pIOHandler, std::vector<std::tuple<std::string, std::string>>& outList) { auto base = DefaultIOSystem::absolutePath(pFile); auto name = DefaultIOSystem::completeBaseName(pFile); auto path = base + "/" + name + "_animation.txt"; std::unique_ptr<IOStream> file(pIOHandler->Open(path.c_str(), "rb")); if (file.get() == nullptr) { return; } // Allocate storage and copy the contents of the file to a memory buffer std::vector<char> buf; size_t fileSize = file->FileSize(); buf.resize(fileSize + 1); TextFileToBuffer(file.get(), buf); /* *_animation.txt format: name path idle idle.smd jump anim/jump.smd walk.smd ... */ std::string animName, animPath; char *tok1, *tok2; char *context1, *context2; tok1 = strtok_s(&buf[0], "\r\n", &context1); while (tok1 != NULL) { tok2 = strtok_s(tok1, " \t", &context2); if (tok2) { char *p = tok2; tok2 = strtok_s(nullptr, " \t", &context2); if (tok2) { animPath = tok2; animName = p; } else { // No name animPath = p; animName = DefaultIOSystem::completeBaseName(animPath); } outList.push_back(std::make_tuple(animName, base + "/" + animPath)); } tok1 = strtok_s(nullptr, "\r\n", &context1); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x158, %rsp # imm = 0x158 movq %rcx, 0x120(%rsp) movq %rdx, %rbx movq %rsi, %r14 leaq 0x100(%rsp), %rdi callq 0x24d9bc leaq 0x138(%rsp), %rdi movq %r14, %rsi callq 0x24d92a leaq 0x10(%rsp), %r15 movq %r15, -0x10(%r15) movq 0x100(%rsp), %rsi movq 0x108(%rsp), %rdx addq %rsi, %rdx movq %rsp, %rdi callq 0x20ac60 leaq 0x1114d6(%rip), %rsi # 0x596f0d movq %rsp, %rdi callq 0x1a5ba0 movq 0x138(%rsp), %rsi movq 0x140(%rsp), %rdx movq %rsp, %rdi callq 0x1a5d30 leaq 0x90(%rsp), %rsi movq %rsi, -0x10(%rsi) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x485a87 movq %rdx, 0x80(%rsp) movq (%rcx), %rdx movq %rdx, 0x90(%rsp) jmp 0x485a8d movups (%rcx), %xmm0 movups %xmm0, (%rsi) movq 0x8(%rax), %rdx leaq 0x80(%rsp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x147b45(%rip), %rsi # 0x5cd5f8 callq 0x1a5ba0 leaq 0xd0(%rsp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x485ae8 movq %rdx, 0xc0(%rsp) movq (%rcx), %rdx movq %rdx, 0xd0(%rsp) jmp 0x485aef movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx movq %rdx, 0xc8(%rsp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x80(%rsp), %rdi leaq 0x90(%rsp), %rax cmpq %rax, %rdi je 0x485b2f movq 0x90(%rsp), %rsi incq %rsi callq 0x1a5190 movq (%rsp), %rdi cmpq %r15, %rdi je 0x485b45 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0xc0(%rsp), %rsi movq (%rbx), %rax leaq 0x124c0a(%rip), %rdx # 0x5aa761 movq %rbx, %rdi callq *0x20(%rax) movq %rax, %rbx testq %rax, %rax je 0x485ea0 xorps %xmm0, %xmm0 movaps %xmm0, 0x40(%rsp) movq $0x0, 0x50(%rsp) movq (%rbx), %rax movq %rbx, %rdi movq %rbx, 0x58(%rsp) callq *0x30(%rax) incq %rax leaq 0x40(%rsp), %rdi movq %rax, %rsi callq 0x249292 leaq 0x40(%rsp), %rsi movq %rbx, %rdi movl $0x1, %edx callq 0x248808 movq %r15, (%rsp) xorl %eax, %eax movq %rax, 0x8(%rsp) movb %al, 0x10(%rsp) leaq 0x30(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) movq 0x40(%rsp), %rdi leaq 0x149a04(%rip), %rsi # 0x5cf5d8 leaq 0x130(%rsp), %rdx callq 0x1a54c0 testq %rax, %rax je 0x485e3c leaq 0xf0(%rsp), %rbx leaq 0x122f46(%rip), %r15 # 0x5a8b3f movq %rax, %rdi movq %r15, %rsi leaq 0x128(%rsp), %rdx callq 0x1a54c0 testq %rax, %rax je 0x485e1d movq %rax, %rbp movq %rbx, %r12 xorl %edi, %edi movq %r15, %r14 movq %r15, %rsi leaq 0x128(%rsp), %rdx callq 0x1a54c0 movq 0x28(%rsp), %rbx testq %rax, %rax je 0x485c84 movq %rax, %r15 movq %rax, %rdi callq 0x1a56a0 leaq 0x20(%rsp), %rdi xorl %esi, %esi movq %rbx, %rdx movq %r15, %rcx movq %rax, %r8 callq 0x1a5830 leaq 0x90(%rsp), %r15 movq 0x8(%rsp), %rbx movq %rbp, %rdi callq 0x1a56a0 movq %rsp, %rdi xorl %esi, %esi movq %rbx, %rdx movq %rbp, %rcx movq %rax, %r8 callq 0x1a5830 jmp 0x485ce6 movq %rbp, %rdi callq 0x1a56a0 leaq 0x20(%rsp), %rdi xorl %esi, %esi movq %rbx, %rdx movq %rbp, %rcx movq %rax, %r8 callq 0x1a5830 leaq 0x90(%rsp), %r15 leaq 0x80(%rsp), %rbx movq %rbx, %rdi leaq 0x20(%rsp), %rsi callq 0x24d92a movq %rsp, %rdi movq %rbx, %rsi callq 0x1a58d0 movq 0x80(%rsp), %rdi cmpq %r15, %rdi je 0x485ce6 movq 0x90(%rsp), %rsi incq %rsi callq 0x1a5190 movq %r12, %rbx movq %r12, 0xe0(%rsp) movq 0x100(%rsp), %rsi movq 0x108(%rsp), %rdx addq %rsi, %rdx leaq 0xe0(%rsp), %r13 movq %r13, %rdi callq 0x20ac60 movq %r13, %rdi leaq 0x1111ef(%rip), %rsi # 0x596f0d callq 0x1a5ba0 leaq 0x70(%rsp), %rbp movq 0x20(%rsp), %rsi movq 0x28(%rsp), %rdx movq %r13, %rdi callq 0x1a5d30 movq %rbp, 0x60(%rsp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x485d5d movq %rdx, 0x60(%rsp) movq (%rcx), %rdx movq %rdx, 0x70(%rsp) jmp 0x485d64 movups (%rcx), %xmm0 movups %xmm0, (%rbp) movq 0x8(%rax), %rdx movq %rdx, 0x68(%rsp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x80(%rsp), %r13 movq %r13, %rdi movq %rsp, %rsi leaq 0x60(%rsp), %rdx callq 0x488652 movq 0x120(%rsp), %rdi movq %r13, %rsi callq 0x4888d8 movq 0xa0(%rsp), %rdi leaq 0xb0(%rsp), %rax cmpq %rax, %rdi je 0x485dc9 movq 0xb0(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x80(%rsp), %rdi cmpq %r15, %rdi je 0x485de6 movq 0x90(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x60(%rsp), %rdi cmpq %rbp, %rdi movq %r14, %r15 je 0x485e00 movq 0x70(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0xe0(%rsp), %rdi cmpq %rbx, %rdi je 0x485e1d movq 0xf0(%rsp), %rsi incq %rsi callq 0x1a5190 xorl %edi, %edi leaq 0x1497b2(%rip), %rsi # 0x5cf5d8 leaq 0x130(%rsp), %rdx callq 0x1a54c0 testq %rax, %rax jne 0x485bf9 movq 0x20(%rsp), %rdi leaq 0x30(%rsp), %rax cmpq %rax, %rdi je 0x485e58 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movq (%rsp), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi leaq 0xd0(%rsp), %r14 movq 0x58(%rsp), %rbx je 0x485e80 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x40(%rsp), %rdi testq %rdi, %rdi je 0x485e97 movq 0x50(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) movq 0xc0(%rsp), %rdi cmpq %r14, %rdi je 0x485ebd movq 0xd0(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x148(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x485ede movq 0x148(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x110(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x485eff movq 0x110(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x158, %rsp # imm = 0x158 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 jmp 0x48603e movq %rax, %r14 movq 0x80(%rsp), %rdi leaq 0x90(%rsp), %rax cmpq %rax, %rdi je 0x485f48 movq 0x90(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x485f48 jmp 0x485f45 movq %rax, %r14 movq (%rsp), %rdi cmpq %r15, %rdi je 0x486063 movq 0x10(%rsp), %rsi jmp 0x48605b movq %rax, %r14 jmp 0x486063 movq %rax, %r14 jmp 0x486084 movq %rax, %r14 jmp 0x48601c jmp 0x485fe2 movq %rax, %r14 leaq 0x80(%rsp), %rdi callq 0x488248 jmp 0x485fa7 jmp 0x485fe2 movq %rax, %r14 movq 0xe0(%rsp), %rdi cmpq %rbx, %rdi jne 0x485fd0 jmp 0x485fe5 movq %rax, %r14 jmp 0x485fc3 movq %rax, %r14 movq 0x60(%rsp), %rdi leaq 0x70(%rsp), %rax cmpq %rax, %rdi je 0x485fc3 movq 0x70(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0xe0(%rsp), %rdi cmpq %r12, %rdi je 0x485fe5 movq 0xf0(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x485fe5 movq %rax, %r14 movq 0x20(%rsp), %rdi leaq 0x30(%rsp), %rax cmpq %rax, %rdi je 0x486001 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movq (%rsp), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi je 0x48601c movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x40(%rsp), %rdi testq %rdi, %rdi je 0x486033 movq 0x50(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x58(%rsp), %rdi movq (%rdi), %rax callq *0x8(%rax) movq 0xc0(%rsp), %rdi leaq 0xd0(%rsp), %rax cmpq %rax, %rdi je 0x486063 movq 0xd0(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x148(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x486084 movq 0x148(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x110(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4860a5 movq 0x110(%rsp), %rsi incq %rsi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp
Assimp::SMDImporter::ParseFile()
void SMDImporter::ParseFile() { const char* szCurrent = &mBuffer[0]; // read line per line ... for ( ;; ) { if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) { break; } // "version <n> \n", <n> should be 1 for hl and hl2 SMD files if (TokenMatch(szCurrent,"version",7)) { if(!SkipSpaces(szCurrent,&szCurrent)) break; if (1 != strtoul10(szCurrent,&szCurrent)) { ASSIMP_LOG_WARN("SMD.version is not 1. This " "file format is not known. Continuing happily ..."); } continue; } // "nodes\n" - Starts the node section if (TokenMatch(szCurrent,"nodes",5)) { ParseNodesSection(szCurrent,&szCurrent); continue; } // "triangles\n" - Starts the triangle section if (TokenMatch(szCurrent,"triangles",9)) { ParseTrianglesSection(szCurrent,&szCurrent); continue; } // "vertexanimation\n" - Starts the vertex animation section if (TokenMatch(szCurrent,"vertexanimation",15)) { bHasUVs = false; ParseVASection(szCurrent,&szCurrent); continue; } // "skeleton\n" - Starts the skeleton section if (TokenMatch(szCurrent,"skeleton",8)) { ParseSkeletonSection(szCurrent,&szCurrent); continue; } SkipLine(szCurrent,&szCurrent); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x80(%rdi), %rax movq %rsp, %r12 movabsq $0x100002600, %rbp # imm = 0x100002600 movq (%rax), %r15 movl 0x104(%rbx), %r13d leal 0x1(%r13), %eax movl %eax, 0x104(%rbx) movzbl (%r15), %r14d cmpq $0x20, %r14 ja 0x48650e btq %r14, %rbp jae 0x486505 incq %r15 jmp 0x4864f0 testq %r14, %r14 je 0x4867ba movl $0x7, %edx leaq 0x14e050(%rip), %rdi # 0x5d456a movq %r15, %rsi callq 0x1a53a0 testl %eax, %eax je 0x486623 movl $0x5, %edx leaq 0x114914(%rip), %rdi # 0x59ae4a movq %r15, %rsi callq 0x1a53a0 testl %eax, %eax je 0x4866d2 movl $0x9, %edx leaq 0x11c35d(%rip), %rdi # 0x5a28af movq %r15, %rsi callq 0x1a53a0 testl %eax, %eax je 0x48671d movl $0xf, %edx leaq 0x147122(%rip), %rdi # 0x5cd690 movq %r15, %rsi callq 0x1a53a0 testl %eax, %eax je 0x486768 movl $0x8, %edx leaq 0x11f498(%rip), %rdi # 0x5a5a22 movq %r15, %rsi callq 0x1a53a0 testl %eax, %eax jne 0x4865e0 movzbl 0x8(%r15), %eax cmpq $0x20, %rax ja 0x4865e0 movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x4865e0 leaq 0x8(%r15), %rcx addq $0x9, %r15 testb %al, %al cmoveq %rcx, %r15 movq %r15, (%rsp) movq %rbx, %rdi movq %r15, %rsi movq %r12, %rdx callq 0x486c1c movq %r12, %rax jmp 0x4864dc movb 0x1(%r15), %r14b incq %r15 cmpb $0xd, %r14b ja 0x4865d9 movzbl %r14b, %eax movl $0x2401, %ecx # imm = 0x2401 btl %eax, %ecx jae 0x4865d9 jmp 0x4865fd movb 0x1(%r15), %r14b incq %r15 cmpb $0xd, %r14b je 0x4865f6 movzbl %r14b, %eax cmpl $0xa, %eax je 0x4865f6 movq %r15, (%rsp) addl $0x2, %r13d movl %r13d, 0x104(%rbx) movq %r12, %rax jmp 0x4864dc movzbl 0x7(%r15), %eax cmpq $0x20, %rax ja 0x48652a movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x48652a leaq 0x7(%r15), %rcx addq $0x8, %r15 testb %al, %al cmoveq %rcx, %r15 movq %r15, (%rsp) movzbl (%r15), %eax cmpl $0x20, %eax je 0x486666 cmpl $0x9, %eax jne 0x48666b incq %r15 jmp 0x486658 movq %r15, (%rsp) cmpl $0xd, %eax ja 0x486682 movl $0x3401, %ecx # imm = 0x3401 btl %eax, %ecx jb 0x4867ba leal -0x3a(%rax), %ecx cmpb $-0xa, %cl jb 0x4866b6 xorl %ecx, %ecx leal (%rcx,%rcx,4), %ecx addb $-0x30, %al movzbl %al, %eax leal (%rax,%rcx,2), %ecx movb 0x1(%r15), %al incq %r15 leal -0x3a(%rax), %edx cmpb $-0xb, %dl ja 0x48668c movq %r15, (%rsp) movq %r12, %rax cmpl $0x1, %ecx je 0x4864dc callq 0x241234 movq %rax, %rdi leaq 0x146f7f(%rip), %rsi # 0x5cd644 callq 0x241182 movq %r12, %rax jmp 0x4864dc movzbl 0x5(%r15), %eax cmpq $0x20, %rax ja 0x486546 movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x486546 leaq 0x5(%r15), %rcx addq $0x6, %r15 testb %al, %al cmoveq %rcx, %r15 movq %r15, (%rsp) movq %rbx, %rdi movq %r15, %rsi movq %r12, %rdx callq 0x4867ca movq %r12, %rax jmp 0x4864dc movzbl 0x9(%r15), %eax cmpq $0x20, %rax ja 0x486562 movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x486562 leaq 0x9(%r15), %rcx addq $0xa, %r15 testb %al, %al cmoveq %rcx, %r15 movq %r15, (%rsp) movq %rbx, %rdi movq %r15, %rsi movq %r12, %rdx callq 0x486896 movq %r12, %rax jmp 0x4864dc movzbl 0xf(%r15), %eax cmpq $0x20, %rax ja 0x48657e movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x48657e leaq 0xf(%r15), %rcx addq $0x10, %r15 testb %al, %al cmoveq %rcx, %r15 movq %r15, (%rsp) movb $0x0, 0x100(%rbx) movq %rbx, %rdi movq %r15, %rsi movq %r12, %rdx callq 0x486972 movq %r12, %rax jmp 0x4864dc addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nop
/hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp
Assimp::SMDImporter::ParseTriangle(char const*, char const**)
void SMDImporter::ParseTriangle(const char* szCurrent, const char** szCurrentOut) { asTriangles.push_back(SMD::Face()); SMD::Face& face = asTriangles.back(); if(!SkipSpaces(szCurrent,&szCurrent)) { LogErrorNoThrow("Unexpected EOF/EOL while parsing a triangle"); return; } // read the texture file name const char* szLast = szCurrent; while (!IsSpaceOrNewLine(*++szCurrent)); // ... and get the index that belongs to this file name face.iTexture = GetTextureIndex(std::string(szLast,(uintptr_t)szCurrent-(uintptr_t)szLast)); SkipSpacesAndLineEnd(szCurrent,&szCurrent); // load three vertices for (unsigned int iVert = 0; iVert < 3;++iVert) { ParseVertex(szCurrent,&szCurrent, face.avVertices[iVert]); } *szCurrentOut = szCurrent; }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xd0, %rsp movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 movl $0x0, 0x8(%rsp) movl $0x30, %eax xorps %xmm0, %xmm0 movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000 movups %xmm0, -0x10(%rsp,%rax) movups %xmm0, -0x20(%rsp,%rax) movq %rcx, (%rsp,%rax) movups %xmm0, 0x8(%rsp,%rax) movq $0x0, 0x18(%rsp,%rax) addq $0x40, %rax cmpq $0xf0, %rax jne 0x487181 leaq 0xc0(%r14), %rdi leaq 0x8(%rsp), %rsi callq 0x488ece movl $0xc0, %r12d movq -0x8(%rsp,%r12), %rdi testq %rdi, %rdi je 0x4871d7 movq 0x8(%rsp,%r12), %rsi subq %rdi, %rsi callq 0x1a5190 addq $-0x40, %r12 jne 0x4871c0 movq 0xc8(%r14), %r12 movzbl (%r15), %eax cmpl $0x20, %eax je 0x4871f2 cmpl $0x9, %eax jne 0x4871f7 incq %r15 jmp 0x4871e4 movq %r15, %rdx cmpl $0xd, %eax ja 0x48722c movl $0x3401, %ecx # imm = 0x3401 btl %eax, %ecx movq %r15, %rdx jae 0x48722c leaq 0x1466b8(%rip), %rsi # 0x5cd8cb movq %r14, %rdi callq 0x4854e2 addq $0xd0, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq movzbl 0x1(%rdx), %eax incq %rdx cmpq $0x20, %rax ja 0x48722c movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x48722c movq %rdx, (%rsp) leaq 0x18(%rsp), %r13 movq %r13, -0x10(%r13) leaq 0x8(%rsp), %rdi movq %r15, %rsi callq 0x209290 leaq 0x8(%rsp), %rsi movq %r14, %rdi callq 0x486db2 movl %eax, -0xc8(%r12) movq 0x8(%rsp), %rdi cmpq %r13, %rdi je 0x48728f movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 movq (%rsp), %rax incl 0x104(%r14) movabsq $0x100002600, %rcx # imm = 0x100002600 movzbl (%rax), %edx cmpq $0x20, %rdx ja 0x4872b8 btq %rdx, %rcx jae 0x4872b8 incq %rax jmp 0x4872a4 movq %rsp, %r15 movq %rax, (%r15) movq $-0xc0, %r13 movq (%rsp), %rsi leaq (%r12,%r13), %rcx movq %r14, %rdi movq %r15, %rdx xorl %r8d, %r8d callq 0x4873a6 addq $0x40, %r13 jne 0x4872c5 movq (%rsp), %rax movq %rax, (%rbx) jmp 0x48721b movq %rax, %rbx movq 0x8(%rsp), %rdi cmpq %r13, %rdi je 0x48731b movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x48731b movq %rax, %rbx jmp 0x48731b movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x4883fe movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp
Assimp::SMDImporter::ParseSkeletonElement(char const*, char const**, int)
void SMDImporter::ParseSkeletonElement(const char* szCurrent, const char** szCurrentOut,int iTime) { aiVector3D vPos; aiVector3D vRot; unsigned int iBone = 0; if(!ParseUnsignedInt(szCurrent,&szCurrent,iBone)) { ASSIMP_LOG_ERROR("Unexpected EOF/EOL while parsing bone index"); SMDI_PARSE_RETURN; } if (iBone >= asBones.size()) { LogErrorNoThrow("Bone index in skeleton section is out of range"); SMDI_PARSE_RETURN; } SMD::Bone& bone = asBones[iBone]; bone.sAnim.asKeys.push_back(SMD::Bone::Animation::MatrixKey()); SMD::Bone::Animation::MatrixKey& key = bone.sAnim.asKeys.back(); key.dTime = (double)iTime; if(!ParseFloat(szCurrent,&szCurrent,(float&)vPos.x)) { LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.pos.x"); SMDI_PARSE_RETURN; } if(!ParseFloat(szCurrent,&szCurrent,(float&)vPos.y)) { LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.pos.y"); SMDI_PARSE_RETURN; } if(!ParseFloat(szCurrent,&szCurrent,(float&)vPos.z)) { LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.pos.z"); SMDI_PARSE_RETURN; } if(!ParseFloat(szCurrent,&szCurrent,(float&)vRot.x)) { LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.rot.x"); SMDI_PARSE_RETURN; } if(!ParseFloat(szCurrent,&szCurrent,(float&)vRot.y)) { LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.rot.y"); SMDI_PARSE_RETURN; } if(!ParseFloat(szCurrent,&szCurrent,(float&)vRot.z)) { LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.rot.z"); SMDI_PARSE_RETURN; } // build the transformation matrix of the key key.matrix.FromEulerAnglesXYZ(vRot.x,vRot.y,vRot.z); { aiMatrix4x4 mTemp; mTemp.a4 = vPos.x; mTemp.b4 = vPos.y; mTemp.c4 = vPos.z; key.matrix = mTemp * key.matrix; } key.vPos = vPos; key.vRot = vRot; // go to the beginning of the next line SMDI_PARSE_RETURN; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xd8, %rsp movl %ecx, %r12d movq %rsi, %r13 leaq 0x2c(%rsp), %rbx xorl %eax, %eax movq %rax, -0x4(%rbx) leaq 0x30(%rsp), %rbp movl %eax, (%rbp) leaq 0x1c(%rsp), %rcx movq %rax, -0x4(%rcx) leaq 0x20(%rsp), %rcx movl %eax, (%rcx) movabsq $0x100000200, %r14 # imm = 0x100000200 movq %rsi, %r15 movzbl (%r15), %ecx cmpq $0x20, %rcx ja 0x487ac1 btq %rcx, %r14 jae 0x487a64 incq %r15 jmp 0x487a4f movl $0x3401, %eax # imm = 0x3401 btq %rcx, %rax jae 0x487ac1 movq %rdi, %r14 movq %rdx, %rbx callq 0x241234 leaq 0x145c3c(%rip), %rsi # 0x5cd6bd movq %rax, %rdi callq 0x2411ba movl $0x2401, %ecx # imm = 0x2401 movzbl (%r13), %eax cmpl $0xd, %eax ja 0x487a9d btl %eax, %ecx jb 0x487aa2 incq %r13 jmp 0x487a8e movq %rbx, %rdx movq %r14, %rcx cmpb $0xd, %al je 0x487ab8 movzbl %al, %eax cmpl $0xa, %eax jne 0x487c9c movb 0x1(%r13), %al incq %r13 jmp 0x487aa8 movq %rdx, 0x10(%rsp) leal -0x3a(%rcx), %edx xorl %eax, %eax cmpb $-0xa, %dl jb 0x487aed leal (%rax,%rax,4), %eax addb $-0x30, %cl movzbl %cl, %ecx leal (%rcx,%rax,2), %eax movb 0x1(%r15), %cl incq %r15 leal -0x3a(%rcx), %edx cmpb $-0xa, %dl jae 0x487ad0 movl %eax, %eax movq 0xd8(%rdi), %rcx movq 0xe0(%rdi), %rdx subq %rcx, %rdx sarq $0x4, %rdx movabsq $-0x71c71c71c71c71c7, %rsi # imm = 0x8E38E38E38E38E39 imulq %rdx, %rsi cmpq %rax, %rsi jbe 0x487bbf movq %rdi, 0x8(%rsp) leaq (%rax,%rax,8), %rax shlq $0x4, %rax leaq (%rcx,%rax), %r13 addq $0x30, %r13 movl $0x3f800000, %eax # imm = 0x3F800000 movl %eax, 0x38(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x3c(%rsp) movl %eax, 0x4c(%rsp) movups %xmm0, 0x50(%rsp) movl %eax, 0x60(%rsp) movups %xmm0, 0x64(%rsp) movsd 0xd3777(%rip), %xmm1 # 0x55b2d0 movsd %xmm1, 0x74(%rsp) movups %xmm0, 0x7c(%rsp) movl %eax, 0x8c(%rsp) movups %xmm0, 0x90(%rsp) movl %eax, 0xa0(%rsp) movups %xmm0, 0xa4(%rsp) movl %eax, 0xb4(%rsp) movups %xmm0, 0xb8(%rsp) movups %xmm0, 0xc8(%rsp) movq 0x8(%r13), %rax cmpq 0x10(%r13), %rax je 0x487c07 leaq 0x38(%rsp), %rsi movl $0xa0, %edx movq %rax, %rdi callq 0x1a5110 addq $0xa0, 0x8(%r13) jmp 0x487c17 leaq 0x145bce(%rip), %rsi # 0x5cd794 movq %rdi, %rbx callq 0x4854e2 movl $0x2401, %ecx # imm = 0x2401 movq 0x10(%rsp), %rdx movzbl (%r15), %eax cmpl $0xd, %eax ja 0x487be6 btl %eax, %ecx jb 0x487beb incq %r15 jmp 0x487bd8 movq %rbx, %rcx cmpb $0xd, %al je 0x487bfe movzbl %al, %eax cmpl $0xa, %eax jne 0x487c99 movb 0x1(%r15), %al incq %r15 jmp 0x487bee leaq 0x38(%rsp), %rdx movq %r13, %rdi movq %rax, %rsi callq 0x489482 movq 0x8(%r13), %rdx leaq -0xa0(%rdx), %rsi xorps %xmm0, %xmm0 cvtsi2sd %r12d, %xmm0 movsd %xmm0, -0x8(%rdx) movq %r15, %rdi movzbl (%rdi), %eax cmpq $0x20, %rax ja 0x487cb7 btq %rax, %r14 jae 0x487c46 incq %rdi jmp 0x487c32 movl $0x3401, %ecx # imm = 0x3401 btq %rax, %rcx jae 0x487cb7 leaq 0x145b6b(%rip), %rsi # 0x5cd7c3 movq 0x8(%rsp), %rdi callq 0x4854e2 movl $0x2401, %ecx # imm = 0x2401 movq 0x10(%rsp), %rdx movzbl (%r15), %eax cmpl $0xd, %eax ja 0x487c7a btl %eax, %ecx jb 0x487c7f incq %r15 jmp 0x487c6c movq 0x8(%rsp), %rcx cmpb $0xd, %al je 0x487c90 movzbl %al, %eax cmpl $0xa, %eax jne 0x487c99 movb 0x1(%r15), %al incq %r15 jmp 0x487c84 movq %r15, %r13 incl 0x104(%rcx) movq %r13, (%rdx) addq $0xd8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rsi, %r12 movq %rdx, %r15 leaq 0x28(%rsp), %rsi movl $0x1, %edx callq 0x2470c9 movq %rax, %r13 movq %rax, %rdi movzbl (%rdi), %eax cmpq $0x20, %rax ja 0x487d3e btq %rax, %r14 jae 0x487ce6 incq %rdi jmp 0x487cd2 movl $0x3401, %ecx # imm = 0x3401 btq %rax, %rcx jae 0x487d3e leaq 0x145af7(%rip), %rsi # 0x5cd7ef movq 0x8(%rsp), %rdi callq 0x4854e2 movl $0x2401, %ecx # imm = 0x2401 movq 0x10(%rsp), %rdx movzbl (%r13), %eax cmpl $0xd, %eax ja 0x487d1b btl %eax, %ecx jb 0x487d20 incq %r13 jmp 0x487d0c movq 0x8(%rsp), %rcx cmpb $0xd, %al je 0x487d35 movzbl %al, %eax cmpl $0xa, %eax jne 0x487c9c movb 0x1(%r13), %al incq %r13 jmp 0x487d25 movq %rbx, %rsi movl $0x1, %edx callq 0x2470c9 movq %rax, %r13 movq %rax, %rdi movzbl (%rdi), %eax cmpq $0x20, %rax ja 0x487dbd btq %rax, %r14 jae 0x487d65 incq %rdi jmp 0x487d51 movl $0x3401, %ecx # imm = 0x3401 btq %rax, %rcx jae 0x487dbd leaq 0x145aa4(%rip), %rsi # 0x5cd81b movq 0x8(%rsp), %rdi callq 0x4854e2 movl $0x2401, %ecx # imm = 0x2401 movq 0x10(%rsp), %rdx movzbl (%r13), %eax cmpl $0xd, %eax ja 0x487d9a btl %eax, %ecx jb 0x487d9f incq %r13 jmp 0x487d8b movq 0x8(%rsp), %rcx cmpb $0xd, %al je 0x487db4 movzbl %al, %eax cmpl $0xa, %eax jne 0x487c9c movb 0x1(%r13), %al incq %r13 jmp 0x487da4 movq %rbp, %rsi movl $0x1, %edx callq 0x2470c9 movq %rax, %r13 movq %rax, %rdi movzbl (%rdi), %eax cmpq $0x20, %rax ja 0x487e3c btq %rax, %r14 jae 0x487de4 incq %rdi jmp 0x487dd0 movl $0x3401, %ecx # imm = 0x3401 btq %rax, %rcx jae 0x487e3c leaq 0x145a51(%rip), %rsi # 0x5cd847 movq 0x8(%rsp), %rdi callq 0x4854e2 movl $0x2401, %ecx # imm = 0x2401 movq 0x10(%rsp), %rdx movzbl (%r13), %eax cmpl $0xd, %eax ja 0x487e19 btl %eax, %ecx jb 0x487e1e incq %r13 jmp 0x487e0a movq 0x8(%rsp), %rcx cmpb $0xd, %al je 0x487e33 movzbl %al, %eax cmpl $0xa, %eax jne 0x487c9c movb 0x1(%r13), %al incq %r13 jmp 0x487e23 leaq 0x18(%rsp), %rsi movl $0x1, %edx callq 0x2470c9 movq %rax, %r13 movq %rax, %rdi movzbl (%rdi), %eax cmpq $0x20, %rax ja 0x487ebd btq %rax, %r14 jae 0x487e65 incq %rdi jmp 0x487e51 movl $0x3401, %ecx # imm = 0x3401 btq %rax, %rcx jae 0x487ebd leaq 0x1459fc(%rip), %rsi # 0x5cd873 movq 0x8(%rsp), %rdi callq 0x4854e2 movl $0x2401, %ecx # imm = 0x2401 movq 0x10(%rsp), %rdx movzbl (%r13), %eax cmpl $0xd, %eax ja 0x487e9a btl %eax, %ecx jb 0x487e9f incq %r13 jmp 0x487e8b movq 0x8(%rsp), %rcx cmpb $0xd, %al je 0x487eb4 movzbl %al, %eax cmpl $0xa, %eax jne 0x487c9c movb 0x1(%r13), %al incq %r13 jmp 0x487ea4 leaq 0x1c(%rsp), %rsi movl $0x1, %edx callq 0x2470c9 movq %rax, %r13 movq %rax, %rdi movzbl (%rdi), %eax cmpq $0x20, %rax ja 0x487f3d btq %rax, %r14 jae 0x487ee6 incq %rdi jmp 0x487ed2 movl $0x3401, %ecx # imm = 0x3401 btq %rax, %rcx jae 0x487f3d leaq 0x1459a7(%rip), %rsi # 0x5cd89f movq 0x8(%rsp), %rdi callq 0x4854e2 movl $0x2401, %ecx # imm = 0x2401 movzbl (%r13), %eax cmpl $0xd, %eax ja 0x487f16 btl %eax, %ecx jb 0x487f22 incq %r13 jmp 0x487f07 movb 0x1(%r13), %al incq %r13 cmpb $0xd, %al je 0x487f1b movzbl %al, %eax cmpl $0xa, %eax je 0x487f1b movq 0x10(%rsp), %rdx movq 0x8(%rsp), %rcx jmp 0x487c9c leaq 0x20(%rsp), %rsi movl $0x1, %edx callq 0x2470c9 movq %rax, %r13 movss 0x18(%rsp), %xmm0 movss 0x1c(%rsp), %xmm1 movss 0x20(%rsp), %xmm2 movq %r12, %rdi callq 0x4884f4 movss 0x28(%rsp), %xmm0 movss 0x2c(%rsp), %xmm1 movss 0x30(%rsp), %xmm2 movl $0x3f800000, %eax # imm = 0x3F800000 leaq 0x38(%rsp), %rbx movl %eax, (%rbx) xorl %ecx, %ecx movq %rcx, 0x4(%rbx) movss %xmm0, 0xc(%rbx) movsd 0xd35a6(%rip), %xmm0 # 0x55b540 movsd %xmm0, 0x10(%rbx) movl $0x0, 0x18(%rbx) movss %xmm1, 0x1c(%rbx) movq %rcx, 0x20(%rbx) movl %eax, 0x28(%rbx) movss %xmm2, 0x2c(%rbx) movq %rcx, 0x30(%rbx) movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000 movq %rax, 0x38(%rbx) movq %rbx, %rdi movq %r12, %rsi callq 0x488752 movupd (%rbx), %xmm0 movups 0x10(%rbx), %xmm1 movups 0x20(%rbx), %xmm2 movups 0x30(%rbx), %xmm3 movups %xmm3, 0x30(%r12) movups %xmm2, 0x20(%r12) movups %xmm1, 0x10(%r12) movupd %xmm0, (%r12) movl 0x30(%rsp), %eax movl %eax, -0x18(%r15) movq 0x28(%rsp), %rax movq %rax, -0x20(%r15) movq 0x18(%rsp), %rax movq %rax, -0x14(%r15) movl 0x20(%rsp), %eax movl %eax, -0xc(%r15) movl $0x2401, %ecx # imm = 0x2401 movzbl (%r13), %eax cmpl $0xd, %eax ja 0x488032 btl %eax, %ecx jb 0x48803e incq %r13 jmp 0x488023 movb 0x1(%r13), %al incq %r13 cmpb $0xd, %al je 0x488037 movzbl %al, %eax cmpl $0xa, %eax je 0x488037 jmp 0x487f2e nop
/hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp
Assimp::STLImporter::pushMeshesToNode(std::vector<unsigned int, std::allocator<unsigned int>>&, aiNode*)
void STLImporter::pushMeshesToNode( std::vector<unsigned int> &meshIndices, aiNode *node ) { ai_assert( nullptr != node ); if ( meshIndices.empty() ) { return; } node->mNumMeshes = static_cast<unsigned int>( meshIndices.size() ); node->mMeshes = new unsigned int[ meshIndices.size() ]; for ( size_t i=0; i<meshIndices.size(); ++i ) { node->mMeshes[ i ] = meshIndices[ i ]; } meshIndices.clear(); }
pushq %r14 pushq %rbx pushq %rax testq %rdx, %rdx je 0x48b4dd movq %rsi, %rbx movq (%rsi), %rcx movq 0x8(%rsi), %rax cmpq %rax, %rcx je 0x48b4d5 movq %rdx, %r14 subq %rcx, %rax shrq $0x2, %rax movl %eax, 0x460(%rdx) movq 0x8(%rbx), %rax subq (%rbx), %rax movq $-0x1, %rdi cmovnsq %rax, %rdi callq 0x1a57a0 movq %rax, 0x468(%r14) movq (%rbx), %rax movq 0x8(%rbx), %rdx cmpq %rax, %rdx je 0x48b4cc xorl %ecx, %ecx movl (%rax,%rcx,4), %eax movq 0x468(%r14), %rdx movl %eax, (%rdx,%rcx,4) incq %rcx movq (%rbx), %rax movq 0x8(%rbx), %rdx movq %rdx, %rsi subq %rax, %rsi sarq $0x2, %rsi cmpq %rsi, %rcx jb 0x48b4a6 cmpq %rax, %rdx je 0x48b4d5 movq %rax, 0x8(%rbx) addq $0x8, %rsp popq %rbx popq %r14 retq leaq 0x11b947(%rip), %rdi # 0x5a6e2b leaq 0x1426cd(%rip), %rsi # 0x5cdbb8 leaq 0x1429f2(%rip), %rcx # 0x5cdee4 movl $0x239, %edx # imm = 0x239 callq 0x1a5270
/hbina[P]fatuous/thirdparty/assimp/code/STL/STLLoader.cpp
Assimp::UnrealImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*)
void UnrealImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) { // For any of the 3 files being passed get the three correct paths // First of all, determine file extension std::string::size_type pos = pFile.find_last_of('.'); std::string extension = GetExtension(pFile); std::string d_path,a_path,uc_path; if (extension == "3d") { // jjjj_d.3d // jjjj_a.3d pos = pFile.find_last_of('_'); if (std::string::npos == pos) { throw DeadlyImportError("UNREAL: Unexpected naming scheme"); } extension = pFile.substr(0,pos); } else { extension = pFile.substr(0,pos); } // build proper paths d_path = extension+"_d.3d"; a_path = extension+"_a.3d"; uc_path = extension+".uc"; ASSIMP_LOG_DEBUG_F( "UNREAL: data file is ", d_path); ASSIMP_LOG_DEBUG_F("UNREAL: aniv file is ", a_path); ASSIMP_LOG_DEBUG_F("UNREAL: uc file is ", uc_path); // and open the files ... we can't live without them std::unique_ptr<IOStream> p(pIOHandler->Open(d_path)); if (!p) throw DeadlyImportError("UNREAL: Unable to open _d file"); StreamReaderLE d_reader(pIOHandler->Open(d_path)); const uint16_t numTris = d_reader.GetI2(); const uint16_t numVert = d_reader.GetI2(); d_reader.IncPtr(44); if (!numTris || numVert < 3) throw DeadlyImportError("UNREAL: Invalid number of vertices/triangles"); // maximum texture index unsigned int maxTexIdx = 0; // collect triangles std::vector<Unreal::Triangle> triangles(numTris); for (auto & tri : triangles) { for (unsigned int i = 0; i < 3;++i) { tri.mVertex[i] = d_reader.GetI2(); if (tri.mVertex[i] >= numTris) { ASSIMP_LOG_WARN("UNREAL: vertex index out of range"); tri.mVertex[i] = 0; } } tri.mType = d_reader.GetI1(); // handle mesh flagss? if (configHandleFlags) tri.mType = Unreal::MF_NORMAL_OS; else { // ignore MOD and MASKED for the moment, treat them as two-sided if (tri.mType == Unreal::MF_NORMAL_MOD_TS || tri.mType == Unreal::MF_NORMAL_MASKED_TS) tri.mType = Unreal::MF_NORMAL_TS; } d_reader.IncPtr(1); for (unsigned int i = 0; i < 3;++i) for (unsigned int i2 = 0; i2 < 2;++i2) tri.mTex[i][i2] = d_reader.GetI1(); tri.mTextureNum = d_reader.GetI1(); maxTexIdx = std::max(maxTexIdx,(unsigned int)tri.mTextureNum); d_reader.IncPtr(1); } p.reset(pIOHandler->Open(a_path)); if (!p) throw DeadlyImportError("UNREAL: Unable to open _a file"); StreamReaderLE a_reader(pIOHandler->Open(a_path)); // read number of frames const uint32_t numFrames = a_reader.GetI2(); if (configFrameID >= numFrames) throw DeadlyImportError("UNREAL: The requested frame does not exist"); uint32_t st = a_reader.GetI2(); if (st != numVert*4) throw DeadlyImportError("UNREAL: Unexpected aniv file length"); // skip to our frame a_reader.IncPtr(configFrameID *numVert*4); // collect vertices std::vector<aiVector3D> vertices(numVert); for (auto &vertex : vertices) { int32_t val = a_reader.GetI4(); Unreal::DecompressVertex(vertex ,val); } // list of textures. std::vector< std::pair<unsigned int, std::string> > textures; // allocate the output scene aiNode* nd = pScene->mRootNode = new aiNode(); nd->mName.Set("<UnrealRoot>"); // we can live without the uc file if necessary std::unique_ptr<IOStream> pb (pIOHandler->Open(uc_path)); if (pb.get()) { std::vector<char> _data; TextFileToBuffer(pb.get(),_data); const char* data = &_data[0]; std::vector< std::pair< std::string,std::string > > tempTextures; // do a quick search in the UC file for some known, usually texture-related, tags for (;*data;++data) { if (TokenMatchI(data,"#exec",5)) { SkipSpacesAndLineEnd(&data); // #exec TEXTURE IMPORT [...] NAME=jjjjj [...] FILE=jjjj.pcx [...] if (TokenMatchI(data,"TEXTURE",7)) { SkipSpacesAndLineEnd(&data); if (TokenMatchI(data,"IMPORT",6)) { tempTextures.push_back(std::pair< std::string,std::string >()); std::pair< std::string,std::string >& me = tempTextures.back(); for (;!IsLineEnd(*data);++data) { if (!::ASSIMP_strincmp(data,"NAME=",5)) { const char *d = data+=5; for (;!IsSpaceOrNewLine(*data);++data); me.first = std::string(d,(size_t)(data-d)); } else if (!::ASSIMP_strincmp(data,"FILE=",5)) { const char *d = data+=5; for (;!IsSpaceOrNewLine(*data);++data); me.second = std::string(d,(size_t)(data-d)); } } if (!me.first.length() || !me.second.length()) tempTextures.pop_back(); } } // #exec MESHMAP SETTEXTURE MESHMAP=box NUM=1 TEXTURE=Jtex1 // #exec MESHMAP SCALE MESHMAP=box X=0.1 Y=0.1 Z=0.2 else if (TokenMatchI(data,"MESHMAP",7)) { SkipSpacesAndLineEnd(&data); if (TokenMatchI(data,"SETTEXTURE",10)) { textures.push_back(std::pair<unsigned int, std::string>()); std::pair<unsigned int, std::string>& me = textures.back(); for (;!IsLineEnd(*data);++data) { if (!::ASSIMP_strincmp(data,"NUM=",4)) { data += 4; me.first = strtoul10(data,&data); } else if (!::ASSIMP_strincmp(data,"TEXTURE=",8)) { data += 8; const char *d = data; for (;!IsSpaceOrNewLine(*data);++data); me.second = std::string(d,(size_t)(data-d)); // try to find matching path names, doesn't care if we don't find them for (std::vector< std::pair< std::string,std::string > >::const_iterator it = tempTextures.begin(); it != tempTextures.end(); ++it) { if ((*it).first == me.second) { me.second = (*it).second; break; } } } } } else if (TokenMatchI(data,"SCALE",5)) { for (;!IsLineEnd(*data);++data) { if (data[0] == 'X' && data[1] == '=') { data = fast_atoreal_move<float>(data+2,(float&)nd->mTransformation.a1); } else if (data[0] == 'Y' && data[1] == '=') { data = fast_atoreal_move<float>(data+2,(float&)nd->mTransformation.b2); } else if (data[0] == 'Z' && data[1] == '=') { data = fast_atoreal_move<float>(data+2,(float&)nd->mTransformation.c3); } } } } } } } else { ASSIMP_LOG_ERROR("Unable to open .uc file"); } std::vector<Unreal::TempMat> materials; materials.reserve(textures.size()*2+5); // find out how many output meshes and materials we'll have and build material indices for (Unreal::Triangle &tri : triangles) { Unreal::TempMat mat(tri); std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(),materials.end(),mat); if (nt == materials.end()) { // add material tri.matIndex = static_cast<unsigned int>(materials.size()); mat.numFaces = 1; materials.push_back(mat); ++pScene->mNumMeshes; } else { tri.matIndex = static_cast<unsigned int>(nt-materials.begin()); ++nt->numFaces; } } if (!pScene->mNumMeshes) { throw DeadlyImportError("UNREAL: Unable to find valid mesh data"); } // allocate meshes and bind them to the node graph pScene->mMeshes = new aiMesh*[pScene->mNumMeshes]; pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = pScene->mNumMeshes]; nd->mNumMeshes = pScene->mNumMeshes; nd->mMeshes = new unsigned int[nd->mNumMeshes]; for (unsigned int i = 0; i < pScene->mNumMeshes;++i) { aiMesh* m = pScene->mMeshes[i] = new aiMesh(); m->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; const unsigned int num = materials[i].numFaces; m->mFaces = new aiFace [num]; m->mVertices = new aiVector3D [num*3]; m->mTextureCoords[0] = new aiVector3D [num*3]; nd->mMeshes[i] = i; // create materials, too aiMaterial* mat = new aiMaterial(); pScene->mMaterials[i] = mat; // all white by default - texture rulez aiColor3D color(1.f,1.f,1.f); aiString s; ::ai_snprintf( s.data, MAXLEN, "mat%u_tx%u_",i,materials[i].tex ); // set the two-sided flag if (materials[i].type == Unreal::MF_NORMAL_TS) { const int twosided = 1; mat->AddProperty(&twosided,1,AI_MATKEY_TWOSIDED); ::strcat(s.data,"ts_"); } else ::strcat(s.data,"os_"); // make TRANS faces 90% opaque that RemRedundantMaterials won't catch us if (materials[i].type == Unreal::MF_NORMAL_TRANS_TS) { const float opac = 0.9f; mat->AddProperty(&opac,1,AI_MATKEY_OPACITY); ::strcat(s.data,"tran_"); } else ::strcat(s.data,"opaq_"); // a special name for the weapon attachment point if (materials[i].type == Unreal::MF_WEAPON_PLACEHOLDER) { s.length = ::ai_snprintf( s.data, MAXLEN, "$WeaponTag$" ); color = aiColor3D(0.f,0.f,0.f); } // set color and name mat->AddProperty(&color,1,AI_MATKEY_COLOR_DIFFUSE); s.length = ::strlen(s.data); mat->AddProperty(&s,AI_MATKEY_NAME); // set texture, if any const unsigned int tex = materials[i].tex; for (std::vector< std::pair< unsigned int, std::string > >::const_iterator it = textures.begin();it != textures.end();++it) { if ((*it).first == tex) { s.Set((*it).second); mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0)); break; } } } // fill them. for (const Unreal::Triangle &tri : triangles) { Unreal::TempMat mat(tri); std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(),materials.end(),mat); aiMesh* mesh = pScene->mMeshes[nt-materials.begin()]; aiFace& f = mesh->mFaces[mesh->mNumFaces++]; f.mIndices = new unsigned int[f.mNumIndices = 3]; for (unsigned int i = 0; i < 3;++i,mesh->mNumVertices++) { f.mIndices[i] = mesh->mNumVertices; mesh->mVertices[mesh->mNumVertices] = vertices[ tri.mVertex[i] ]; mesh->mTextureCoords[0][mesh->mNumVertices] = aiVector3D( tri.mTex[i][0] / 255.f, 1.f - tri.mTex[i][1] / 255.f, 0.f); } } // convert to RH MakeLeftHandedProcess hero; hero.Execute(pScene); FlipWindingOrderProcess flipper; flipper.Execute(pScene); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x5d8, %rsp # imm = 0x5D8 movq %rcx, %rbp movq %rdx, %r15 movq %rsi, %r14 movq %rdi, 0x30(%rsp) movq %rsi, %rdi movl $0x2e, %esi movq $-0x1, %rdx callq 0x1a5730 movq %rax, %rbx leaq 0xf8(%rsp), %r13 movq %r13, %rdi movq %r14, %rsi callq 0x24818a leaq 0x148(%rsp), %rcx movq %rcx, -0x10(%rcx) xorl %eax, %eax movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0x128(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0x168(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0xd53b7(%rip), %rsi # 0x561861 movq %r13, %rdi callq 0x1a60c0 testl %eax, %eax je 0x48c4cd leaq 0x198(%rsp), %rdi movq %r14, %rsi xorl %edx, %edx movq %rbx, %rcx callq 0x1a6240 jmp 0x48c500 movq %r14, %rdi movl $0x5f, %esi movq $-0x1, %rdx callq 0x1a5730 cmpq $-0x1, %rax je 0x48ded4 leaq 0x198(%rsp), %rdi movq %r14, %rsi xorl %edx, %edx movq %rax, %rcx callq 0x1a6240 leaq 0xf8(%rsp), %rdi leaq 0x198(%rsp), %rbx movq %rbx, %rsi callq 0x1a58d0 movq (%rbx), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48c538 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x1a8(%rsp), %r12 movq %r12, -0x10(%r12) movq 0xf8(%rsp), %rsi movq 0x100(%rsp), %rdx addq %rsi, %rdx leaq 0x198(%rsp), %rdi callq 0x20ac60 leaq 0x141cb1(%rip), %rsi # 0x5ce21d leaq 0x198(%rsp), %rdi callq 0x1a5ba0 leaq 0x138(%rsp), %rdi leaq 0x198(%rsp), %rbx movq %rbx, %rsi callq 0x1a58d0 movq (%rbx), %rdi cmpq %r12, %rdi je 0x48c5a9 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x198(%rsp), %rdi movq %r12, (%rdi) movq 0xf8(%rsp), %rsi movq 0x100(%rsp), %rdx addq %rsi, %rdx callq 0x20ac60 leaq 0x141c50(%rip), %rsi # 0x5ce223 leaq 0x198(%rsp), %rdi callq 0x1a5ba0 leaq 0x118(%rsp), %rdi leaq 0x198(%rsp), %rbx movq %rbx, %rsi callq 0x1a58d0 movq (%rbx), %rdi cmpq %r12, %rdi je 0x48c610 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x198(%rsp), %rdi movq %r12, (%rdi) movq 0xf8(%rsp), %rsi movq 0x100(%rsp), %rdx addq %rsi, %rdx callq 0x20ac60 leaq 0x141bef(%rip), %rsi # 0x5ce229 leaq 0x198(%rsp), %rdi callq 0x1a5ba0 leaq 0x158(%rsp), %rdi leaq 0x198(%rsp), %rbx movq %rbx, %rsi callq 0x1a58d0 movq (%rbx), %rdi cmpq %r12, %rdi je 0x48c677 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 callq 0x241234 movq %rax, %rbx leaq 0x141ba7(%rip), %rsi # 0x5ce22d leaq 0x198(%rsp), %rdi callq 0x320320 movq 0x138(%rsp), %rsi movq 0x140(%rsp), %rdx leaq 0x198(%rsp), %rdi callq 0x1a61e0 leaq 0x1a0(%rsp), %rsi leaq 0x90(%rsp), %rdi callq 0x1a5690 movq 0x90(%rsp), %rsi movq %rbx, %rdi callq 0x241112 leaq 0xa0(%rsp), %r14 movq -0x10(%r14), %rdi cmpq %r14, %rdi je 0x48c6f6 movq 0xa0(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x31f893(%rip), %rsi # 0x7abf90 leaq 0x198(%rsp), %rdi callq 0x1a5d00 leaq 0x208(%rsp), %rdi callq 0x1a5ca0 callq 0x241234 movq %rax, %rbx leaq 0x141b1d(%rip), %rsi # 0x5ce243 leaq 0x198(%rsp), %rdi callq 0x320320 movq 0x118(%rsp), %rsi movq 0x120(%rsp), %rdx leaq 0x198(%rsp), %rdi callq 0x1a61e0 leaq 0x1a0(%rsp), %rsi leaq 0x90(%rsp), %rdi callq 0x1a5690 movq 0x90(%rsp), %rsi movq %rbx, %rdi callq 0x241112 movq 0x90(%rsp), %rdi cmpq %r14, %rdi je 0x48c792 movq 0xa0(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x31f7f7(%rip), %rsi # 0x7abf90 leaq 0x198(%rsp), %rdi callq 0x1a5d00 leaq 0x208(%rsp), %rdi callq 0x1a5ca0 callq 0x241234 movq %rax, %rbx leaq 0x141a97(%rip), %rsi # 0x5ce259 leaq 0x198(%rsp), %rdi callq 0x23c920 movq 0x158(%rsp), %rsi movq 0x160(%rsp), %rdx leaq 0x198(%rsp), %rdi callq 0x1a61e0 leaq 0x1a0(%rsp), %rsi leaq 0x90(%rsp), %rdi callq 0x1a5690 movq 0x90(%rsp), %rsi movq %rbx, %rdi callq 0x241112 movq 0x90(%rsp), %rdi cmpq %r14, %rdi je 0x48c82e movq 0xa0(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x31f75b(%rip), %rsi # 0x7abf90 leaq 0x198(%rsp), %rdi callq 0x1a5d00 leaq 0x208(%rsp), %rbx movq %rbx, %rdi callq 0x1a5ca0 movq %r12, -0x70(%rbx) leaq 0x11df04(%rip), %rsi # 0x5aa761 leaq 0x11deff(%rip), %rdx # 0x5aa763 leaq 0x198(%rsp), %rdi callq 0x209290 movq 0x138(%rsp), %rsi movq 0x198(%rsp), %rdx movq (%rbp), %rax movq %rbp, %rdi callq *0x20(%rax) movq %rax, 0x8(%rsp) movq 0x198(%rsp), %rdi cmpq %r12, %rdi je 0x48c8ad movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 cmpq $0x0, 0x8(%rsp) je 0x48dc51 leaq 0x198(%rsp), %rdi movq %r12, (%rdi) leaq 0x11de96(%rip), %rsi # 0x5aa761 leaq 0x11de91(%rip), %rdx # 0x5aa763 callq 0x209290 movq 0x138(%rsp), %rsi movq 0x198(%rsp), %rdx movq (%rbp), %rax movq %rbp, %rdi callq *0x20(%rax) leaq 0x90(%rsp), %rdi movq %rax, %rsi xorl %edx, %edx callq 0x27ede4 movq 0x198(%rsp), %rdi cmpq %r12, %rdi je 0x48c920 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x90(%rsp), %rdi callq 0x28088e movl %eax, %r13d leaq 0x90(%rsp), %rdi callq 0x28088e movl %eax, %ebx leaq 0x90(%rsp), %rdi movl $0x2c, %esi callq 0x27f688 testw %r13w, %r13w je 0x48dcb6 cmpw $0x2, %bx jbe 0x48dcb6 movw %bx, 0x80(%rsp) movq %rbp, 0x38(%rsp) movq %r15, 0x48(%rsp) movzwl %r13w, %esi leaq 0xc8(%rsp), %rdi leaq 0x198(%rsp), %rdx callq 0x48e4ce movq 0xc8(%rsp), %rbx movq 0xd0(%rsp), %r15 cmpq %r15, %rbx je 0x48ca6d leaq 0x90(%rsp), %r14 leaq 0x141901(%rip), %rbp # 0x5ce2b9 xorl %r12d, %r12d movq %r14, %rdi callq 0x28088e movw %ax, (%rbx,%r12,2) cmpw %r13w, %ax jb 0x48c9e5 callq 0x241234 movq %rax, %rdi movq %rbp, %rsi callq 0x241182 movw $0x0, (%rbx,%r12,2) incq %r12 cmpq $0x3, %r12 jne 0x48c9bb movq %r14, %rdi callq 0x280a0a movb %al, 0x6(%rbx) movq 0x30(%rsp), %rcx cmpb $0x0, 0x7c(%rcx) je 0x48ca08 xorl %ecx, %ecx jmp 0x48ca10 addb $-0x3, %al movb $0x1, %cl cmpb $0x1, %al ja 0x48ca13 movb %cl, 0x6(%rbx) movl $0x1, %esi movq %r14, %rdi callq 0x27f688 movl $0x4, %r12d movq %r14, %rdi callq 0x280a0a movb %al, (%rbx,%r12,2) movq %r14, %rdi callq 0x280a0a movb %al, 0x1(%rbx,%r12,2) incq %r12 cmpq $0x7, %r12 jne 0x48ca26 movq %r14, %rdi callq 0x280a0a movb %al, 0xe(%rbx) movl $0x1, %esi movq %r14, %rdi callq 0x27f688 addq $0x14, %rbx cmpq %r15, %rbx jne 0x48c9b8 leaq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax movq %rax, (%rdi) leaq 0x11dcda(%rip), %rsi # 0x5aa761 leaq 0x11dcd5(%rip), %rdx # 0x5aa763 callq 0x209290 movq 0x118(%rsp), %rsi movq 0x198(%rsp), %rdx movq 0x38(%rsp), %rdi movq (%rdi), %rax callq *0x20(%rax) movq %rax, 0x88(%rsp) movq 0x48(%rsp), %rbp movq 0x8(%rsp), %rdi movq (%rdi), %rax callq *0x8(%rax) movq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48caeb movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 cmpq $0x0, 0x88(%rsp) movzwl 0x80(%rsp), %ebx je 0x48dd23 leaq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax movq %rax, (%rdi) leaq 0x11dc45(%rip), %rsi # 0x5aa761 leaq 0x11dc40(%rip), %rdx # 0x5aa763 callq 0x209290 movq 0x118(%rsp), %rsi movq 0x198(%rsp), %rdx movq 0x38(%rsp), %rdi movq (%rdi), %rax callq *0x20(%rax) leaq 0x5a0(%rsp), %rdi movq %rax, %rsi xorl %edx, %edx callq 0x27ede4 movq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48cb7a movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x5a0(%rsp), %rdi callq 0x28088e cwtl movq 0x30(%rsp), %rcx cmpl %eax, 0x78(%rcx) jae 0x48dd90 leaq 0x5a0(%rsp), %rdi callq 0x28088e movzwl %bx, %ebx movswl %ax, %esi leal (,%rbx,4), %eax cmpl %esi, %eax jne 0x48ddfd movq 0x30(%rsp), %rax imull 0x78(%rax), %esi leaq 0x5a0(%rsp), %rdi callq 0x27f688 leaq 0x178(%rsp), %rdi leaq 0x198(%rsp), %rdx movq %rbx, %rsi callq 0x267026 movq 0x178(%rsp), %r14 movq 0x180(%rsp), %r15 cmpq %r15, %r14 je 0x48cc4d leaq 0x5a0(%rsp), %rbx movq %rbx, %rdi callq 0x28094c movl %eax, %ecx shll $0x15, %ecx sarl $0x15, %ecx xorps %xmm0, %xmm0 cvtsi2ss %ecx, %xmm0 movss %xmm0, (%r14) movl %eax, %ecx shll $0xa, %ecx sarl $0x15, %ecx xorps %xmm0, %xmm0 cvtsi2ss %ecx, %xmm0 sarl $0x16, %eax xorps %xmm1, %xmm1 cvtsi2ss %eax, %xmm1 movss %xmm0, 0x4(%r14) movss %xmm1, 0x8(%r14) addq $0xc, %r14 cmpq %r15, %r14 jne 0x48cc03 xorps %xmm0, %xmm0 movaps %xmm0, 0xe0(%rsp) movq $0x0, 0xf0(%rsp) movl $0x478, %edi # imm = 0x478 callq 0x1a5230 movq %rax, %r13 movq %rax, %rdi callq 0x2402f8 movq %r13, 0x8(%rbp) movl $0xc, (%r13) movabsq $0x526c6165726e553c, %rax # imm = 0x526C6165726E553C movq %rax, 0x4(%r13) movl $0x3e746f6f, 0xc(%r13) # imm = 0x3E746F6F movb $0x0, 0x10(%r13) leaq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax movq %rax, (%rdi) leaq 0x11daa7(%rip), %rsi # 0x5aa761 leaq 0x11daa2(%rip), %rdx # 0x5aa763 callq 0x209290 movq 0x158(%rsp), %rsi movq 0x198(%rsp), %rdx movq 0x38(%rsp), %rdi movq (%rdi), %rax callq *0x20(%rax) movq %rax, %rbx movq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48cd09 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 testq %rbx, %rbx movq %rbx, 0x8(%rsp) movq %r13, 0x38(%rsp) je 0x48d3f5 xorps %xmm0, %xmm0 leaq 0x10(%rsp), %rsi movaps %xmm0, (%rsi) movq $0x0, 0x10(%rsi) movq %rbx, %rdi movl $0x1, %edx callq 0x248808 movq 0x10(%rsp), %r15 xorps %xmm0, %xmm0 movaps %xmm0, 0x50(%rsp) movq $0x0, 0x60(%rsp) cmpb $0x0, (%r15) je 0x48d3cd movq 0x38(%rsp), %rax leaq 0x42c(%rax), %rbx leaq 0x418(%rax), %rcx movq %rcx, 0x30(%rsp) addq $0x404, %rax # imm = 0x404 movq %rax, 0x80(%rsp) leaq 0x1415cd(%rip), %r14 # 0x5ce356 movabsq $0x100002600, %r13 # imm = 0x100002600 movq %rbx, 0x70(%rsp) movl $0x5, %edx movq %r14, %rdi movq %r15, %rsi callq 0x1a61b0 testl %eax, %eax je 0x48cdbc cmpb $0x0, 0x1(%r15) leaq 0x1(%r15), %r15 jne 0x48cd98 jmp 0x48d3cd movzbl 0x5(%r15), %eax cmpq $0x20, %rax ja 0x48cdac movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x48cdac addq $0xe, %r15 movq %r15, %r12 movzbl -0x8(%r12), %eax cmpq $0x20, %rax ja 0x48cdf5 btq %rax, %r13 jae 0x48cdf5 incq %r12 jmp 0x48cdde leaq -0x8(%r12), %r15 movl $0x7, %edx leaq 0x141574(%rip), %rdi # 0x5ce37a movq %r15, %rsi callq 0x1a61b0 testl %eax, %eax je 0x48ce6c movl $0x7, %edx leaq 0x141551(%rip), %rdi # 0x5ce36f movq %r15, %rsi callq 0x1a61b0 testl %eax, %eax jne 0x48cdac movzbl -0x1(%r12), %eax cmpq $0x20, %rax ja 0x48cdac movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x48cdac movzbl (%r12), %eax cmpq $0x20, %rax ja 0x48d0bf btq %rax, %r13 jae 0x48d0bf incq %r12 jmp 0x48ce4e movzbl -0x1(%r12), %eax cmpq $0x20, %rax ja 0x48ce12 movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x48ce12 movzbl (%r12), %eax cmpq $0x20, %rax ja 0x48ce9e btq %rax, %r13 jae 0x48ce9e incq %r12 jmp 0x48ce88 movl $0x6, %edx leaq 0x1414b2(%rip), %rdi # 0x5ce35c movq %r12, %rsi callq 0x1a61b0 testl %eax, %eax jne 0x48d0f3 movzbl 0x6(%r12), %eax cmpq $0x20, %rax ja 0x48d0f3 movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x48d0f3 leaq 0x1a8(%rsp), %rbx movq %rbx, 0x198(%rsp) xorl %eax, %eax movq %rax, 0x1a0(%rsp) movb %al, 0x1a8(%rsp) leaq 0x1c8(%rsp), %r14 movq %r14, 0x1b8(%rsp) movq %rax, 0x1c0(%rsp) movb %al, 0x1c8(%rsp) leaq 0x50(%rsp), %rdi leaq 0x198(%rsp), %rsi callq 0x48e75e movq 0x1b8(%rsp), %rdi cmpq %r14, %rdi je 0x48cf4d movq 0x1c8(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x198(%rsp), %rdi cmpq %rbx, %rdi leaq 0x1413f7(%rip), %r14 # 0x5ce356 je 0x48cf71 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x7, %r12 movq 0x58(%rsp), %rbx leaq -0x40(%rbx), %rax movq %rax, 0x78(%rsp) leaq -0x20(%rbx), %rax movq %rax, 0x190(%rsp) movq %r12, %r15 movzbl (%r12), %eax cmpl $0xd, %eax ja 0x48cfaa movl $0x3401, %ecx # imm = 0x3401 btl %eax, %ecx jb 0x48d0fb movl $0x5, %edx movq %r15, %rdi leaq 0x1413aa(%rip), %rsi # 0x5ce363 callq 0x1a61b0 testl %eax, %eax je 0x48cfe2 movl $0x5, %edx movq %r15, %rdi leaq 0x141398(%rip), %rsi # 0x5ce369 callq 0x1a61b0 testl %eax, %eax je 0x48d036 movq %r15, %r12 jmp 0x48d0b7 addq $0x5, %r15 movq %r15, %r12 movzbl (%r12), %eax cmpq $0x20, %rax ja 0x48d004 movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jb 0x48d009 incq %r12 jmp 0x48cfe9 leaq 0x1a8(%rsp), %r14 movq %r14, 0x198(%rsp) leaq 0x198(%rsp), %rbp movq %rbp, %rdi movq %r15, %rsi movq %r12, %rdx callq 0x209290 movq 0x78(%rsp), %rdi jmp 0x48d08b addq $0x5, %r15 movq %r15, %r12 movzbl (%r12), %eax cmpq $0x20, %rax ja 0x48d058 movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jb 0x48d05d incq %r12 jmp 0x48d03d leaq 0x1a8(%rsp), %r14 movq %r14, 0x198(%rsp) leaq 0x198(%rsp), %rbp movq %rbp, %rdi movq %r15, %rsi movq %r12, %rdx callq 0x209290 movq 0x190(%rsp), %rdi movq %rbp, %rsi callq 0x1a58d0 movq 0x198(%rsp), %rdi cmpq %r14, %rdi je 0x48d0b0 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x14129f(%rip), %r14 # 0x5ce356 incq %r12 jmp 0x48cf8f movl $0xa, %edx leaq 0x1412ac(%rip), %rdi # 0x5ce377 movq %r12, %rsi callq 0x1a61b0 testl %eax, %eax je 0x48d130 movl $0x5, %edx leaq 0x1412ad(%rip), %rdi # 0x5ce390 movq %r12, %rsi callq 0x1a61b0 testl %eax, %eax je 0x48d337 movq %r12, %r15 jmp 0x48cdac cmpq $0x0, -0x38(%rbx) je 0x48d109 cmpq $0x0, -0x18(%rbx) jne 0x48d121 movq 0x58(%rsp), %rsi addq $-0x40, %rsi movq %rsi, 0x58(%rsp) leaq 0x50(%rsp), %rdi callq 0x48e914 movq 0x48(%rsp), %rbp movq 0x70(%rsp), %rbx jmp 0x48cdac movzbl 0xa(%r12), %eax cmpq $0x20, %rax ja 0x48d0d7 movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x48d0d7 movl $0x0, 0x198(%rsp) leaq 0x1b0(%rsp), %r14 movq %r14, 0x1a0(%rsp) movq $0x0, 0x1a8(%rsp) movb $0x0, 0x1b0(%rsp) leaq 0xe0(%rsp), %rdi leaq 0x198(%rsp), %rsi callq 0x48e94a movq 0x1a0(%rsp), %rdi cmpq %r14, %rdi je 0x48d1ad movq 0x1b0(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0xb, %r12 movq 0xe8(%rsp), %rax movq %rax, 0x78(%rsp) leaq -0x20(%rax), %rbp movq %r12, %r15 leaq 0x14118a(%rip), %r14 # 0x5ce356 movzbl (%r15), %eax cmpl $0xd, %eax ja 0x48d1e3 movl $0x3401, %ecx # imm = 0x3401 btl %eax, %ecx jb 0x48d32d movl $0x4, %edx movq %r15, %rdi leaq 0x141190(%rip), %rsi # 0x5ce382 callq 0x1a61b0 testl %eax, %eax je 0x48d239 movl $0x8, %edx movq %r15, %rdi leaq 0x14117d(%rip), %rsi # 0x5ce387 callq 0x1a61b0 testl %eax, %eax jne 0x48d26f addq $0x8, %r15 movq %r15, %r14 movzbl (%r14), %eax cmpq $0x20, %rax ja 0x48d234 movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jb 0x48d27d incq %r14 jmp 0x48d21a movb 0x4(%r15), %al addq $0x4, %r15 leal -0x3a(%rax), %edx xorl %ecx, %ecx cmpb $-0xa, %dl jb 0x48d267 xorl %ecx, %ecx leal (%rcx,%rcx,4), %ecx addb $-0x30, %al movzbl %al, %eax leal (%rax,%rcx,2), %ecx movb 0x1(%r15), %al incq %r15 leal -0x3a(%rax), %edx cmpb $-0xb, %dl ja 0x48d24d movq 0x78(%rsp), %rax movl %ecx, -0x28(%rax) movq %r15, %r14 incq %r14 movq %r14, %r15 jmp 0x48d1c5 leaq 0x1a8(%rsp), %rbx movq %rbx, 0x198(%rsp) leaq 0x198(%rsp), %r12 movq %r12, %rdi movq %r15, %rsi movq %r14, %rdx callq 0x209290 movq %rbp, %rdi movq %r12, %rsi callq 0x1a58d0 movq 0x198(%rsp), %rdi cmpq %rbx, %rdi je 0x48d2cb movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x50(%rsp), %rbx movq 0x58(%rsp), %r12 cmpq %r12, %rbx je 0x48d30a movq 0x78(%rsp), %rax movq -0x18(%rax), %r15 cmpq %r15, 0x8(%rbx) jne 0x48d301 testq %r15, %r15 je 0x48d314 movq (%rbp), %rsi movq (%rbx), %rdi movq %r15, %rdx callq 0x1a5c20 testl %eax, %eax je 0x48d314 addq $0x40, %rbx cmpq %r12, %rbx jne 0x48d2e3 movq 0x70(%rsp), %rbx jmp 0x48d272 addq $0x20, %rbx movq %rbp, %rdi movq %rbx, %rsi callq 0x1a64a0 movq 0x70(%rsp), %rbx jmp 0x48d272 movq 0x48(%rsp), %rbp jmp 0x48cdac movzbl 0x5(%r12), %eax cmpq $0x20, %rax ja 0x48d0f3 movabsq $0x100003601, %rcx # imm = 0x100003601 btq %rax, %rcx jae 0x48d0f3 addq $0x6, %r12 movq %r12, %r15 movzbl (%r15), %eax cmpl $0x58, %eax jle 0x48d381 cmpl $0x59, %eax je 0x48d394 cmpl $0x5a, %eax jne 0x48d3b4 cmpb $0x3d, 0x1(%r15) movq %rbx, %rsi je 0x48d3a0 jmp 0x48d3b4 jne 0x48d3b9 cmpb $0x3d, 0x1(%r15) movq 0x80(%rsp), %rsi je 0x48d3a0 jmp 0x48d3b4 cmpb $0x3d, 0x1(%r15) movq 0x30(%rsp), %rsi jne 0x48d3b4 addq $0x2, %r15 movq %r15, %rdi movl $0x1, %edx callq 0x2470c9 movq %rax, %r15 incq %r15 jmp 0x48d362 cmpl $0xd, %eax ja 0x48d3b4 movl $0x3401, %ecx # imm = 0x3401 btl %eax, %ecx jae 0x48d3b4 jmp 0x48cdac leaq 0x50(%rsp), %rdi callq 0x48e590 movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x48d3ee movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x38(%rsp), %r13 jmp 0x48d409 callq 0x241234 leaq 0x140f95(%rip), %rsi # 0x5ce396 movq %rax, %rdi callq 0x2411ba xorps %xmm0, %xmm0 leaq 0x10(%rsp), %rdi movaps %xmm0, (%rdi) movq $0x0, 0x10(%rdi) movq 0xe8(%rsp), %rax subq 0xe0(%rsp), %rax sarq $0x3, %rax movabsq $-0x6666666666666666, %rsi # imm = 0x999999999999999A imulq %rax, %rsi addq $0x5, %rsi callq 0x48e5c0 movq 0xc8(%rsp), %rbx movq 0xd0(%rsp), %r12 cmpq %r12, %rbx je 0x48d50e leaq 0x198(%rsp), %r14 leaq 0x10(%rsp), %r15 movsbl 0x6(%rbx), %eax movl %eax, 0x198(%rsp) movzbl 0xe(%rbx), %eax movl %eax, 0x19c(%rsp) movl $0x0, 0x1a0(%rsp) movq 0x10(%rsp), %rdi movq 0x18(%rsp), %rsi movq %r14, %rdx callq 0x48ec3d movq 0x18(%rsp), %rsi movq %rax, %rcx subq 0x10(%rsp), %rcx shrq $0x2, %rcx imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB movl %ecx, 0x10(%rbx) cmpq %rsi, %rax je 0x48d4c4 incl 0x8(%rax) jmp 0x48d501 movl $0x1, 0x1a0(%rsp) cmpq 0x20(%rsp), %rax je 0x48d4f3 movl 0x1a0(%rsp), %eax movl %eax, 0x8(%rsi) movq 0x198(%rsp), %rax movq %rax, (%rsi) addq $0xc, 0x18(%rsp) jmp 0x48d4fe movq %r15, %rdi movq %r14, %rdx callq 0x48ed2e incl 0x10(%rbp) addq $0x14, %rbx cmpq %r12, %rbx jne 0x48d46d movl 0x10(%rbp), %ebx testq %rbx, %rbx je 0x48de6a leaq (,%rbx,8), %r14 movq %r14, %rdi callq 0x1a57a0 movq %rax, 0x18(%rbp) movl %ebx, 0x20(%rbp) movq %r14, %rdi callq 0x1a57a0 movq %rax, 0x28(%rbp) movl %ebx, 0x460(%r13) shlq $0x2, %rbx movq %rbx, %rdi callq 0x1a57a0 movq %rax, 0x468(%r13) xorl %r12d, %r12d movl $0x520, %edi # imm = 0x520 callq 0x1a5230 movq %rax, %r15 movq $0x0, 0x4(%rax) leaq 0x10(%rax), %r13 leaq 0xf1(%rax), %rbx movl $0xcc, %edx movq %r13, %rdi xorl %esi, %esi callq 0x1a54e0 xorps %xmm0, %xmm0 movups %xmm0, 0xe0(%r15) movb $0x0, 0xf0(%r15) movl $0x3ff, %edx # imm = 0x3FF movq %rbx, %rdi movl $0x1b, %esi callq 0x1a54e0 xorl %eax, %eax movl %eax, 0x4f0(%r15) xorps %xmm0, %xmm0 movups %xmm0, 0x4f8(%r15) movups %xmm0, 0x508(%r15) movl %eax, 0x518(%r15) movq %r15, %rdi addq $0x30, %rdi movl $0xa0, %edx xorl %esi, %esi callq 0x1a54e0 movq 0x18(%rbp), %rax movq %r15, (%rax,%r12,8) movl $0x4, (%r15) movq 0x10(%rsp), %rax leaq (%r12,%r12,2), %rcx movq %rcx, 0x30(%rsp) movl 0x8(%rax,%rcx,4), %r14d movq %r14, %rbx shlq $0x4, %rbx leaq 0x8(%rbx), %rdi callq 0x1a57a0 movq %r14, (%rax) addq $0x8, %rax testq %r14, %r14 je 0x48d63f addq %rax, %rbx movq %rax, %rcx movl $0x0, (%rcx) movq $0x0, 0x8(%rcx) addq $0x10, %rcx cmpq %rbx, %rcx jne 0x48d628 movq %rax, 0xd0(%r15) leal (%r14,%r14,2), %eax shlq $0x2, %rax leaq (%rax,%rax,2), %rbx movq %rbx, %rdi callq 0x1a57a0 movq %rax, %rbp testl %r14d, %r14d je 0x48d68d leaq -0xc(%rbx), %rax movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB mulq %rcx shrq $0x3, %rdx leaq (%rdx,%rdx,2), %rax leaq 0xc(,%rax,4), %rdx movq %rbp, %rdi xorl %esi, %esi callq 0x1a54e0 movq %rbp, (%r13) movq %rbx, %rdi callq 0x1a57a0 movq %rax, %r13 testl %r14d, %r14d je 0x48d6cf addq $-0xc, %rbx movq %rbx, %rax movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB mulq %rcx shrq $0x3, %rdx leaq (%rdx,%rdx,2), %rax leaq 0xc(,%rax,4), %rdx movq %r13, %rdi xorl %esi, %esi callq 0x1a54e0 movq %r13, 0x70(%r15) movq 0x38(%rsp), %rax movq 0x468(%rax), %rax movl %r12d, (%rax,%r12,4) movl $0x10, %edi callq 0x1a5230 movq %rax, %r15 movq %rax, %rdi callq 0x2466d0 movq 0x48(%rsp), %rbp leaq 0x19c(%rsp), %r13 movq 0x28(%rbp), %rax movq %r15, (%rax,%r12,8) movsd 0xcdbbb(%rip), %xmm0 # 0x55b2d0 movsd %xmm0, 0x50(%rsp) movl $0x3f800000, 0x58(%rsp) # imm = 0x3F800000 movl $0x0, 0x198(%rsp) movb $0x0, 0x19c(%rsp) movl $0x3ff, %edx # imm = 0x3FF leaq 0x19d(%rsp), %rdi movl $0x1b, %esi callq 0x1a54e0 movq 0x10(%rsp), %rax leaq (,%r12,4), %rcx leaq (%rcx,%rcx,2), %r14 movl 0x4(%rax,%r14), %r8d movl $0x400, %esi # imm = 0x400 movq %r13, %rdi leaq 0x140c63(%rip), %rdx # 0x5ce3d5 movl %r12d, %ecx xorl %eax, %eax callq 0x1a5890 movq 0x10(%rsp), %rbx cmpl $0x1, (%rbx,%r14) jne 0x48d7d5 movl $0x1, 0x44(%rsp) movl $0x4, (%rsp) movq %r15, %rdi leaq 0x44(%rsp), %rsi movl $0x4, %edx leaq 0x10b767(%rip), %rcx # 0x598f12 xorl %r8d, %r8d xorl %r9d, %r9d callq 0x2468bc movq 0x30(%rsp), %r14 movq %r13, %rdi callq 0x1a56a0 movl $0x5f7374, 0x19c(%rsp,%rax) # imm = 0x5F7374 movq 0x10(%rsp), %rbx jmp 0x48d7ed movq %r13, %rdi callq 0x1a56a0 movl $0x5f736f, 0x19c(%rsp,%rax) # imm = 0x5F736F movq 0x30(%rsp), %r14 cmpl $0x2, (%rbx,%r14,4) jne 0x48d842 movl $0x3f666666, 0x44(%rsp) # imm = 0x3F666666 movl $0x1, (%rsp) movq %r15, %rdi leaq 0x44(%rsp), %rsi movl $0x4, %edx leaq 0x103771(%rip), %rcx # 0x590f88 xorl %r8d, %r8d xorl %r9d, %r9d callq 0x2468bc movq %r13, %rdi callq 0x1a56a0 movl $0x6e617274, (%r13,%rax) # imm = 0x6E617274 movw $0x5f, 0x4(%r13,%rax) movq 0x10(%rsp), %rbx jmp 0x48d85b movq %r13, %rdi callq 0x1a56a0 movl $0x7161706f, (%r13,%rax) # imm = 0x7161706F movw $0x5f, 0x4(%r13,%rax) cmpl $0x8, (%rbx,%r14,4) jne 0x48d894 movabsq $0x546e6f7061655724, %rax # imm = 0x546E6F7061655724 movq %rax, (%r13) movl $0x246761, 0x8(%r13) # imm = 0x246761 movl $0xb, 0x198(%rsp) movq $0x0, 0x50(%rsp) movl $0x0, 0x58(%rsp) movl $0x1, (%rsp) movq %r15, %rdi leaq 0x50(%rsp), %rsi movl $0xc, %edx leaq 0x10206d(%rip), %rcx # 0x58f91c xorl %r8d, %r8d xorl %r9d, %r9d callq 0x2468bc movq %r13, %rdi callq 0x1a56a0 movl %eax, 0x198(%rsp) movq %r15, %rdi leaq 0x198(%rsp), %rsi leaq 0x10205e(%rip), %rdx # 0x58f939 xorl %ecx, %ecx xorl %r8d, %r8d callq 0x246b54 movq 0xe0(%rsp), %rax movq 0xe8(%rsp), %rcx cmpq %rcx, %rax je 0x48d95d movq 0x10(%rsp), %rdx movl 0x4(%rdx,%r14,4), %edx cmpl %edx, (%rax) je 0x48d913 addq $0x28, %rax cmpq %rcx, %rax jne 0x48d904 jmp 0x48d95d movq 0x10(%rax), %rbx cmpq $0x3ff, %rbx # imm = 0x3FF ja 0x48d93e movl %ebx, 0x198(%rsp) movq 0x8(%rax), %rsi movq %r13, %rdi movq %rbx, %rdx callq 0x1a5110 movb $0x0, 0x19c(%rsp,%rbx) movq %r15, %rdi leaq 0x198(%rsp), %rsi leaq 0x1031a4(%rip), %rdx # 0x590af4 movl $0x1, %ecx xorl %r8d, %r8d callq 0x246b54 incq %r12 movl 0x10(%rbp), %eax cmpq %rax, %r12 jb 0x48d55a movq 0xc8(%rsp), %rbx movq 0xd0(%rsp), %r15 cmpq %r15, %rbx je 0x48dacb leaq 0x198(%rsp), %r14 movsbl 0x6(%rbx), %eax movl %eax, 0x198(%rsp) movzbl 0xe(%rbx), %eax movl %eax, 0x19c(%rsp) movl $0x0, 0x1a0(%rsp) movq 0x10(%rsp), %rdi movq 0x18(%rsp), %rsi movq %r14, %rdx callq 0x48ec3d movq 0x18(%rbp), %rcx subq 0x10(%rsp), %rax shrq $0x2, %rax movabsq $0x5555555555555558, %rdx # imm = 0x5555555555555558 imulq %rdx, %rax movq (%rcx,%rax), %r13 movq 0xd0(%r13), %rbp movl 0x8(%r13), %r12d leal 0x1(%r12), %eax movl %eax, 0x8(%r13) shlq $0x4, %r12 movl $0x3, (%rbp,%r12) movl $0xc, %edi callq 0x1a57a0 addq %r12, %rbp movq %rax, 0x8(%rbp) movl 0x4(%r13), %ecx xorl %eax, %eax movss 0xcdb99(%rip), %xmm3 # 0x55b5b8 movss 0xcdb89(%rip), %xmm4 # 0x55b5b0 movq 0x8(%rbp), %rdx movl %ecx, (%rdx,%rax,4) movzwl (%rbx,%rax,2), %ecx movq 0x178(%rsp), %rdx leaq (%rcx,%rcx,2), %rcx movq 0x10(%r13), %rsi movl 0x4(%r13), %edi leaq (%rdi,%rdi,2), %rdi movl 0x8(%rdx,%rcx,4), %r8d movl %r8d, 0x8(%rsi,%rdi,4) movq (%rdx,%rcx,4), %rcx movq %rcx, (%rsi,%rdi,4) movzbl 0x8(%rbx,%rax,2), %ecx xorps %xmm0, %xmm0 cvtsi2ss %ecx, %xmm0 movzbl 0x9(%rbx,%rax,2), %ecx xorps %xmm1, %xmm1 cvtsi2ss %ecx, %xmm1 divss %xmm3, %xmm0 divss %xmm3, %xmm1 movaps %xmm4, %xmm2 subss %xmm1, %xmm2 movq 0x70(%r13), %rcx movl 0x4(%r13), %edx leaq (%rdx,%rdx,2), %rdx movss %xmm0, (%rcx,%rdx,4) movss %xmm2, 0x4(%rcx,%rdx,4) movl $0x0, 0x8(%rcx,%rdx,4) incq %rax movl 0x4(%r13), %ecx incl %ecx movl %ecx, 0x4(%r13) cmpq $0x3, %rax jne 0x48da27 addq $0x14, %rbx cmpq %r15, %rbx movq 0x48(%rsp), %rbp jne 0x48d98d leaq 0x198(%rsp), %rdi movq 0x8(%rsp), %rbx callq 0x2539d0 leaq 0x198(%rsp), %rdi movq %rbp, %rsi callq 0x253a0e leaq 0x50(%rsp), %rdi callq 0x25437e leaq 0x50(%rsp), %rdi movq %rbp, %rsi callq 0x2543bc leaq 0x50(%rsp), %rdi callq 0x254394 leaq 0x198(%rsp), %rdi callq 0x2539e6 movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x48db32 movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 testq %rbx, %rbx je 0x48db40 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) leaq 0xe0(%rsp), %rdi callq 0x48e682 movq 0x178(%rsp), %rdi testq %rdi, %rdi je 0x48db6a movq 0x188(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 leaq 0x5a0(%rsp), %rdi callq 0x27f664 movq 0xc8(%rsp), %rdi testq %rdi, %rdi je 0x48db94 movq 0xd8(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 leaq 0x90(%rsp), %rdi callq 0x27f664 movq 0x88(%rsp), %rdi movq (%rdi), %rax callq *0x8(%rax) movq 0x158(%rsp), %rdi leaq 0x168(%rsp), %rax cmpq %rax, %rdi je 0x48dbd4 movq 0x168(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x118(%rsp), %rdi leaq 0x128(%rsp), %rax cmpq %rax, %rdi je 0x48dbf9 movq 0x128(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x138(%rsp), %rdi leaq 0x148(%rsp), %rax cmpq %rax, %rdi je 0x48dc1e movq 0x148(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x108(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x48dc3f movq 0x108(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x5d8, %rsp # imm = 0x5D8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x198(%rsp), %rdi movq %r12, (%rdi) leaq 0x1405fd(%rip), %rsi # 0x5ce26d leaq 0x140614(%rip), %rdx # 0x5ce28b callq 0x209290 movb $0x1, %bpl leaq 0x198(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24faa2(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24fa6e(%rip), %rsi # 0x6dd710 movq 0x31e2b7(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x48df3d movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax movq %rax, (%rdi) leaq 0x1405af(%rip), %rsi # 0x5ce28c leaq 0x1405d4(%rip), %rdx # 0x5ce2b8 callq 0x209290 movb $0x1, %bpl leaq 0x198(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24fa35(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24fa01(%rip), %rsi # 0x6dd710 movq 0x31e24a(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x48df3d movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax movq %rax, (%rdi) leaq 0x140591(%rip), %rsi # 0x5ce2db leaq 0x1405a8(%rip), %rdx # 0x5ce2f9 callq 0x209290 movb $0x1, %bpl leaq 0x198(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24f9c8(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24f994(%rip), %rsi # 0x6dd710 movq 0x31e1dd(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x48df3d movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax movq %rax, (%rdi) leaq 0x140543(%rip), %rsi # 0x5ce2fa leaq 0x140566(%rip), %rdx # 0x5ce324 callq 0x209290 movb $0x1, %bpl leaq 0x198(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24f95b(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24f927(%rip), %rsi # 0x6dd710 movq 0x31e170(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x48df3d movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax movq %rax, (%rdi) leaq 0x140501(%rip), %rsi # 0x5ce325 leaq 0x14051d(%rip), %rdx # 0x5ce348 callq 0x209290 movb $0x1, %bpl leaq 0x198(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24f8ee(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24f8ba(%rip), %rsi # 0x6dd710 movq 0x31e103(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x48df3d movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax movq %rax, (%rdi) leaq 0x14051d(%rip), %rsi # 0x5ce3ae leaq 0x14053c(%rip), %rdx # 0x5ce3d4 callq 0x209290 movb $0x1, %bpl leaq 0x198(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24f881(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24f84d(%rip), %rsi # 0x6dd710 movq 0x31e096(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x48df3d movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x1a8(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x140308(%rip), %rsi # 0x5ce1fc leaq 0x140321(%rip), %rdx # 0x5ce21c leaq 0x198(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x198(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24f816(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24f7e2(%rip), %rsi # 0x6dd710 movq 0x31e02b(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x48e324 movq %rax, %rbx movq 0x198(%rsp), %rdi cmpq %r15, %rdi jne 0x48e0d7 jmp 0x48e0e7 jmp 0x48e0f1 movq %rax, %rbx movq 0x1a0(%rsp), %rdi cmpq %r14, %rdi je 0x48e327 movq 0x1b0(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x48e327 jmp 0x48e34f movq %rax, %rbx leaq 0x198(%rsp), %rdi callq 0x2f02de jmp 0x48e327 movq %rax, %rbx movq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48dfcb movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl movq 0x8(%rsp), %r15 jne 0x48dfe2 jmp 0x48e38c movq %rax, %rbx movq 0x8(%rsp), %r15 movq %r14, %rdi callq 0x1a6080 jmp 0x48e38c jmp 0x48dff3 jmp 0x48e025 movq %rax, %rbx movq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48e01b movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x48e028 jmp 0x48e3db movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 jmp 0x48e3db movq %rax, %rbx movq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48e05d movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x48e067 jmp 0x48e06f movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 movq $0x0, 0x8(%rsp) jmp 0x48e3fc movq %rax, %rbx movq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48e0a5 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x48e0b2 jmp 0x48e2be movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 jmp 0x48e2be movq %rax, %rbx movq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48e0e7 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x48e0f4 jmp 0x48e436 movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 jmp 0x48e436 jmp 0x48e324 movq %rax, %rbx jmp 0x48e331 jmp 0x48e34f jmp 0x48e185 jmp 0x48e324 movq %rax, %rbx leaq 0x50(%rsp), %rdi callq 0x254394 jmp 0x48e12e jmp 0x48e12b movq %rax, %rbx leaq 0x198(%rsp), %rdi callq 0x2539e6 jmp 0x48e387 jmp 0x48e384 movq %rax, %rbx movq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48e3b1 movq 0x1a8(%rsp), %rsi incq %rsi jmp 0x48e17b jmp 0x48e185 movq %rax, %rbx movl $0x478, %esi # imm = 0x478 movq %r13, %rdi callq 0x1a5190 jmp 0x48e3b1 movq %rax, %rbx jmp 0x48e3b1 jmp 0x48e282 jmp 0x48e282 movq %rax, %rbx jmp 0x48e3e8 movq %rax, %rbx movq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48e3fc movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x48e3fc jmp 0x48e3f9 jmp 0x48e2bb jmp 0x48e2bb movq %rax, %rbx jmp 0x48e2cb jmp 0x48e24f jmp 0x48e34f jmp 0x48e1f5 jmp 0x48e34f movq %rax, %rbx movq 0x90(%rsp), %rdi cmpq %r14, %rdi jne 0x48e227 jmp 0x48e2fe jmp 0x48e34f movq %rax, %rbx leaq 0xa0(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x48e2fe movq 0xa0(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x48e2fe jmp 0x48e34f jmp 0x48e24f jmp 0x48e34f jmp 0x48e24f jmp 0x48e34f movq %rax, %rbx movq 0x198(%rsp), %rdi cmpq %r12, %rdi je 0x48e436 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x48e436 jmp 0x48e34f jmp 0x48e324 movq %rax, %rbx jmp 0x48e3db movq %rax, %rbx movq 0x198(%rsp), %rdi leaq 0x1a8(%rsp), %rax cmpq %rax, %rdi je 0x48e3e8 movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x48e3e8 movq %rax, %rbx leaq 0x90(%rsp), %rdi callq 0x27f664 movq 0x8(%rsp), %rdi jmp 0x48e430 movq %rax, %rbx movq 0x198(%rsp), %rdi cmpq %r12, %rdi je 0x48e2cb movq 0x1a8(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x48e2cb jmp 0x48e2fb jmp 0x48e2fb movq %rax, %rbx movq 0x31dc8b(%rip), %rsi # 0x7abf90 leaq 0x198(%rsp), %rdi callq 0x1a5d00 leaq 0x208(%rsp), %rdi callq 0x1a5ca0 jmp 0x48e436 movq %rax, %rbx leaq 0x50(%rsp), %rdi callq 0x48e590 movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x48e348 movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x8(%rsp), %r15 jmp 0x48e3a3 movq %rax, %rbx jmp 0x48e436 jmp 0x48e384 jmp 0x48e384 jmp 0x48e384 jmp 0x48e384 jmp 0x48e384 jmp 0x48e384 movq %rax, %rbx jmp 0x48e3be jmp 0x48e384 jmp 0x48e384 jmp 0x48e384 movq %rax, %rbx movl $0x10, %esi movq %r15, %rdi callq 0x1a5190 jmp 0x48e387 jmp 0x48e384 jmp 0x48e3f9 movq %rax, %rbx movq 0x8(%rsp), %r15 movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x48e3a3 movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 testq %r15, %r15 je 0x48e3b1 movq (%r15), %rax movq %r15, %rdi callq *0x8(%rax) leaq 0xe0(%rsp), %rdi callq 0x48e682 movq 0x178(%rsp), %rdi testq %rdi, %rdi je 0x48e3db movq 0x188(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 leaq 0x5a0(%rsp), %rdi callq 0x27f664 movq 0x88(%rsp), %rax movq %rax, 0x8(%rsp) jmp 0x48e3fc jmp 0x48e3f9 movq %rax, %rbx movq 0xc8(%rsp), %rdi testq %rdi, %rdi je 0x48e419 movq 0xd8(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 leaq 0x90(%rsp), %rdi callq 0x27f664 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x48e436 movq (%rdi), %rax callq *0x8(%rax) movq 0x158(%rsp), %rdi leaq 0x168(%rsp), %rax cmpq %rax, %rdi je 0x48e45b movq 0x168(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x118(%rsp), %rdi leaq 0x128(%rsp), %rax cmpq %rax, %rdi je 0x48e480 movq 0x128(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x138(%rsp), %rdi leaq 0x148(%rsp), %rax cmpq %rax, %rdi je 0x48e4a5 movq 0x148(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x108(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x48e4c6 movq 0x108(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Unreal/UnrealLoader.cpp
Assimp::XFileImporter::CanRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*, bool) const
bool XFileImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const { std::string extension = GetExtension(pFile); if(extension == "x") { return true; } if (!extension.length() || checkSig) { uint32_t token[1]; token[0] = AI_MAKE_MAGIC("xof "); return CheckMagicToken(pIOHandler,pFile,token,1,0); } return false; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movl %ecx, %ebp movq %rdx, %r14 movq %rsi, %rbx leaq 0x8(%rsp), %r15 movq %r15, %rdi callq 0x24818a leaq 0xda85c(%rip), %rsi # 0x56978a movq %r15, %rdi callq 0x1a60c0 testl %eax, %eax je 0x48ef74 cmpq $0x0, 0x10(%rsp) setne %al xorb $0x1, %bpl testb %bpl, %al jne 0x48ef78 leaq 0x4(%rsp), %rdx movl $0x786f6620, (%rdx) # imm = 0x786F6620 movq %r14, %rdi movq %rbx, %rsi movl $0x1, %ecx xorl %r8d, %r8d movl $0x4, %r9d callq 0x24821c movl %eax, %ebx jmp 0x48ef7a movb $0x1, %bl jmp 0x48ef7a xorl %ebx, %ebx leaq 0x18(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x48ef95 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 movl %ebx, %eax addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq 0x18(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x48efc0 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X/XFileImporter.cpp
Assimp::XFileImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*)
void XFileImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) { // read file into memory std::unique_ptr<IOStream> file( pIOHandler->Open( pFile)); if ( file.get() == NULL ) { throw DeadlyImportError( "Failed to open file " + pFile + "." ); } static const size_t MinSize = 16; size_t fileSize = file->FileSize(); if ( fileSize < MinSize ) { throw DeadlyImportError( "XFile is too small." ); } // in the hope that binary files will never start with a BOM ... mBuffer.resize( fileSize + 1); file->Read( &mBuffer.front(), 1, fileSize); ConvertToUTF8(mBuffer); // parse the file into a temporary representation XFileParser parser( mBuffer); // and create the proper return structures out of it CreateDataRepresentationFromImport( pScene, parser.GetImportedData()); // if nothing came from it, report it as error if ( !pScene->mRootNode ) { throw DeadlyImportError( "XFile is ill-formatted - no content imported." ); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rcx, %rbx movq %rdx, %r14 movq %rsi, %r12 movq %rdi, %r15 leaq 0x10(%rsp), %rbp movq %rbp, -0x10(%rbp) leaq 0x11b767(%rip), %rsi # 0x5aa761 leaq 0x11b762(%rip), %rdx # 0x5aa763 movq %rsp, %rdi callq 0x209290 movq (%r12), %rsi movq (%rsp), %rdx movq (%rbx), %rax movq %rbx, %rdi callq *0x20(%rax) movq %rax, %rbx movq (%rsp), %rdi cmpq %rbp, %rdi je 0x48f033 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 testq %rbx, %rbx je 0x48f0c5 movq (%rbx), %rax movq %rbx, %rdi callq *0x30(%rax) movq %rax, %r13 cmpq $0xf, %rax jbe 0x48f11a leaq 0x78(%r15), %r12 leaq 0x1(%r13), %rsi movq %r12, %rdi callq 0x249292 movq (%r12), %rsi movq (%rbx), %rax movl $0x1, %edx movq %rbx, %rdi movq %r13, %rcx callq *0x10(%rax) movq %r12, %rdi callq 0x2483d4 movq %rsp, %rdi movq %r12, %rsi callq 0x491e2c movq 0x30(%rsp), %rdx movq %r15, %rdi movq %r14, %rsi callq 0x48f33a cmpq $0x0, 0x8(%r14) je 0x48f176 movq %rsp, %rdi callq 0x492c64 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) addq $0x58, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x10bddb(%rip), %rsi # 0x59aeb4 leaq 0x38(%rsp), %rdi movq %r12, %rdx callq 0x23ca59 leaq 0x10be31(%rip), %rsi # 0x59af1e leaq 0x38(%rsp), %rdi callq 0x1a5ba0 movq %rbp, (%rsp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x48f1d9 movups (%rcx), %xmm0 movups %xmm0, (%rbp) jmp 0x48f1e5 movl $0x10, %edi callq 0x1a5680 movq %rax, %r15 movq %rsp, %rdi movq %rbp, (%rdi) leaq 0x13f38c(%rip), %rsi # 0x5ce4c0 leaq 0x13f398(%rip), %rdx # 0x5ce4d3 callq 0x209290 movb $0x1, %r12b movq %rsp, %rsi movq %r15, %rdi callq 0x1a53e0 leaq 0x24e5e3(%rip), %rax # 0x6dd738 movq %rax, (%r15) xorl %r12d, %r12d leaq 0x24e5ae(%rip), %rsi # 0x6dd710 movq 0x31cdf7(%rip), %rdx # 0x7abf60 movq %r15, %rdi callq 0x1a5b00 jmp 0x48f22d movl $0x10, %edi callq 0x1a5680 movq %rax, %r15 leaq 0x48(%rsp), %r12 movq %r12, -0x10(%r12) leaq 0x13f340(%rip), %rsi # 0x5ce4d4 leaq 0x13f366(%rip), %rdx # 0x5ce501 leaq 0x38(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x38(%rsp), %rsi movq %r15, %rdi callq 0x1a53e0 leaq 0x24e57c(%rip), %rax # 0x6dd738 movq %rax, (%r15) xorl %ebp, %ebp leaq 0x24e548(%rip), %rsi # 0x6dd710 movq 0x31cd91(%rip), %rdx # 0x7abf60 movq %r15, %rdi callq 0x1a5b00 jmp 0x48f22d movq %rdx, (%rsp) movq (%rcx), %rdx movq %rdx, 0x10(%rsp) movq 0x8(%rax), %rdx movq %rsp, %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movb $0x1, %r15b movq %rbx, %rdi callq 0x1a53e0 leaq 0x24e527(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %r15d, %r15d leaq 0x24e4f2(%rip), %rsi # 0x6dd710 movq 0x31cd3b(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq (%rsp), %rdi cmpq %rbp, %rdi je 0x48f246 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x48(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x48f261 movq 0x48(%rsp), %rsi incq %rsi callq 0x1a5190 testb %r15b, %r15b jne 0x48f2ed jmp 0x48f332 movq %rax, %r14 leaq 0x48(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x48f2ed movq 0x48(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x48f2ed movq %rax, %r14 movq 0x38(%rsp), %rdi cmpq %r12, %rdi je 0x48f2a9 movq 0x48(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x48f2b3 jmp 0x48f2fa movq %rax, %r14 movq %r15, %rdi callq 0x1a6080 jmp 0x48f2fa movq %rax, %r14 movq (%rsp), %rdi cmpq %rbp, %rdi je 0x48f2d6 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 testb %r12b, %r12b jne 0x48f2e0 jmp 0x48f329 movq %rax, %r14 movq %r15, %rdi callq 0x1a6080 jmp 0x48f329 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 jmp 0x48f332 movq %rax, %r14 movq %rsp, %rdi callq 0x492c64 jmp 0x48f329 jmp 0x48f326 movq %rax, %r14 movq (%rsp), %rdi cmpq %rbp, %rdi je 0x48f332 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x48f332 movq %rax, %r14 jmp 0x48f332 movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X/XFileImporter.cpp
Assimp::XFileParser::XFileParser(std::vector<char, std::allocator<char>> const&)
XFileParser::XFileParser( const std::vector<char>& pBuffer) : mMajorVersion( 0 ) , mMinorVersion( 0 ) , mIsBinaryFormat( false ) , mBinaryNumCount( 0 ) , mP( nullptr ) , mEnd( nullptr ) , mLineNumber( 0 ) , mScene( nullptr ) { // vector to store uncompressed file for INFLATE'd X files std::vector<char> uncompressed; // set up memory pointers mP = &pBuffer.front(); mEnd = mP + pBuffer.size() - 1; // check header if ( 0 != strncmp( mP, "xof ", 4 ) ) { throw DeadlyImportError( "Header mismatch, file is not an XFile." ); } // read version. It comes in a four byte format such as "0302" mMajorVersion = (unsigned int)(mP[4] - 48) * 10 + (unsigned int)(mP[5] - 48); mMinorVersion = (unsigned int)(mP[6] - 48) * 10 + (unsigned int)(mP[7] - 48); bool compressed = false; // txt - pure ASCII text format if( strncmp( mP + 8, "txt ", 4) == 0) mIsBinaryFormat = false; // bin - Binary format else if( strncmp( mP + 8, "bin ", 4) == 0) mIsBinaryFormat = true; // tzip - Inflate compressed text format else if( strncmp( mP + 8, "tzip", 4) == 0) { mIsBinaryFormat = false; compressed = true; } // bzip - Inflate compressed binary format else if( strncmp( mP + 8, "bzip", 4) == 0) { mIsBinaryFormat = true; compressed = true; } else ThrowException( format() << "Unsupported xfile format '" << mP[8] << mP[9] << mP[10] << mP[11] << "'"); // float size mBinaryFloatSize = (unsigned int)(mP[12] - 48) * 1000 + (unsigned int)(mP[13] - 48) * 100 + (unsigned int)(mP[14] - 48) * 10 + (unsigned int)(mP[15] - 48); if( mBinaryFloatSize != 32 && mBinaryFloatSize != 64) ThrowException( format() << "Unknown float size " << mBinaryFloatSize << " specified in xfile header." ); // The x format specifies size in bits, but we work in bytes mBinaryFloatSize /= 8; mP += 16; // If this is a compressed X file, apply the inflate algorithm to it if (compressed) { #ifdef ASSIMP_BUILD_NO_COMPRESSED_X throw DeadlyImportError("Assimp was built without compressed X support"); #else /* /////////////////////////////////////////////////////////////////////// * COMPRESSED X FILE FORMAT * /////////////////////////////////////////////////////////////////////// * [xhead] * 2 major * 2 minor * 4 type // bzip,tzip * [mszip_master_head] * 4 unkn // checksum? * 2 unkn // flags? (seems to be constant) * [mszip_head] * 2 ofs // offset to next section * 2 magic // 'CK' * ... ofs bytes of data * ... next mszip_head * * http://www.kdedevelopers.org/node/3181 has been very helpful. * /////////////////////////////////////////////////////////////////////// */ // build a zlib stream z_stream stream; stream.opaque = NULL; stream.zalloc = &dummy_alloc; stream.zfree = &dummy_free; stream.data_type = (mIsBinaryFormat ? Z_BINARY : Z_ASCII); // initialize the inflation algorithm ::inflateInit2(&stream, -MAX_WBITS); // skip unknown data (checksum, flags?) mP += 6; // First find out how much storage we'll need. Count sections. const char* P1 = mP; unsigned int est_out = 0; while (P1 + 3 < mEnd) { // read next offset uint16_t ofs = *((uint16_t*)P1); AI_SWAP2(ofs); P1 += 2; if (ofs >= MSZIP_BLOCK) throw DeadlyImportError("X: Invalid offset to next MSZIP compressed block"); // check magic word uint16_t magic = *((uint16_t*)P1); AI_SWAP2(magic); P1 += 2; if (magic != MSZIP_MAGIC) throw DeadlyImportError("X: Unsupported compressed format, expected MSZIP header"); // and advance to the next offset P1 += ofs; est_out += MSZIP_BLOCK; // one decompressed block is 32786 in size } // Allocate storage and terminating zero and do the actual uncompressing uncompressed.resize(est_out + 1); char* out = &uncompressed.front(); while (mP + 3 < mEnd) { uint16_t ofs = *((uint16_t*)mP); AI_SWAP2(ofs); mP += 4; if (mP + ofs > mEnd + 2) { throw DeadlyImportError("X: Unexpected EOF in compressed chunk"); } // push data to the stream stream.next_in = (Bytef*)mP; stream.avail_in = ofs; stream.next_out = (Bytef*)out; stream.avail_out = MSZIP_BLOCK; // and decompress the data .... int ret = ::inflate( &stream, Z_SYNC_FLUSH ); if (ret != Z_OK && ret != Z_STREAM_END) throw DeadlyImportError("X: Failed to decompress MSZIP-compressed data"); ::inflateReset( &stream ); ::inflateSetDictionary( &stream, (const Bytef*)out , MSZIP_BLOCK - stream.avail_out ); // and advance to the next offset out += MSZIP_BLOCK - stream.avail_out; mP += ofs; } // terminate zlib ::inflateEnd(&stream); // ok, update pointers to point to the uncompressed file data mP = &uncompressed[0]; mEnd = out; // FIXME: we don't need the compressed data anymore, could release // it already for better memory usage. Consider breaking const-co. ASSIMP_LOG_INFO("Successfully decompressed MSZIP-compressed file"); #endif // !! ASSIMP_BUILD_NO_COMPRESSED_X } else { // start reading here ReadUntilEndOfLine(); } mScene = new Scene; ParseFile(); // filter the imported hierarchy for some degenerated cases if( mScene->mRootNode) { FilterHierarchy( mScene->mRootNode); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1c8, %rsp # imm = 0x1C8 movq %rdi, %rbx xorl %eax, %eax movl %eax, 0x10(%rdi) movq %rax, 0x30(%rdi) movq %rax, (%rdi) movb $0x0, 0x8(%rdi) xorps %xmm0, %xmm0 movups %xmm0, 0x18(%rdi) movl %eax, 0x28(%rdi) movq %rax, 0x40(%rsp) movaps %xmm0, 0x30(%rsp) movq (%rsi), %r14 movq %r14, 0x18(%rdi) movq 0x8(%rsi), %rax decq %rax movq %rax, 0x20(%rdi) leaq 0x13c953(%rip), %rsi # 0x5ce7d0 movl $0x4, %edx movq %r14, %rdi callq 0x1a53a0 testl %eax, %eax jne 0x49240b leaq 0x18(%rbx), %r12 movsbl 0x4(%r14), %eax leal (%rax,%rax,4), %eax movsbl 0x5(%r14), %ecx leal (%rcx,%rax,2), %eax movl $0xfffffdf0, %ecx # imm = 0xFFFFFDF0 addl %ecx, %eax movl %eax, (%rbx) movsbl 0x6(%r14), %eax leal (%rax,%rax,4), %eax movsbl 0x7(%r14), %edx leal (%rdx,%rax,2), %eax addl %ecx, %eax movl %eax, 0x4(%rbx) leaq 0x8(%r14), %r15 leaq 0x13c92d(%rip), %rsi # 0x5ce7fc movl $0x4, %edx movq %r15, %rdi callq 0x1a53a0 xorl %ebp, %ebp testl %eax, %eax je 0x492006 leaq 0x13c914(%rip), %rsi # 0x5ce801 movl $0x4, %edx movq %r15, %rdi callq 0x1a53a0 testl %eax, %eax je 0x49200f leaq 0x13c8fd(%rip), %rsi # 0x5ce806 movl $0x4, %edx movq %r15, %rdi callq 0x1a53a0 xorl %ebp, %ebp testl %eax, %eax je 0x49226c leaq 0x13c8e4(%rip), %rsi # 0x5ce80b movl $0x4, %edx movq %r15, %rdi callq 0x1a53a0 movb $0x1, %dl movb $0x1, %cl testl %eax, %eax je 0x492013 leaq 0x50(%rsp), %rdi callq 0x1a6170 leaq 0x13c8bf(%rip), %rsi # 0x5ce810 leaq 0x50(%rsp), %rdi movl $0x1a, %edx callq 0x1a61e0 movq (%r12), %rax movb 0x8(%rax), %al leaq 0xf(%rsp), %rsi movb %al, (%rsi) leaq 0x50(%rsp), %rdi movl $0x1, %edx callq 0x1a61e0 movq (%r12), %rax movb 0x9(%rax), %al leaq 0xf(%rsp), %rsi movb %al, (%rsi) leaq 0x50(%rsp), %rdi movl $0x1, %edx callq 0x1a61e0 movq (%r12), %rax movb 0xa(%rax), %al leaq 0xf(%rsp), %rsi movb %al, (%rsi) leaq 0x50(%rsp), %rdi movl $0x1, %edx callq 0x1a61e0 movq (%r12), %rax movb 0xb(%rax), %al leaq 0xf(%rsp), %rsi movb %al, (%rsi) leaq 0x50(%rsp), %rdi movl $0x1, %edx callq 0x1a61e0 leaq 0x113801(%rip), %rsi # 0x5a57dc leaq 0x50(%rsp), %rdi movl $0x1, %edx callq 0x1a61e0 leaq 0x58(%rsp), %rsi leaq 0x10(%rsp), %rdi callq 0x1a5690 leaq 0x10(%rsp), %rsi movq %rbx, %rdi callq 0x492590 xorl %edx, %edx movl $0x1, %ebp jmp 0x492011 movb $0x1, %dl xorl %ecx, %ecx movb %dl, 0x8(%rbx) movsbl 0xc(%r14), %eax imull $0x3e8, %eax, %eax # imm = 0x3E8 movsbl 0xd(%r14), %edx imull $0x64, %edx, %edx addl %eax, %edx movsbl 0xe(%r14), %eax leal (%rax,%rax,4), %eax leal (%rdx,%rax,2), %edx movsbl 0xf(%r14), %esi leal (%rsi,%rdx), %eax addl $0xffff2fb0, %eax # imm = 0xFFFF2FB0 addl %esi, %edx movl %eax, 0xc(%rbx) cmpl $0xd070, %edx # imm = 0xD070 je 0x49205c cmpl $0xd090, %edx # imm = 0xD090 jne 0x49246b shrl $0x3, %eax movl %eax, 0xc(%rbx) addq $0x10, %r14 movq %r14, 0x18(%rbx) testb %cl, %cl je 0x4921f4 leaq 0x50(%rsp), %rdi movq $0x0, 0x50(%rdi) leaq 0x647(%rip), %rax # 0x4926cd movq %rax, 0x40(%rdi) leaq 0x646(%rip), %rax # 0x4926d7 movq %rax, 0x48(%rdi) movl %ebp, 0x58(%rdi) leaq 0x1173c9(%rip), %rdx # 0x5a9468 movl $0xfffffff1, %esi # imm = 0xFFFFFFF1 movl $0x70, %ecx callq 0x1a53c0 movq 0x18(%rbx), %rdx movq 0x20(%rbx), %rax leaq 0x6(%rdx), %rcx movq %rcx, 0x18(%rbx) addq $0x9, %rdx movl $0x1, %esi cmpq %rax, %rdx jae 0x492109 movl $0x1, %edx movzwl (%rcx), %esi cmpq $0x8012, %rsi # imm = 0x8012 jae 0x49227a cmpw $0x4b43, 0x2(%rcx) # imm = 0x4B43 jne 0x4922df leaq (%rcx,%rsi), %rdi addq $0x7, %rdi addq %rsi, %rcx addq $0x4, %rcx addl $0x8012, %edx # imm = 0x8012 cmpq %rax, %rdi jb 0x4920d1 movl %edx, %esi leaq 0x30(%rsp), %rdi callq 0x249292 movq 0x30(%rsp), %r14 movq 0x18(%rbx), %rcx movq 0x20(%rbx), %rax leaq 0x3(%rcx), %rdx cmpq %rax, %rdx jae 0x4921c7 leaq 0x50(%rsp), %r15 movzwl (%rcx), %r13d leaq 0x4(%rcx), %rdx movq %rdx, (%r12) addq %r13, %rcx addq $0x4, %rcx addq $0x2, %rax cmpq %rax, %rcx ja 0x492344 movq %rdx, 0x50(%rsp) movl %r13d, 0x58(%rsp) movq %r14, 0x68(%rsp) movl $0x8012, 0x70(%rsp) # imm = 0x8012 movq %r15, %rdi movl $0x2, %esi callq 0x1a5ac0 cmpl $0x2, %eax jae 0x4923a9 movq %r15, %rdi callq 0x1a61c0 movl $0x8012, %edx # imm = 0x8012 subl 0x70(%rsp), %edx movq %r15, %rdi movq %r14, %rsi callq 0x1a6360 movl $0x8012, %eax # imm = 0x8012 subl 0x70(%rsp), %eax addq %rax, %r14 movq 0x18(%rbx), %rdx movq 0x20(%rbx), %rax leaq (%rdx,%r13), %rcx movq %rcx, 0x18(%rbx) addq %r13, %rdx addq $0x3, %rdx cmpq %rax, %rdx jb 0x492132 leaq 0x50(%rsp), %rdi callq 0x1a6510 movq 0x30(%rsp), %rax movq %rax, 0x18(%rbx) movq %r14, 0x20(%rbx) callq 0x241234 leaq 0x13c72e(%rip), %rsi # 0x5ce918 movq %rax, %rdi callq 0x24114a jmp 0x4921fc movq %rbx, %rdi callq 0x4926e0 movl $0x58, %edi callq 0x1a5230 xorps %xmm0, %xmm0 movups %xmm0, 0x40(%rax) movups %xmm0, 0x30(%rax) movups %xmm0, 0x20(%rax) movups %xmm0, 0x10(%rax) movups %xmm0, (%rax) movl $0x0, 0x50(%rax) movq %rax, 0x30(%rbx) movq %rbx, %rdi callq 0x492718 movq 0x30(%rbx), %rax movq (%rax), %rsi testq %rsi, %rsi je 0x492243 movq %rbx, %rdi callq 0x492a14 movq 0x30(%rsp), %rdi testq %rdi, %rdi je 0x49225a movq 0x40(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 addq $0x1c8, %rsp # imm = 0x1C8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movb $0x1, %cl xorl %edx, %edx movl $0x1, %ebp jmp 0x492013 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x20(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x13c5c4(%rip), %rsi # 0x5ce85b leaq 0x13c5ed(%rip), %rdx # 0x5ce88b leaq 0x10(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24b479(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24b445(%rip), %rsi # 0x6dd710 movq 0x319c8e(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x49246b movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x20(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x13c590(%rip), %rsi # 0x5ce88c leaq 0x13c5c0(%rip), %rdx # 0x5ce8c3 leaq 0x10(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24b414(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24b3e0(%rip), %rsi # 0x6dd710 movq 0x319c29(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x49246b movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x20(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x13c563(%rip), %rsi # 0x5ce8c4 leaq 0x13c581(%rip), %rdx # 0x5ce8e9 leaq 0x10(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24b3af(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24b37b(%rip), %rsi # 0x6dd710 movq 0x319bc4(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x49246b movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x20(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x13c524(%rip), %rsi # 0x5ce8ea leaq 0x13c54a(%rip), %rdx # 0x5ce917 leaq 0x10(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x10(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24b34a(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24b316(%rip), %rsi # 0x6dd710 movq 0x319b5f(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x49246b movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x60(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x13c3ad(%rip), %rsi # 0x5ce7d5 leaq 0x13c3cc(%rip), %rdx # 0x5ce7fb leaq 0x50(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x50(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x24b2e8(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x24b2b4(%rip), %rsi # 0x6dd710 movq 0x319afd(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 leaq 0x50(%rsp), %rdi callq 0x1a6170 leaq 0x13c3af(%rip), %rsi # 0x5ce82b leaq 0x50(%rsp), %rdi movl $0x13, %edx callq 0x1a61e0 movl 0xc(%rbx), %esi leaq 0x50(%rsp), %rdi callq 0x1a5850 leaq 0x13c3a0(%rip), %rsi # 0x5ce83f leaq 0x50(%rsp), %rdi movl $0x1b, %edx callq 0x1a61e0 leaq 0x58(%rsp), %rsi leaq 0x10(%rsp), %rdi callq 0x1a5690 leaq 0x10(%rsp), %rsi movq %rbx, %rdi callq 0x492590 jmp 0x4924cc movq %rax, %rbx leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4924f3 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x4924f3 jmp 0x4924f0 jmp 0x49256d movq %rax, %rbx movq 0x319a96(%rip), %rsi # 0x7abf90 leaq 0x50(%rsp), %rdi callq 0x1a5d00 leaq 0xc0(%rsp), %rdi callq 0x1a5ca0 jmp 0x492570 jmp 0x49256d jmp 0x49256d jmp 0x49256d movq %rax, %rbx movq 0x50(%rsp), %rdi cmpq %r15, %rdi je 0x492559 movq 0x60(%rsp), %rsi jmp 0x492551 jmp 0x492560 jmp 0x49256d jmp 0x49256d jmp 0x49253f jmp 0x49253f jmp 0x492560 jmp 0x492560 jmp 0x49253f jmp 0x492560 movq %rax, %rbx movq 0x10(%rsp), %rdi cmpq %r15, %rdi je 0x492559 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x492563 jmp 0x492570 movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 jmp 0x492570 movq %rax, %rbx movq 0x30(%rsp), %rdi testq %rdi, %rdi je 0x492587 movq 0x40(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/X/XFileParser.cpp
Assimp::XFileParser::ParseUnknownDataObject()
void XFileParser::ParseUnknownDataObject() { // find opening delimiter bool running = true; while( running ) { std::string t = GetNextToken(); if( t.length() == 0) ThrowException( "Unexpected end of file while parsing unknown segment."); if( t == "{") break; } unsigned int counter = 1; // parse until closing delimiter while( counter > 0) { std::string t = GetNextToken(); if( t.length() == 0) ThrowException( "Unexpected end of file while parsing unknown segment."); if( t == "{") ++counter; else if( t == "}") --counter; } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx leaq 0x18(%rsp), %r13 leaq 0x8(%rsp), %r14 leaq 0x106b4c(%rip), %r15 # 0x59af40 movq %r14, %rdi movq %rbx, %rsi callq 0x492c84 cmpq $0x0, 0x10(%rsp) je 0x4944b8 movq %r14, %rdi movq %r15, %rsi callq 0x1a60c0 movl %eax, %ebp movq 0x8(%rsp), %rdi cmpq %r13, %rdi je 0x49442f movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testl %ebp, %ebp jne 0x4943f4 movl $0x1, %ebp leaq 0x8(%rsp), %r14 leaq 0x106afc(%rip), %r15 # 0x59af40 movq %r14, %rdi movq %rbx, %rsi callq 0x492c84 cmpq $0x0, 0x10(%rsp) je 0x4944e6 movq %r14, %rdi movq %r15, %rsi callq 0x1a60c0 testl %eax, %eax je 0x494487 movq %r14, %rdi leaq 0x146158(%rip), %rsi # 0x5da5cc callq 0x1a60c0 cmpl $0x1, %eax movl $0x0, %r12d sbbl %r12d, %r12d jmp 0x49448d movl $0x1, %r12d movq 0x8(%rsp), %rdi cmpq %r13, %rdi je 0x4944a4 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 addl %r12d, %ebp jne 0x494444 addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x38(%rsp), %r14 movq %r14, -0x10(%r14) leaq 0x13aa96(%rip), %rsi # 0x5cef5e leaq 0x13aac4(%rip), %rdx # 0x5cef93 leaq 0x28(%rsp), %rdi callq 0x209290 leaq 0x28(%rsp), %rsi movq %rbx, %rdi callq 0x492590 leaq 0x38(%rsp), %r14 movq %r14, -0x10(%r14) leaq 0x13aa68(%rip), %rsi # 0x5cef5e leaq 0x13aa96(%rip), %rdx # 0x5cef93 leaq 0x28(%rsp), %rdi callq 0x209290 leaq 0x28(%rsp), %rsi movq %rbx, %rdi callq 0x492590 jmp 0x494518 jmp 0x494534 movq %rax, %rbx movq 0x28(%rsp), %rdi cmpq %r14, %rdi je 0x494537 movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x494537 movq %rax, %rbx movq 0x8(%rsp), %rdi cmpq %r13, %rdi je 0x49454e movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X/XFileParser.cpp
Assimp::XFileParser::ParseDataObjectMeshTextureCoords(Assimp::XFile::Mesh*)
void XFileParser::ParseDataObjectMeshTextureCoords( Mesh* pMesh) { readHeadOfDataObject(); if( pMesh->mNumTextures + 1 > AI_MAX_NUMBER_OF_TEXTURECOORDS) ThrowException( "Too many sets of texture coordinates"); std::vector<aiVector2D>& coords = pMesh->mTexCoords[pMesh->mNumTextures++]; unsigned int numCoords = ReadInt(); if( numCoords != pMesh->mPositions.size()) ThrowException( "Texture coord count does not match vertex count"); coords.resize( numCoords); for( unsigned int a = 0; a < numCoords; a++) coords[a] = ReadVector2(); CheckForClosingBrace(); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rsi, %r15 movq %rdi, %rbx xorl %esi, %esi callq 0x494556 movl 0x80(%r15), %r12d leal 0x1(%r12), %eax cmpl $0x9, %eax jae 0x494e7a movl %eax, 0x80(%r15) movq %rbx, %rdi callq 0x494a28 movl %eax, %r14d movq 0x28(%r15), %rax subq 0x20(%r15), %rax sarq $0x2, %rax movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB imulq %rax, %rcx cmpq %r14, %rcx jne 0x494ea4 leaq (%r12,%r12,2), %rax leaq (%r15,%rax,8), %r15 addq $0x88, %r15 movq %r15, %rdi movq %r14, %rsi callq 0x34178c testq %r14, %r14 je 0x494e67 xorl %r12d, %r12d movq %rbx, %rdi callq 0x494796 movaps %xmm0, 0x20(%rsp) movq %rbx, %rdi callq 0x494796 movaps 0x20(%rsp), %xmm1 unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1] movaps %xmm1, 0x20(%rsp) movq %rbx, %rdi callq 0x494bd4 movq (%r15), %rax movaps 0x20(%rsp), %xmm0 movlps %xmm0, (%rax,%r12,8) incq %r12 cmpq %r12, %r14 jne 0x494e28 movq %rbx, %rdi addq $0x38, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0x494986 leaq 0x10(%rsp), %r14 movq %r14, -0x10(%r14) leaq 0x139ce8(%rip), %rsi # 0x5ceb72 leaq 0x139d05(%rip), %rdx # 0x5ceb96 movq %rsp, %rdi callq 0x209290 movq %rsp, %rsi movq %rbx, %rdi callq 0x492590 leaq 0x10(%rsp), %r14 movq %r14, -0x10(%r14) leaq 0x139ce3(%rip), %rsi # 0x5ceb97 leaq 0x139d0b(%rip), %rdx # 0x5cebc6 movq %rsp, %rdi callq 0x209290 movq %rsp, %rsi movq %rbx, %rdi callq 0x492590 jmp 0x494ed2 jmp 0x494eed movq %rax, %rbx movq (%rsp), %rdi cmpq %r14, %rdi je 0x494ef0 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x494ef0 movq %rax, %rbx movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X/XFileParser.cpp
Assimp::X3DImporter::FindNodeElement_FromRoot(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, CX3DImporter_NodeElement::EType, CX3DImporter_NodeElement**)
bool X3DImporter::FindNodeElement_FromRoot(const std::string& pID, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement) { for(std::list<CX3DImporter_NodeElement*>::iterator it = NodeElement_List.begin(); it != NodeElement_List.end(); ++it) { if(((*it)->Type == pType) && ((*it)->ID == pID)) { if(pElement != nullptr) *pElement = *it; return true; } }// for(std::list<CX3DImporter_NodeElement*>::iterator it = NodeElement_List.begin(); it != NodeElement_List.end(); it++) return false; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %r14 movq 0x78(%rdi), %r13 addq $0x78, %r14 cmpq %r14, %r13 je 0x4983e8 movl %edx, %ebp movq %rcx, (%rsp) movq (%rsi), %r15 movq 0x8(%rsi), %r12 movq 0x10(%r13), %rbx cmpl %ebp, 0x8(%rbx) jne 0x4983df cmpq %r12, 0x18(%rbx) jne 0x4983df testq %r12, %r12 je 0x4983f9 movq 0x10(%rbx), %rdi movq %r15, %rsi movq %r12, %rdx callq 0x1a5c20 testl %eax, %eax je 0x4983f9 movq (%r13), %r13 cmpq %r14, %r13 jne 0x4983b8 xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movb $0x1, %al movq (%rsp), %rcx testq %rcx, %rcx je 0x4983ea movq %rbx, (%rcx) jmp 0x4983ea nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp
Assimp::X3DImporter::Throw_CloseNotFound(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void X3DImporter::Throw_CloseNotFound(const std::string& pNode) { throw DeadlyImportError("Close tag for node <" + pNode + "> not found. Seems file is corrupt."); }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x48, %rsp movq %rsi, %r14 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0xfe5b0(%rip), %rsi # 0x596bc5 leaq 0x8(%rsp), %rdi movq %r14, %rdx callq 0x23ca59 leaq 0xfe5b1(%rip), %rsi # 0x596bda leaq 0x8(%rsp), %rdi callq 0x1a5ba0 leaq 0x38(%rsp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x498654 movups (%rcx), %xmm0 movups %xmm0, (%r15) jmp 0x498661 movq %rdx, 0x28(%rsp) movq (%rcx), %rdx movq %rdx, 0x38(%rsp) movq 0x8(%rax), %rdx leaq 0x28(%rsp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movb $0x1, %bpl movq %rbx, %rdi callq 0x1a53e0 leaq 0x2450a9(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x245075(%rip), %rsi # 0x6dd710 movq 0x3138be(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x28(%rsp), %rdi cmpq %r15, %rdi je 0x4986c4 movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x18(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4986df movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x498709 jmp 0x498711 movq %rax, %r14 leaq 0x18(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x498709 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x498709 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp
Assimp::X3DImporter::XML_SearchNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool X3DImporter::XML_SearchNode(const std::string& pNodeName) { while(mReader->read()) { if((mReader->getNodeType() == irr::io::EXN_ELEMENT) && XML_CheckNode_NameEqual(pNodeName)) return true; } return false; }
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq 0x98(%rdi), %rdi movq (%rdi), %rax callq *0x10(%rax) testb %al, %al je 0x499f04 movq 0x98(%r14), %rdi movq (%rdi), %rax callq *0x18(%rax) cmpl $0x1, %eax jne 0x499efb movq 0x98(%r14), %rdi movq (%rdi), %rax callq *0x68(%rax) movq %rbx, %rdi movq %rax, %rsi callq 0x1a60c0 testl %eax, %eax je 0x499f0e movq 0x98(%r14), %rdi jmp 0x499ec3 xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r14 retq movb $0x1, %al jmp 0x499f06
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp
Assimp::X3DImporter::XML_ReadNode_GetAttrVal_AsCol3f(int, aiColor3D&)
void X3DImporter::XML_ReadNode_GetAttrVal_AsCol3f(const int pAttrIdx, aiColor3D& pValue) { std::vector<float> tlist; std::vector<float>::iterator it; XML_ReadNode_GetAttrVal_AsArrF(pAttrIdx, tlist); if(tlist.size() != 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx)); it = tlist.begin(); pValue.r = *it++; pValue.g = *it++; pValue.b = *it; }
pushq %rbp pushq %r14 pushq %rbx subq $0x50, %rsp movq %rdx, %r14 movl %esi, %ebp movq %rdi, %rbx xorps %xmm0, %xmm0 leaq 0x10(%rsp), %rdx movaps %xmm0, (%rdx) movq $0x0, 0x10(%rdx) callq 0x49a78e movq 0x10(%rsp), %rdi movq 0x18(%rsp), %rax subq %rdi, %rax cmpq $0xc, %rax jne 0x49a71a movss (%rdi), %xmm0 movss %xmm0, (%r14) movss 0x4(%rdi), %xmm0 movss %xmm0, 0x4(%r14) movss 0x8(%rdi), %xmm0 movss %xmm0, 0x8(%r14) movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 addq $0x50, %rsp popq %rbx popq %r14 popq %rbp retq movq 0x98(%rbx), %rdi movq (%rdi), %rax movl %ebp, %esi callq *0x30(%rax) leaq 0x30(%rsp), %rdi leaq 0xf(%rsp), %rdx movq %rax, %rsi callq 0x23ca1c leaq 0x30(%rsp), %rsi movq %rbx, %rdi callq 0x49871a movq %rax, %rbx leaq 0x40(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49a76f movq 0x40(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49a76f jmp 0x49a76c jmp 0x49a76c movq %rax, %rbx movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x49a786 movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp
Assimp::X3DImporter::XML_ReadNode_GetAttrVal_AsArrF(int, std::vector<float, std::allocator<float>>&)
void X3DImporter::XML_ReadNode_GetAttrVal_AsArrF(const int pAttrIdx, std::vector<float>& pValue) { auto floatValue = std::dynamic_pointer_cast<const FIFloatValue>(mReader->getAttributeEncodedValue(pAttrIdx)); if (floatValue) { pValue = floatValue->value; } else { const char *val = mReader->getAttributeValue(pAttrIdx); pValue.clear(); //std::cregex_iterator wordItBegin(val, val + strlen(val), pattern_nws); //const std::cregex_iterator wordItEnd; //std::transform(wordItBegin, wordItEnd, std::back_inserter(pValue), [](const std::cmatch &match) { return std::stof(match.str()); }); WordIterator wordItBegin(val, val + strlen(val)); WordIterator wordItEnd; std::transform(wordItBegin, wordItEnd, std::back_inserter(pValue), [](const char *match) { return static_cast<float>(atof(match)); }); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rdx, %r14 movl %esi, %ebp movq %rdi, %r15 movq 0x98(%rdi), %rsi movq (%rsi), %rax leaq 0x8(%rsp), %rbx movq %rbx, %rdi movl %ebp, %edx callq *0x90(%rax) movq (%rbx), %rdi testq %rdi, %rdi je 0x49a803 leaq 0x304ed3(%rip), %rsi # 0x79f6a0 leaq 0x304ef4(%rip), %rdx # 0x79f6c8 xorl %ebx, %ebx xorl %ecx, %ecx callq 0x1a6190 movl $0x0, %r12d testq %rax, %rax je 0x49a815 movq 0x10(%rsp), %rbx testq %rbx, %rbx je 0x49a80a movq 0x3117af(%rip), %rcx # 0x7abfa8 cmpb $0x0, (%rcx) je 0x49a80e incl 0x8(%rbx) jmp 0x49a812 xorl %ebx, %ebx xorl %r12d, %r12d jmp 0x49a815 xorl %ebx, %ebx jmp 0x49a812 lock incl 0x8(%rbx) movq %rax, %r12 movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x49a824 callq 0x280464 testq %r12, %r12 je 0x49a83d addq $0x8, %r12 movq %r14, %rdi movq %r12, %rsi callq 0x4a0a5c jmp 0x49a8ce movq 0x98(%r15), %rdi movq (%rdi), %rax movl %ebp, %esi callq *0x30(%rax) movq %rax, %r15 movq (%r14), %rax cmpq %rax, 0x8(%r14) je 0x49a85c movq %rax, 0x8(%r14) movq %r15, %rdi callq 0x1a56a0 movq %rax, %r12 leaq (%r15,%rax), %r13 movq 0x3149b6(%rip), %rsi # 0x7af228 movq %r15, %rdi callq 0x1a59c0 addq %rax, %r15 xorl %ecx, %ecx cmpq %r12, %rax cmovlq %r15, %rcx movq %rcx, 0x18(%rsp) movq %r13, 0x20(%rsp) testq %rcx, %rcx je 0x49a8ce leaq 0x8(%rsp), %r12 leaq 0x18(%rsp), %r13 movq %r15, %rdi callq 0x1a5f00 cvtsd2ss %xmm0, %xmm0 movss %xmm0, 0x8(%rsp) movq %r14, %rdi movq %r12, %rsi callq 0x2a45e0 movq %r13, %rdi callq 0x4a10b6 movq 0x18(%rsp), %r15 testq %r15, %r15 jne 0x49a89f testq %rbx, %rbx je 0x49a8db movq %rbx, %rdi callq 0x280464 addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x49a8ee jmp 0x49a8ee movq %rax, %r14 testq %rbx, %rbx je 0x49a8fe movq %rbx, %rdi callq 0x280464 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp
Assimp::X3DImporter::XML_ReadNode_GetAttrVal_AsVec2f(int, aiVector2t<float>&)
void X3DImporter::XML_ReadNode_GetAttrVal_AsVec2f(const int pAttrIdx, aiVector2D& pValue) { std::vector<float> tlist; std::vector<float>::iterator it; XML_ReadNode_GetAttrVal_AsArrF(pAttrIdx, tlist); if(tlist.size() != 2) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx)); it = tlist.begin(); pValue.x = *it++; pValue.y = *it; }
pushq %rbp pushq %r14 pushq %rbx subq $0x50, %rsp movq %rdx, %r14 movl %esi, %ebp movq %rdi, %rbx xorps %xmm0, %xmm0 leaq 0x10(%rsp), %rdx movaps %xmm0, (%rdx) movq $0x0, 0x10(%rdx) callq 0x49a78e movq 0x10(%rsp), %rdi movq 0x18(%rsp), %rax subq %rdi, %rax cmpq $0x8, %rax jne 0x49a96b movss (%rdi), %xmm0 movss %xmm0, (%r14) movss 0x4(%rdi), %xmm0 movss %xmm0, 0x4(%r14) movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 addq $0x50, %rsp popq %rbx popq %r14 popq %rbp retq movq 0x98(%rbx), %rdi movq (%rdi), %rax movl %ebp, %esi callq *0x30(%rax) leaq 0x30(%rsp), %rdi leaq 0xf(%rsp), %rdx movq %rax, %rsi callq 0x23ca1c leaq 0x30(%rsp), %rsi movq %rbx, %rdi callq 0x49871a movq %rax, %rbx leaq 0x40(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49a9c0 movq 0x40(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49a9c0 jmp 0x49a9bd jmp 0x49a9bd movq %rax, %rbx movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x49a9d7 movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp
Assimp::X3DImporter::XML_ReadNode_GetAttrVal_AsArrCol3f(int, std::vector<aiColor3D, std::allocator<aiColor3D>>&)
void X3DImporter::XML_ReadNode_GetAttrVal_AsArrCol3f(const int pAttrIdx, std::vector<aiColor3D>& pValue) { std::list<aiColor3D> tlist; XML_ReadNode_GetAttrVal_AsListCol3f(pAttrIdx, tlist);// read as list // and copy to array if(!tlist.empty()) { pValue.reserve(tlist.size()); for(std::list<aiColor3D>::iterator it = tlist.begin(); it != tlist.end(); ++it) pValue.push_back(*it); } }
pushq %r15 pushq %r14 pushq %rbx subq $0x20, %rsp movq %rdx, %r14 leaq 0x8(%rsp), %rbx movq %rbx, 0x8(%rbx) movq %rbx, (%rbx) movq $0x0, 0x10(%rbx) movq %rbx, %rdx callq 0x49af26 movq 0x8(%rsp), %rdi cmpq %rbx, %rdi je 0x49b0cd movq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x4a0c24 movq %rbx, %r15 movq (%r15), %r15 cmpq %rbx, %r15 je 0x49b0c8 leaq 0x10(%r15), %rsi movq %r14, %rdi callq 0x4a0cbc jmp 0x49b0b2 movq 0x8(%rsp), %rdi leaq 0x8(%rsp), %rbx cmpq %rbx, %rdi je 0x49b0ec movq (%rdi), %r14 movl $0x20, %esi callq 0x1a5190 movq %r14, %rdi cmpq %rbx, %r14 jne 0x49b0d7 addq $0x20, %rsp popq %rbx popq %r14 popq %r15 retq jmp 0x49b0f8 movq %rax, %r14 movq 0x8(%rsp), %rdi cmpq %rbx, %rdi je 0x49b11a movq (%rdi), %r15 movl $0x20, %esi callq 0x1a5190 movq %r15, %rdi cmpq %rbx, %r15 jne 0x49b105 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp
Assimp::X3DImporter::XML_ReadNode_GetAttrVal_AsListS(int, std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void X3DImporter::XML_ReadNode_GetAttrVal_AsListS(const int pAttrIdx, std::list<std::string>& pValue) { // make copy of attribute value - strings list. const size_t tok_str_len = strlen(mReader->getAttributeValue(pAttrIdx)); if ( 0 == tok_str_len ) { Throw_IncorrectAttrValue( mReader->getAttributeName( pAttrIdx ) ); } // get pointer to begin of value. char *tok_str = const_cast<char*>(mReader->getAttributeValue(pAttrIdx)); char *tok_str_end = tok_str + tok_str_len; // string list has following format: attr_name='"s1" "s2" "sn"'. do { char* tbeg; char* tend; size_t tlen; std::string tstr; // find begin of string(element of string list): "sn". tbeg = strstr(tok_str, "\""); if(tbeg == nullptr) Throw_IncorrectAttrValue(mReader->getAttributeName(pAttrIdx)); tbeg++;// forward pointer from '\"' symbol to next after it. tok_str = tbeg; // find end of string(element of string list): "sn". tend = strstr(tok_str, "\""); if(tend == nullptr) Throw_IncorrectAttrValue(mReader->getAttributeName(pAttrIdx)); tok_str = tend + 1; // create storage for new string tlen = tend - tbeg; tstr.resize(tlen);// reserve enough space and copy data memcpy((void*)tstr.data(), tbeg, tlen);// not strcpy because end of copied string from tok_str has no terminator. // and store string in output list. pValue.push_back(tstr); } while(tok_str < tok_str_end); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rdx, %r14 movl %esi, %ebp movq %rdi, %r12 movq 0x98(%rdi), %rdi movq (%rdi), %rax callq *0x30(%rax) movq %rax, %rdi callq 0x1a56a0 testq %rax, %rax je 0x49b88a movq %rax, %r15 movq %r12, 0x10(%rsp) movq 0x98(%r12), %rdi movq (%rdi), %rax movl %ebp, 0xc(%rsp) movl %ebp, %esi callq *0x30(%rax) movq %rax, %rbp addq %rax, %r15 leaq 0x28(%rsp), %rbx leaq 0x18(%rsp), %r12 movq %rbx, 0x18(%rsp) movq $0x0, 0x20(%rsp) movb $0x0, 0x28(%rsp) movq %rbp, %rdi movl $0x22, %esi callq 0x1a5910 testq %rax, %rax je 0x49b81c movq %rax, %rbx incq %rbx movq %rbx, %rdi movl $0x22, %esi callq 0x1a5910 testq %rax, %rax je 0x49b853 movq %rax, %rbp movq %rax, %r13 subq %rbx, %r13 movq %r12, %rdi movq %r13, %rsi xorl %edx, %edx callq 0x1a5be0 movq 0x18(%rsp), %rdi movq %rbx, %rsi movq %r13, %rdx callq 0x1a5110 movq %r14, %rdi movq %r12, %rsi callq 0x4a136a movq %rax, %rdi movq %r14, %rsi callq 0x1a5360 incq 0x10(%r14) movq 0x18(%rsp), %rdi leaq 0x28(%rsp), %rbx cmpq %rbx, %rdi je 0x49b801 movq 0x28(%rsp), %rsi incq %rsi callq 0x1a5190 incq %rbp cmpq %r15, %rbp jb 0x49b760 addq $0x58, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq 0x10(%rsp), %rax movq 0x98(%rax), %rdi movq (%rdi), %rax movl 0xc(%rsp), %esi callq *0x28(%rax) leaq 0x38(%rsp), %rdi leaq 0xb(%rsp), %rdx movq %rax, %rsi callq 0x23ca1c leaq 0x38(%rsp), %rsi movq 0x10(%rsp), %rdi callq 0x498e54 movq 0x10(%rsp), %rax movq 0x98(%rax), %rdi movq (%rdi), %rax movl 0xc(%rsp), %esi callq *0x28(%rax) leaq 0x38(%rsp), %rdi leaq 0xb(%rsp), %rdx movq %rax, %rsi callq 0x23ca1c leaq 0x38(%rsp), %rsi movq 0x10(%rsp), %rdi callq 0x498e54 movq %r12, %rbx movq 0x98(%r12), %rdi movq (%rdi), %rax movl %ebp, %esi callq *0x28(%rax) leaq 0x18(%rsp), %rdi leaq 0x38(%rsp), %rdx movq %rax, %rsi callq 0x23ca1c leaq 0x18(%rsp), %rsi movq %rbx, %rdi callq 0x498e54 movq %rax, %rbx leaq 0x28(%rsp), %rax movq -0x10(%rax), %rdi jmp 0x49b906 movq %rax, %rbx jmp 0x49b918 jmp 0x49b8d1 movq %rax, %rbx leaq 0x48(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49b8fc movq 0x48(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49b8fc jmp 0x49b8f9 jmp 0x49b8f9 jmp 0x49b8f9 jmp 0x49b8f9 movq %rax, %rbx movq 0x18(%rsp), %rdi leaq 0x28(%rsp), %rax cmpq %rax, %rdi je 0x49b918 movq 0x28(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp
Assimp::X3DImporter::MeshGeometry_AddColor(aiMesh&, std::__cxx11::list<aiColor4t<float>, std::allocator<aiColor4t<float>>> const&, bool) const
void X3DImporter::MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const { std::list<aiColor4D>::const_iterator col_it = pColors.begin(); if(pColorPerVertex) { if(pColors.size() < pMesh.mNumVertices) { throw DeadlyImportError("MeshGeometry_AddColor1. Colors count(" + to_string(pColors.size()) + ") can not be less than Vertices count(" + to_string(pMesh.mNumVertices) + ")."); } // copy colors to mesh pMesh.mColors[0] = new aiColor4D[pMesh.mNumVertices]; for(size_t i = 0; i < pMesh.mNumVertices; i++) pMesh.mColors[0][i] = *col_it++; }// if(pColorPerVertex) else { if(pColors.size() < pMesh.mNumFaces) { throw DeadlyImportError("MeshGeometry_AddColor1. Colors count(" + to_string(pColors.size()) + ") can not be less than Faces count(" + to_string(pMesh.mNumFaces) + ")."); } // copy colors to mesh pMesh.mColors[0] = new aiColor4D[pMesh.mNumVertices]; for(size_t fi = 0; fi < pMesh.mNumFaces; fi++) { // apply color to all vertices of face for ( size_t vi = 0, vi_e = pMesh.mFaces[ fi ].mNumIndices; vi < vi_e; vi++ ) { pMesh.mColors[ 0 ][ pMesh.mFaces[ fi ].mIndices[ vi ] ] = *col_it; } ++col_it; } }// if(pColorPerVertex) else }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xc8, %rsp movq %rdx, %r15 movq %rsi, %r14 movq (%rdx), %r12 movq 0x10(%rdx), %rax testl %ecx, %ecx je 0x49c704 movl 0x4(%r14), %r13d cmpq %r13, %rax jb 0x49c7b4 movq %r13, %rbx shlq $0x4, %rbx movq %rbx, %rdi callq 0x1a57a0 movq %rax, %r15 testq %r13, %r13 je 0x49c79e xorl %r13d, %r13d movq %r15, %rdi xorl %esi, %esi movq %rbx, %rdx callq 0x1a54e0 movq %r15, 0x30(%r14) xorl %eax, %eax movups 0x10(%r12), %xmm0 movq (%r12), %r12 movq 0x30(%r14), %rcx movups %xmm0, (%rcx,%r13) incq %rax movl 0x4(%r14), %ecx addq $0x10, %r13 cmpq %rcx, %rax jb 0x49c6dc jmp 0x49c7a2 movl 0x8(%r14), %r13d cmpq %r13, %rax jb 0x49c81d movl 0x4(%r14), %ebp movq %rbp, %rbx shlq $0x4, %rbx movq %rbx, %rdi callq 0x1a57a0 movq %rax, %r15 testq %rbp, %rbp je 0x49c739 movq %r15, %rdi xorl %esi, %esi movq %rbx, %rdx callq 0x1a54e0 movq %r15, 0x30(%r14) testl %r13d, %r13d je 0x49c7a2 xorl %eax, %eax movq 0xd0(%r14), %rdx movq %rax, %rcx shlq $0x4, %rcx movl (%rdx,%rcx), %edx testq %rdx, %rdx je 0x49c78d leaq 0x10(%r12), %rsi xorl %edi, %edi movq 0x30(%r14), %r8 movq 0xd0(%r14), %r9 movq 0x8(%r9,%rcx), %r9 movl (%r9,%rdi,4), %r9d shlq $0x4, %r9 movups (%rsi), %xmm0 movups %xmm0, (%r8,%r9) incq %rdi cmpq %rdi, %rdx jne 0x49c761 movl 0x8(%r14), %r13d movq (%r12), %r12 incq %rax movl %r13d, %ecx cmpq %rcx, %rax jb 0x49c744 jmp 0x49c7a2 movq %r15, 0x30(%r14) addq $0xc8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx movq 0x10(%r15), %rsi leaq 0x28(%rsp), %rdi callq 0x4a0db2 leaq 0x133afb(%rip), %rsi # 0x5d02d1 leaq 0x88(%rsp), %rdi leaq 0x28(%rsp), %rdx callq 0x2beb54 leaq 0x133b08(%rip), %rsi # 0x5d02f7 leaq 0x88(%rsp), %rdi callq 0x1a5ba0 leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x49c88d movups (%rcx), %xmm0 movups %xmm0, (%r15) jmp 0x49c89a movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx movq 0x10(%r15), %rsi leaq 0x28(%rsp), %rdi callq 0x4a0db2 leaq 0x133a92(%rip), %rsi # 0x5d02d1 leaq 0x88(%rsp), %rdi leaq 0x28(%rsp), %rdx callq 0x2beb54 leaq 0x133ac6(%rip), %rsi # 0x5d031e leaq 0x88(%rsp), %rdi callq 0x1a5ba0 leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x49c915 movups (%rcx), %xmm0 movups %xmm0, (%r15) jmp 0x49c922 movq %rdx, 0x8(%rsp) movq (%rcx), %rdx movq %rdx, 0x18(%rsp) movq 0x8(%rax), %rdx movq %rdx, 0x10(%rsp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl 0x4(%r14), %esi leaq 0x68(%rsp), %rdi callq 0x4a0e3a leaq 0xa8(%rsp), %rdi leaq 0x8(%rsp), %rsi leaq 0x68(%rsp), %rdx callq 0x2be1b1 leaq 0xf480d(%rip), %rsi # 0x5910eb leaq 0xa8(%rsp), %rdi callq 0x1a5ba0 leaq 0x58(%rsp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x49c996 movups (%rcx), %xmm0 movups %xmm0, (%r12) jmp 0x49c9a3 movq %rdx, 0x8(%rsp) movq (%rcx), %rdx movq %rdx, 0x18(%rsp) movq 0x8(%rax), %rdx movq %rdx, 0x10(%rsp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl 0x8(%r14), %esi leaq 0x68(%rsp), %rdi callq 0x4a0e3a leaq 0xa8(%rsp), %rdi leaq 0x8(%rsp), %rsi leaq 0x68(%rsp), %rdx callq 0x2be1b1 leaq 0xf4785(%rip), %rsi # 0x5910eb leaq 0xa8(%rsp), %rdi callq 0x1a5ba0 leaq 0x58(%rsp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x49c9ee movups (%rcx), %xmm0 movups %xmm0, (%r12) jmp 0x49c9fb movq %rdx, 0x48(%rsp) movq (%rcx), %rdx movq %rdx, 0x58(%rsp) movq 0x8(%rax), %rdx leaq 0x48(%rsp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movb $0x1, %bpl movq %rbx, %rdi callq 0x1a53e0 leaq 0x240d67(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x240d33(%rip), %rsi # 0x6dd710 movq 0x30f57c(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 jmp 0x49ca44 movq %rdx, 0x48(%rsp) movq (%rcx), %rdx movq %rdx, 0x58(%rsp) movq 0x8(%rax), %rdx leaq 0x48(%rsp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movb $0x1, %bpl movq %rbx, %rdi callq 0x1a53e0 leaq 0x240d0f(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x240cdb(%rip), %rsi # 0x6dd710 movq 0x30f524(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 jmp 0x49ca46 movq %rax, %r14 movq 0x48(%rsp), %rdi cmpq %r12, %rdi je 0x49ca6a movq 0x58(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49ca6a jmp 0x49ca64 movq %rax, %r14 movb $0x1, %bpl leaq 0xb8(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49ca95 movq 0xb8(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49ca95 jmp 0x49ca8f movq %rax, %r14 movb $0x1, %bpl leaq 0x78(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49caba movq 0x78(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49caba jmp 0x49cab4 movq %rax, %r14 movb $0x1, %bpl movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x49cadb movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49cadb jmp 0x49cad5 movq %rax, %r14 movb $0x1, %bpl leaq 0x98(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49cafc movq 0x98(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x38(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49cb17 movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x49cb45 jmp 0x49cb4d jmp 0x49cb20 movq %rax, %r14 leaq 0x38(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49cb45 movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49cb45 jmp 0x49cb42 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp
Assimp::X3DImporter::ParseFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*)
void X3DImporter::ParseFile(const std::string& pFile, IOSystem* pIOHandler) { std::unique_ptr<FIReader> OldReader = std::move(mReader);// store current XMLreader. std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb")); // Check whether we can read from the file if ( file.get() == nullptr ) { throw DeadlyImportError( "Failed to open X3D file " + pFile + "." ); } mReader = FIReader::create(file.get()); if ( !mReader ) { throw DeadlyImportError( "Failed to create XML reader for file" + pFile + "." ); } mReader->registerVocabulary("urn:web3d:x3d:fi-vocabulary-3.2", &X3D_vocabulary_3_2); mReader->registerVocabulary("urn:web3d:x3d:fi-vocabulary-3.3", &X3D_vocabulary_3_3); // start reading ParseNode_Root(); // restore old XMLreader mReader = std::move(OldReader); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdx, %r14 movq %rsi, %r13 movq %rdi, %r15 movq 0x98(%rdi), %rbx movq $0x0, 0x98(%rdi) leaq 0x18(%rsp), %rbp movq %rbp, -0x10(%rbp) leaq 0x10b942(%rip), %rsi # 0x5aa761 leaq 0x10b93d(%rip), %rdx # 0x5aa763 leaq 0x8(%rsp), %rdi callq 0x209290 movq (%r13), %rsi movq 0x8(%rsp), %rdx movq (%r14), %rax movq %r14, %rdi callq *0x20(%rax) movq %rax, %r14 movq 0x8(%rsp), %rdi cmpq %rbp, %rdi je 0x49ee5c movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testq %r14, %r14 je 0x49ef8f leaq 0x8(%rsp), %rdi movq %r14, %rsi callq 0x4ae6fe movq 0x8(%rsp), %r12 movq $0x0, 0x8(%rsp) movq 0x98(%r15), %rdi movq %r12, 0x98(%r15) testq %rdi, %rdi je 0x49eeb0 movq (%rdi), %rax callq *0x8(%rax) movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x49eea9 movq (%rdi), %rax callq *0x8(%rax) movq 0x98(%r15), %r12 testq %r12, %r12 je 0x49efde leaq 0x8(%rsp), %rdi movq %rbp, (%rdi) leaq 0x131869(%rip), %rsi # 0x5d0731 leaq 0x131881(%rip), %rdx # 0x5d0750 callq 0x209290 movq (%r12), %rax leaq 0x3104e1(%rip), %rdx # 0x7af3c0 leaq 0x8(%rsp), %rsi movq %r12, %rdi callq *0xa8(%rax) movq 0x8(%rsp), %rdi cmpq %rbp, %rdi je 0x49ef04 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x98(%r15), %r12 leaq 0x8(%rsp), %rdi movq %rbp, (%rdi) leaq 0x131837(%rip), %rsi # 0x5d0751 leaq 0x13184f(%rip), %rdx # 0x5d0770 callq 0x209290 movq (%r12), %rax leaq 0x31058f(%rip), %rdx # 0x7af4c0 leaq 0x8(%rsp), %rsi movq %r12, %rdi callq *0xa8(%rax) movq 0x8(%rsp), %rdi cmpq %rbp, %rdi je 0x49ef56 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 movq %r15, %rdi callq 0x49f21e movq 0x98(%r15), %rdi movq %rbx, 0x98(%r15) testq %rdi, %rdi je 0x49ef77 movq (%rdi), %rax callq *0x8(%rax) movq (%r14), %rax movq %r14, %rdi callq *0x8(%rax) addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x131775(%rip), %rsi # 0x5d0718 leaq 0x28(%rsp), %rdi movq %r13, %rdx callq 0x23ca59 leaq 0xfbf67(%rip), %rsi # 0x59af1e leaq 0x28(%rsp), %rdi callq 0x1a5ba0 movq %rbp, 0x8(%rsp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x49f02d movups (%rcx), %xmm0 movups %xmm0, (%rbp) jmp 0x49f03a movl $0x10, %edi callq 0x1a5680 movq %rax, %r12 leaq 0xf7f6b(%rip), %rsi # 0x596f5d leaq 0x28(%rsp), %rdi movq %r13, %rdx callq 0x23ca59 leaq 0xfbf18(%rip), %rsi # 0x59af1e leaq 0x28(%rsp), %rdi callq 0x1a5ba0 movq %rbp, 0x8(%rsp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x49f086 movups (%rcx), %xmm0 movups %xmm0, (%rbp) jmp 0x49f093 movq %rdx, 0x8(%rsp) movq (%rcx), %rdx movq %rdx, 0x18(%rsp) movq 0x8(%rax), %rdx leaq 0x8(%rsp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movb $0x1, %r12b movq %r14, %rdi callq 0x1a53e0 leaq 0x23e6d0(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %r12d, %r12d leaq 0x23e69b(%rip), %rsi # 0x6dd710 movq 0x30cee4(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x49f0de movq %rdx, 0x8(%rsp) movq (%rcx), %rdx movq %rdx, 0x18(%rsp) movq 0x8(%rax), %rdx leaq 0x8(%rsp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movb $0x1, %r13b movq %r12, %rdi callq 0x1a53e0 leaq 0x23e677(%rip), %rax # 0x6dd738 movq %rax, (%r12) xorl %r13d, %r13d leaq 0x23e641(%rip), %rsi # 0x6dd710 movq 0x30ce8a(%rip), %rdx # 0x7abf60 movq %r12, %rdi callq 0x1a5b00 movq %rax, %r15 movq 0x8(%rsp), %rdi cmpq %rbp, %rdi je 0x49f0f8 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x38(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49f113 movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 testb %r13b, %r13b jne 0x49f1a0 jmp 0x49f1de movq %rax, %r15 leaq 0x38(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49f1a0 movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49f1a0 movq %rax, %r15 movq 0x8(%rsp), %rdi cmpq %rbp, %rdi je 0x49f15b movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x38(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49f176 movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 testb %r12b, %r12b jne 0x49f1ad jmp 0x49f1e7 movq %rax, %r15 leaq 0x38(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x49f1ad movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49f1ad movq %rax, %r15 movq %r12, %rdi callq 0x1a6080 jmp 0x49f1de movq %rax, %r15 movq %r14, %rdi callq 0x1a6080 jmp 0x49f1e7 jmp 0x49f1db jmp 0x49f1bd jmp 0x49f1db movq %rax, %r15 movq 0x8(%rsp), %rdi cmpq %rbp, %rdi je 0x49f1de movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49f1de jmp 0x49f1db movq %rax, %r15 movq (%r14), %rax movq %r14, %rdi callq *0x8(%rax) testq %rbx, %rbx je 0x49f1f5 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) movq %r15, %rdi callq 0x1a5b90 movq %rax, %r15 movq 0x8(%rsp), %rdi cmpq %rbp, %rdi je 0x49f1e7 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x49f1e7 movq %rax, %r15 jmp 0x49f1e7
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp
CX3DImporter_NodeElement::~CX3DImporter_NodeElement()
virtual ~CX3DImporter_NodeElement() { // empty }
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx leaq 0x2fe753(%rip), %rax # 0x79f620 movq %rax, (%rdi) leaq 0x38(%rdi), %r14 movq 0x38(%rdi), %rdi cmpq %r14, %rdi je 0x4a0ef2 movq (%rdi), %r15 movl $0x18, %esi callq 0x1a5190 movq %r15, %rdi cmpq %r14, %r15 jne 0x4a0edd movq 0x10(%rbx), %rdi addq $0x20, %rbx cmpq %rbx, %rdi je 0x4a0f0f movq (%rbx), %rsi incq %rsi popq %rbx popq %r14 popq %r15 jmp 0x1a5190 popq %rbx popq %r14 popq %r15 retq nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Node.hpp
Assimp::X3DImporter::ParseNode_Lighting_SpotLight()
void X3DImporter::ParseNode_Lighting_SpotLight() { std::string def, use; float ambientIntensity = 0; aiVector3D attenuation( 1, 0, 0 ); float beamWidth = 0.7854f; aiColor3D color( 1, 1, 1 ); float cutOffAngle = 1.570796f; aiVector3D direction( 0, 0, -1 ); bool global = true; float intensity = 1; aiVector3D location( 0, 0, 0 ); bool on = true; float radius = 100; CX3DImporter_NodeElement* ne( nullptr ); MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECK_RET("ambientIntensity", ambientIntensity, XML_ReadNode_GetAttrVal_AsFloat); MACRO_ATTRREAD_CHECK_REF("attenuation", attenuation, XML_ReadNode_GetAttrVal_AsVec3f); MACRO_ATTRREAD_CHECK_RET("beamWidth", beamWidth, XML_ReadNode_GetAttrVal_AsFloat); MACRO_ATTRREAD_CHECK_REF("color", color, XML_ReadNode_GetAttrVal_AsCol3f); MACRO_ATTRREAD_CHECK_RET("cutOffAngle", cutOffAngle, XML_ReadNode_GetAttrVal_AsFloat); MACRO_ATTRREAD_CHECK_REF("direction", direction, XML_ReadNode_GetAttrVal_AsVec3f); MACRO_ATTRREAD_CHECK_RET("global", global, XML_ReadNode_GetAttrVal_AsBool); MACRO_ATTRREAD_CHECK_RET("intensity", intensity, XML_ReadNode_GetAttrVal_AsFloat); MACRO_ATTRREAD_CHECK_REF("location", location, XML_ReadNode_GetAttrVal_AsVec3f); MACRO_ATTRREAD_CHECK_RET("on", on, XML_ReadNode_GetAttrVal_AsBool); MACRO_ATTRREAD_CHECK_RET("radius", radius, XML_ReadNode_GetAttrVal_AsFloat); MACRO_ATTRREAD_LOOPEND; // if "USE" defined then find already defined element. if(!use.empty()) { MACRO_USE_CHECKANDAPPLY(def, use, ENET_SpotLight, ne); } else { if(on) { // create and if needed - define new geometry object. ne = new CX3DImporter_NodeElement_Light(CX3DImporter_NodeElement::ENET_SpotLight, NodeElement_Cur); if(!def.empty()) ne->ID = def; if(beamWidth > cutOffAngle) beamWidth = cutOffAngle; ((CX3DImporter_NodeElement_Light*)ne)->AmbientIntensity = ambientIntensity; ((CX3DImporter_NodeElement_Light*)ne)->Attenuation = attenuation; ((CX3DImporter_NodeElement_Light*)ne)->BeamWidth = beamWidth; ((CX3DImporter_NodeElement_Light*)ne)->Color = color; ((CX3DImporter_NodeElement_Light*)ne)->CutOffAngle = cutOffAngle; ((CX3DImporter_NodeElement_Light*)ne)->Direction = direction; ((CX3DImporter_NodeElement_Light*)ne)->Global = global; ((CX3DImporter_NodeElement_Light*)ne)->Intensity = intensity; ((CX3DImporter_NodeElement_Light*)ne)->Location = location; ((CX3DImporter_NodeElement_Light*)ne)->Radius = radius; // Assimp want a node with name similar to a light. "Why? I don't no." ) ParseHelper_Group_Begin(false); // make random name if(ne->ID.empty()) ne->ID = "SpotLight_" + to_string((size_t)ne); NodeElement_Cur->ID = ne->ID;// assign name to node and return to light element. ParseHelper_Node_Exit(); // check for child nodes if(!mReader->isEmptyElement()) ParseNode_Metadata(ne, "SpotLight"); else NodeElement_Cur->Child.push_back(ne);// add made object as child to current element NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph }// if(on) }// if(!use.empty()) else }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x268, %rsp # imm = 0x268 movq %rdi, %rbx leaq 0xa0(%rsp), %r12 movq %r12, -0x10(%r12) xorl %eax, %eax movq %rax, -0x8(%r12) movb %al, (%r12) leaq 0x80(%rsp), %r13 movq %r13, -0x10(%r13) movq %rax, -0x8(%r13) movb %al, (%r13) movss 0xb6f1a(%rip), %xmm0 # 0x55b5b0 movlps %xmm0, 0x60(%rsp) movl %eax, 0x68(%rsp) movsd 0xb6c29(%rip), %xmm0 # 0x55b2d0 movsd %xmm0, 0x50(%rsp) movl $0x3f800000, 0x58(%rsp) # imm = 0x3F800000 movq %rax, 0x40(%rsp) movl $0xbf800000, 0x48(%rsp) # imm = 0xBF800000 movq %rax, 0x30(%rsp) movl %eax, 0x38(%rsp) movq %rax, 0x20(%rsp) movq 0x98(%rdi), %rdi movq (%rdi), %rax callq *0x20(%rax) movl %eax, %ebp testl %eax, %eax jle 0x4a4a5a movss 0x12c311(%rip), %xmm0 # 0x5d0a00 movss %xmm0, 0x18(%rsp) movss 0x12c2ff(%rip), %xmm0 # 0x5d09fc movss %xmm0, 0x14(%rsp) movb $0x1, 0xb(%rsp) movss 0xb6ea0(%rip), %xmm0 # 0x55b5b0 movss %xmm0, 0x10(%rsp) movss 0xb6f02(%rip), %xmm0 # 0x55b620 movss %xmm0, 0xc(%rsp) xorl %r12d, %r12d xorps %xmm0, %xmm0 movss %xmm0, 0x1c(%rsp) leaq 0xf0(%rsp), %r13 movb $0x1, 0xa(%rsp) movl %ebp, 0x2c(%rsp) movq 0x98(%rbx), %rdi movq (%rdi), %rax movl %r12d, %esi callq *0x28(%rax) movq %r13, %rdi movq %rax, %rsi leaq 0xd0(%rsp), %rdx callq 0x23ca1c movq %r13, %rdi leaq 0x12dd8f(%rip), %rsi # 0x5d24fd callq 0x1a60c0 testl %eax, %eax je 0x4a48f0 movq %r13, %rdi leaq 0xc6aa4(%rip), %rsi # 0x56b229 callq 0x1a60c0 testl %eax, %eax je 0x4a490d movq %r13, %rdi leaq 0x12c19e(%rip), %rsi # 0x5d093a callq 0x1a60c0 testl %eax, %eax je 0x4a4948 movq %r13, %rdi leaq 0x12c192(%rip), %rsi # 0x5d0945 callq 0x1a60c0 testl %eax, %eax je 0x4a4948 movq %r13, %rdi leaq 0x12c184(%rip), %rsi # 0x5d094e callq 0x1a60c0 testl %eax, %eax je 0x4a4948 movq %r13, %rdi leaq 0x12c223(%rip), %rsi # 0x5d0a04 callq 0x1a60c0 testl %eax, %eax je 0x4a497e movq %r13, %rdi leaq 0xf7b72(%rip), %rsi # 0x59c36a callq 0x1a60c0 leaq 0x60(%rsp), %rdx testl %eax, %eax je 0x4a4991 movq %r13, %rdi leaq 0x12c21f(%rip), %rsi # 0x5d0a33 callq 0x1a60c0 testl %eax, %eax je 0x4a499e movq %r13, %rdi leaq 0xf2ebb(%rip), %rsi # 0x5976e6 callq 0x1a60c0 testl %eax, %eax je 0x4a49b1 movq %r13, %rdi leaq 0x12c1fb(%rip), %rsi # 0x5d0a3d callq 0x1a60c0 testl %eax, %eax je 0x4a49c3 movq %r13, %rdi leaq 0xc61ee(%rip), %rsi # 0x56aa47 callq 0x1a60c0 leaq 0x40(%rsp), %rdx testl %eax, %eax je 0x4a4991 movq %r13, %rdi leaq 0x138453(%rip), %rsi # 0x5dccc8 callq 0x1a60c0 testl %eax, %eax je 0x4a49d9 movq %r13, %rdi leaq 0x104f79(%rip), %rsi # 0x5a9805 callq 0x1a60c0 testl %eax, %eax je 0x4a49ed movq %r13, %rdi leaq 0xa8730(%rip), %rsi # 0x54cfd3 callq 0x1a60c0 leaq 0x30(%rsp), %rdx testl %eax, %eax je 0x4a4991 movq %r13, %rdi leaq 0x112a70(%rip), %rsi # 0x5b732f callq 0x1a60c0 testl %eax, %eax je 0x4a4a03 movq %r13, %rdi leaq 0x10603d(%rip), %rsi # 0x5aa913 callq 0x1a60c0 testl %eax, %eax je 0x4a4a17 movq %rbx, %rdi movq %r13, %rsi callq 0x498b92 jmp 0x4a4948 movq 0x98(%rbx), %rdi movq (%rdi), %rax movl %r12d, %esi callq *0x30(%rax) movq %rax, %r15 leaq 0x90(%rsp), %rbp jmp 0x4a4925 movq 0x98(%rbx), %rdi movq (%rdi), %rax movl %r12d, %esi callq *0x30(%rax) movq %rax, %r15 leaq 0x70(%rsp), %rbp movq 0x8(%rbp), %r14 movq %r15, %rdi callq 0x1a56a0 movq %rbp, %rdi xorl %esi, %esi movq %r14, %rdx movq %r15, %rcx movq %rax, %r8 callq 0x1a5830 movl 0x2c(%rsp), %ebp movq 0xf0(%rsp), %rdi leaq 0x100(%rsp), %rax cmpq %rax, %rdi je 0x4a496d movq 0x100(%rsp), %rsi incq %rsi callq 0x1a5190 incl %r12d cmpl %r12d, %ebp jne 0x4a4741 jmp 0x4a4a2d movq %rbx, %rdi movl %r12d, %esi callq 0x49a228 movss %xmm0, 0x1c(%rsp) jmp 0x4a4948 movq %rbx, %rdi movl %r12d, %esi callq 0x49a9e0 jmp 0x4a4948 movq %rbx, %rdi movl %r12d, %esi callq 0x49a228 movss %xmm0, 0x18(%rsp) jmp 0x4a4948 movq %rbx, %rdi movl %r12d, %esi leaq 0x50(%rsp), %rdx callq 0x49a6aa jmp 0x4a4948 movq %rbx, %rdi movl %r12d, %esi callq 0x49a228 movss %xmm0, 0x14(%rsp) jmp 0x4a4948 movq %rbx, %rdi movl %r12d, %esi callq 0x499f12 movb %al, 0xa(%rsp) jmp 0x4a4948 movq %rbx, %rdi movl %r12d, %esi callq 0x49a228 movss %xmm0, 0x10(%rsp) jmp 0x4a4948 movq %rbx, %rdi movl %r12d, %esi callq 0x499f12 movb %al, 0xb(%rsp) jmp 0x4a4948 movq %rbx, %rdi movl %r12d, %esi callq 0x49a228 movss %xmm0, 0xc(%rsp) jmp 0x4a4948 cmpq $0x0, 0x78(%rsp) leaq 0xa0(%rsp), %r12 leaq 0x80(%rsp), %r13 jne 0x4a4a62 testb $0x1, 0xb(%rsp) je 0x4a4e47 andb $0x1, 0xa(%rsp) jmp 0x4a4b1a cmpq $0x0, 0x78(%rsp) je 0x4a4ad4 movq %rbx, %rdi callq 0x4997b6 cmpq $0x0, 0x98(%rsp) je 0x4a4a7d movq %rbx, %rdi callq 0x4989dc leaq 0x70(%rsp), %rsi leaq 0x20(%rsp), %rcx movq %rbx, %rdi movl $0x2b, %edx callq 0x498494 testb %al, %al jne 0x4a4aa5 leaq 0x70(%rsp), %rsi movq %rbx, %rdi callq 0x4994f4 movq 0x90(%rbx), %rbx movl $0x18, %edi callq 0x1a5230 leaq 0x38(%rbx), %rsi movq 0x20(%rsp), %rcx movq %rcx, 0x10(%rax) movq %rax, %rdi callq 0x1a5360 addq $0x48, %rbx jmp 0x4a4e44 xorps %xmm0, %xmm0 movss %xmm0, 0x1c(%rsp) movss 0xb6b3b(%rip), %xmm0 # 0x55b620 movss %xmm0, 0xc(%rsp) movss 0xb6abd(%rip), %xmm0 # 0x55b5b0 movss %xmm0, 0x10(%rsp) movb $0x1, 0xa(%rsp) movss 0x12bef6(%rip), %xmm0 # 0x5d09fc movss %xmm0, 0x14(%rsp) movss 0x12beec(%rip), %xmm0 # 0x5d0a00 movss %xmm0, 0x18(%rsp) movl $0x98, %edi callq 0x1a5230 movq %rax, %r14 movq 0x90(%rbx), %rax movl $0x2b, 0x8(%r14) leaq 0x10(%r14), %r15 leaq 0x20(%r14), %rcx movq %rcx, 0x10(%r14) xorl %ecx, %ecx movq %rcx, 0x18(%r14) movb $0x0, 0x20(%r14) movq %rax, 0x30(%r14) leaq 0x38(%r14), %rax movq %rax, 0x40(%r14) movq %rax, 0x38(%r14) movq %rcx, 0x48(%r14) leaq 0x2fabb8(%rip), %rax # 0x79f720 movq %rax, (%r14) xorps %xmm0, %xmm0 movups %xmm0, 0x54(%r14) movq %rcx, 0x64(%r14) movups %xmm0, 0x74(%r14) movq %rcx, 0x84(%r14) movq %r14, 0x20(%rsp) cmpq %rcx, 0x98(%rsp) je 0x4a4ba2 leaq 0x90(%rsp), %rsi movq %r15, %rdi callq 0x1a64a0 movq %r14, %rax addq $0x74, %rax movss 0x14(%rsp), %xmm1 movaps %xmm1, %xmm0 minss 0x18(%rsp), %xmm0 movss 0x1c(%rsp), %xmm2 movss %xmm2, 0x50(%r14) movl 0x68(%rsp), %ecx movl %ecx, 0x8(%rax) movq 0x60(%rsp), %rcx movq %rcx, (%rax) movss %xmm0, 0x90(%r14) movsd 0x50(%rsp), %xmm0 movsd %xmm0, 0x54(%r14) movss 0x58(%rsp), %xmm0 movss %xmm0, 0x5c(%r14) movss %xmm1, 0x94(%r14) movq 0x40(%rsp), %rax movq %rax, 0x60(%r14) movl 0x48(%rsp), %eax movl %eax, 0x68(%r14) movb 0xa(%rsp), %al movb %al, 0x6c(%r14) movss 0x10(%rsp), %xmm0 movss %xmm0, 0x70(%r14) movq 0x30(%rsp), %rax movq %rax, 0x80(%r14) movl 0x38(%rsp), %eax movl %eax, 0x88(%r14) movss 0xc(%rsp), %xmm0 movss %xmm0, 0x8c(%r14) movq %rbx, %rdi xorl %esi, %esi callq 0x49ec96 cmpq $0x0, 0x18(%r14) jne 0x4a4d79 leaq 0xf0(%rsp), %rdi callq 0x1a6170 leaq 0xf0(%rsp), %rdi movq %r14, %rsi callq 0x1a5850 leaq 0xf8(%rsp), %rsi leaq 0xb0(%rsp), %rdi callq 0x1a5690 movq 0x3072fa(%rip), %rsi # 0x7abf90 leaq 0xf0(%rsp), %rdi callq 0x1a5d00 leaq 0x160(%rsp), %rdi callq 0x1a5ca0 leaq 0x12bd92(%rip), %rcx # 0x5d0a49 leaq 0xb0(%rsp), %rdi movl $0xa, %r8d xorl %esi, %esi xorl %edx, %edx callq 0x1a5260 leaq 0xe0(%rsp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx movq %r12, %rbp cmpq %rcx, %rdx je 0x4a4d01 movq %rdx, 0xd0(%rsp) movq (%rcx), %rdx movq %rdx, 0xe0(%rsp) jmp 0x4a4d09 movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx leaq 0xd0(%rsp), %r12 movq %rdx, 0x8(%r12) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq %r15, %rdi movq %r12, %rsi callq 0x1a58d0 movq (%r12), %rdi cmpq %r13, %rdi je 0x4a4d4d movq 0xe0(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0xc0(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi movq %rbp, %r12 leaq 0x80(%rsp), %r13 je 0x4a4d79 movq 0xc0(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x90(%rbx), %rdi addq $0x10, %rdi movq %r15, %rsi callq 0x1a64a0 movq %rbx, %rdi callq 0x49edce movq 0x98(%rbx), %rdi movq (%rdi), %rax callq *0x78(%rax) testb %al, %al je 0x4a4dcc movq 0x90(%rbx), %r15 movl $0x18, %edi callq 0x1a5230 leaq 0x38(%r15), %rsi movq %r14, 0x10(%rax) movq %rax, %rdi callq 0x1a5360 incq 0x48(%r15) jmp 0x4a4e23 leaq 0x100(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x12b9e9(%rip), %rsi # 0x5d07c8 leaq 0x12b9eb(%rip), %rdx # 0x5d07d1 leaq 0xf0(%rsp), %rdi callq 0x209290 leaq 0xf0(%rsp), %rdx movq %rbx, %rdi movq %r14, %rsi callq 0x4a7412 movq 0xf0(%rsp), %rdi cmpq %r15, %rdi je 0x4a4e23 movq 0x100(%rsp), %rsi incq %rsi callq 0x1a5190 movl $0x18, %edi callq 0x1a5230 leaq 0x78(%rbx), %rsi movq %r14, 0x10(%rax) movq %rax, %rdi callq 0x1a5360 addq $0x88, %rbx incq (%rbx) movq 0x70(%rsp), %rdi cmpq %r13, %rdi je 0x4a4e61 movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x90(%rsp), %rdi cmpq %r12, %rdi je 0x4a4e7e movq 0xa0(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x268, %rsp # imm = 0x268 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq 0xc0(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4a4f1d movq 0xc0(%rsp), %rsi jmp 0x4a4f15 jmp 0x4a4ef0 movq %rax, %rbx movq 0xf0(%rsp), %rdi cmpq %r15, %rdi jne 0x4a4f0d jmp 0x4a4f1d jmp 0x4a4ef0 movq %rax, %rbx movq 0x3070c2(%rip), %rsi # 0x7abf90 leaq 0xf0(%rsp), %rdi callq 0x1a5d00 leaq 0x160(%rsp), %rdi callq 0x1a5ca0 jmp 0x4a4f1d jmp 0x4a4ef0 jmp 0x4a4ef0 jmp 0x4a4ef0 movq %rax, %rbx jmp 0x4a4f1d movq %rax, %rbx movq 0xf0(%rsp), %rdi leaq 0x100(%rsp), %rax cmpq %rax, %rdi je 0x4a4f1d movq 0x100(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x70(%rsp), %rdi leaq 0x80(%rsp), %rax cmpq %rax, %rdi je 0x4a4f3f movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x90(%rsp), %rdi leaq 0xa0(%rsp), %rax cmpq %rax, %rdi je 0x4a4f64 movq 0xa0(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Light.cpp
Assimp::X3DImporter::ParseNode_MetadataSet()
void X3DImporter::ParseNode_MetadataSet() { std::string def, use; std::string name, reference; CX3DImporter_NodeElement* ne( nullptr ); MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECK_RET("name", name, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("reference", reference, mReader->getAttributeValue); MACRO_ATTRREAD_LOOPEND; // if "USE" defined then find already defined element. if(!use.empty()) { MACRO_USE_CHECKANDAPPLY(def, use, ENET_MetaSet, ne); } else { ne = new CX3DImporter_NodeElement_MetaSet(NodeElement_Cur); if(!def.empty()) ne->ID = def; ((CX3DImporter_NodeElement_MetaSet*)ne)->Reference = reference; // also metadata node can contain childs if(!mReader->isEmptyElement()) ParseNode_Metadata(ne, "MetadataSet"); else NodeElement_Cur->Child.push_back(ne);// made object as child to current element NodeElement_List.push_back(ne);// add new element to elements list. }// if(!use.empty()) else }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xb8, %rsp movq %rdi, %r12 leaq 0x60(%rsp), %rcx movq %rcx, -0x10(%rcx) xorl %eax, %eax movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0x40(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0xa8(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0x80(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) movq %rax, 0x28(%rsp) movq 0x98(%rdi), %rdi movq (%rdi), %rax callq *0x20(%rax) movl %eax, %ebp testl %eax, %eax jle 0x4a6b4c xorl %r14d, %r14d leaq 0x8(%rsp), %r15 movq %r12, 0x90(%rsp) movq 0x98(%r12), %rdi movq (%rdi), %rax movl %r14d, %esi callq *0x28(%rax) movq %r15, %rdi movq %rax, %rsi leaq 0x7(%rsp), %rdx callq 0x23ca1c movq %r15, %rdi leaq 0x12bb16(%rip), %rsi # 0x5d24fd callq 0x1a60c0 testl %eax, %eax je 0x4a6a8b movq %r15, %rdi leaq 0xc482b(%rip), %rsi # 0x56b229 callq 0x1a60c0 testl %eax, %eax je 0x4a6aa6 movq %r15, %rdi leaq 0x129f25(%rip), %rsi # 0x5d093a callq 0x1a60c0 testl %eax, %eax je 0x4a6ae6 movq %r15, %rdi leaq 0x129f19(%rip), %rsi # 0x5d0945 callq 0x1a60c0 testl %eax, %eax je 0x4a6ae6 movq %r15, %rdi leaq 0x129f0b(%rip), %rsi # 0x5d094e callq 0x1a60c0 testl %eax, %eax je 0x4a6ae6 movq %r15, %rdi leaq 0xf95db(%rip), %rsi # 0x5a0035 callq 0x1a60c0 testl %eax, %eax je 0x4a6b10 movq %r15, %rdi leaq 0xf89b7(%rip), %rsi # 0x59f428 callq 0x1a60c0 testl %eax, %eax je 0x4a6b2e movq %r12, %rdi movq %r15, %rsi callq 0x498b92 jmp 0x4a6ae6 movq 0x98(%r12), %rdi movq (%rdi), %rax movl %r14d, %esi callq *0x30(%rax) movq %rax, %r12 leaq 0x50(%rsp), %r13 jmp 0x4a6abf movq 0x98(%r12), %rdi movq (%rdi), %rax movl %r14d, %esi callq *0x30(%rax) movq %rax, %r12 leaq 0x30(%rsp), %r13 movq 0x8(%r13), %rbx movq %r12, %rdi callq 0x1a56a0 movq %r13, %rdi xorl %esi, %esi movq %rbx, %rdx movq %r12, %rcx movq %rax, %r8 callq 0x1a5830 movq 0x90(%rsp), %r12 movq 0x8(%rsp), %rdi leaq 0x18(%rsp), %rax cmpq %rax, %rdi je 0x4a6b02 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 incl %r14d cmpl %r14d, %ebp jne 0x4a69bc jmp 0x4a6b4c movq 0x98(%r12), %rdi movq (%rdi), %rax movl %r14d, %esi callq *0x30(%rax) movq %rax, %r12 leaq 0x98(%rsp), %r13 jmp 0x4a6abf movq 0x98(%r12), %rdi movq (%rdi), %rax movl %r14d, %esi callq *0x30(%rax) movq %rax, %r12 leaq 0x70(%rsp), %r13 jmp 0x4a6abf cmpq $0x0, 0x38(%rsp) je 0x4a6bc5 movq %r12, %rdi callq 0x4997b6 cmpq $0x0, 0x58(%rsp) je 0x4a6b6c movq %r12, %rdi callq 0x4989dc leaq 0x30(%rsp), %rsi leaq 0x28(%rsp), %rcx movq %r12, %rdi movl $0x5, %edx callq 0x498494 testb %al, %al jne 0x4a6b94 leaq 0x30(%rsp), %rsi movq %r12, %rdi callq 0x4994f4 movq 0x90(%r12), %r12 movl $0x18, %edi callq 0x1a5230 leaq 0x38(%r12), %rsi movq 0x28(%rsp), %rcx movq %rcx, 0x10(%rax) movq %rax, %rdi callq 0x1a5360 addq $0x48, %r12 jmp 0x4a6d19 movl $0xa8, %edi callq 0x1a5230 movq %rax, %r14 movq 0x90(%r12), %rax movl $0x5, 0x8(%r14) leaq 0x20(%r14), %rcx movq %rcx, 0x10(%r14) xorl %ecx, %ecx movq %rcx, 0x18(%r14) movb %cl, 0x20(%r14) movq %rax, 0x30(%r14) leaq 0x38(%r14), %rax movq %rax, 0x40(%r14) movq %rax, 0x38(%r14) movq %rcx, 0x48(%r14) leaq 0x60(%r14), %rax movq %rax, 0x50(%r14) movq %rcx, 0x58(%r14) movb %cl, 0x60(%r14) leaq 0x80(%r14), %rax movq %rax, 0x70(%r14) movq %rcx, 0x78(%r14) movb %cl, 0x80(%r14) leaq 0x2f8c03(%rip), %rax # 0x79f838 movq %rax, (%r14) leaq 0x90(%r14), %rax movq %rax, 0x98(%r14) movq %rax, 0x90(%r14) movq %rcx, 0xa0(%r14) cmpq %rcx, 0x58(%rsp) je 0x4a6c69 leaq 0x10(%r14), %rdi leaq 0x50(%rsp), %rsi callq 0x1a64a0 movq %r14, %rdi addq $0x70, %rdi leaq 0x70(%rsp), %rsi callq 0x1a64a0 movq 0x98(%r12), %rdi movq (%rdi), %rax callq *0x78(%rax) testb %al, %al je 0x4a6cb4 movq 0x90(%r12), %rbx movl $0x18, %edi callq 0x1a5230 leaq 0x38(%rbx), %rsi movq %r14, 0x10(%rax) movq %rax, %rdi callq 0x1a5360 incq 0x48(%rbx) jmp 0x4a6cf7 leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x129dee(%rip), %rsi # 0x5d0ab2 leaq 0x129df2(%rip), %rdx # 0x5d0abd leaq 0x8(%rsp), %rdi callq 0x209290 movq %r12, %rdi movq %r14, %rsi callq 0x4a7412 movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x4a6cf7 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 movl $0x18, %edi callq 0x1a5230 leaq 0x78(%r12), %rsi movq %r14, 0x10(%rax) movq %rax, %rdi callq 0x1a5360 addq $0x88, %r12 leaq 0x40(%rsp), %rbx incq (%r12) movq 0x70(%rsp), %rdi leaq 0x80(%rsp), %rax cmpq %rax, %rdi je 0x4a6d44 movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x98(%rsp), %rdi leaq 0xa8(%rsp), %rax cmpq %rax, %rdi je 0x4a6d69 movq 0xa8(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x30(%rsp), %rdi cmpq %rbx, %rdi je 0x4a6d80 movq 0x40(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x50(%rsp), %rdi leaq 0x60(%rsp), %rax cmpq %rax, %rdi je 0x4a6d9c movq 0x60(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0xb8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq 0x8(%rsp), %rdi cmpq %r15, %rdi jne 0x4a6ddc jmp 0x4a6de9 jmp 0x4a6dc5 jmp 0x4a6dc5 jmp 0x4a6dc5 jmp 0x4a6dc5 movq %rax, %rbx jmp 0x4a6de9 movq %rax, %rbx movq 0x8(%rsp), %rdi leaq 0x18(%rsp), %rax cmpq %rax, %rdi je 0x4a6de9 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x70(%rsp), %rdi leaq 0x80(%rsp), %rax cmpq %rax, %rdi je 0x4a6e0b movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x98(%rsp), %rdi leaq 0xa8(%rsp), %rax cmpq %rax, %rdi je 0x4a6e30 movq 0xa8(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x30(%rsp), %rdi leaq 0x40(%rsp), %rax cmpq %rax, %rdi je 0x4a6e4c movq 0x40(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x50(%rsp), %rdi leaq 0x60(%rsp), %rax cmpq %rax, %rdi je 0x4a6e68 movq 0x60(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Metadata.cpp
Assimp::X3DImporter::PostprocessHelper_ElementIsMesh(CX3DImporter_NodeElement::EType) const
bool X3DImporter::PostprocessHelper_ElementIsMesh(const CX3DImporter_NodeElement::EType pType) const { if((pType == CX3DImporter_NodeElement::ENET_Arc2D) || (pType == CX3DImporter_NodeElement::ENET_ArcClose2D) || (pType == CX3DImporter_NodeElement::ENET_Box) || (pType == CX3DImporter_NodeElement::ENET_Circle2D) || (pType == CX3DImporter_NodeElement::ENET_Cone) || (pType == CX3DImporter_NodeElement::ENET_Cylinder) || (pType == CX3DImporter_NodeElement::ENET_Disk2D) || (pType == CX3DImporter_NodeElement::ENET_ElevationGrid) || (pType == CX3DImporter_NodeElement::ENET_Extrusion) || (pType == CX3DImporter_NodeElement::ENET_IndexedFaceSet) || (pType == CX3DImporter_NodeElement::ENET_IndexedLineSet) || (pType == CX3DImporter_NodeElement::ENET_IndexedTriangleFanSet) || (pType == CX3DImporter_NodeElement::ENET_IndexedTriangleSet) || (pType == CX3DImporter_NodeElement::ENET_IndexedTriangleStripSet) || (pType == CX3DImporter_NodeElement::ENET_PointSet) || (pType == CX3DImporter_NodeElement::ENET_LineSet) || (pType == CX3DImporter_NodeElement::ENET_Polyline2D) || (pType == CX3DImporter_NodeElement::ENET_Polypoint2D) || (pType == CX3DImporter_NodeElement::ENET_Rectangle2D) || (pType == CX3DImporter_NodeElement::ENET_Sphere) || (pType == CX3DImporter_NodeElement::ENET_TriangleFanSet) || (pType == CX3DImporter_NodeElement::ENET_TriangleSet) || (pType == CX3DImporter_NodeElement::ENET_TriangleSet2D) || (pType == CX3DImporter_NodeElement::ENET_TriangleStripSet)) { return true; } else { return false; } }
movd %esi, %xmm0 pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0] movdqa 0x128473(%rip), %xmm1 # 0x5d0b90 paddd %xmm0, %xmm1 movl %esi, %eax andl $-0x4, %eax cmpl $0x18, %eax sete %cl movl %esi, %eax andl $-0x3, %eax cmpl $0x1c, %eax pcmpeqd 0x128464(%rip), %xmm0 # 0x5d0ba0 sete %dl pxor 0xb2b59(%rip), %xmm1 # 0x55b2a0 movdqa 0x128461(%rip), %xmm2 # 0x5d0bb0 pcmpgtd %xmm1, %xmm2 por %xmm0, %xmm2 addl $-0x1f, %esi cmpl $0x2, %esi setb %al movmskps %xmm2, %esi testl %esi, %esi setne %sil orb %dl, %al orb %cl, %al orb %sil, %al retq nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Postprocess.cpp
Assimp::X3DImporter::Postprocess_CollectMetadata(CX3DImporter_NodeElement const&, aiNode&) const
void X3DImporter::Postprocess_CollectMetadata(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode) const { std::list<CX3DImporter_NodeElement*> meta_list; size_t meta_idx; PostprocessHelper_CollectMetadata(pNodeElement, meta_list);// find metadata in current node element. if ( !meta_list.empty() ) { if ( pSceneNode.mMetaData != nullptr ) { throw DeadlyImportError( "Postprocess. MetaData member in node are not nullptr. Something went wrong." ); } // copy collected metadata to output node. pSceneNode.mMetaData = aiMetadata::Alloc( static_cast<unsigned int>(meta_list.size()) ); meta_idx = 0; for(std::list<CX3DImporter_NodeElement*>::const_iterator it = meta_list.begin(); it != meta_list.end(); ++it, ++meta_idx) { CX3DImporter_NodeElement_Meta* cur_meta = (CX3DImporter_NodeElement_Meta*)*it; // due to limitations we can add only first element of value list. // Add an element according to its type. if((*it)->Type == CX3DImporter_NodeElement::ENET_MetaBoolean) { if(((CX3DImporter_NodeElement_MetaBoolean*)cur_meta)->Value.size() > 0) pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, *(((CX3DImporter_NodeElement_MetaBoolean*)cur_meta)->Value.begin())); } else if((*it)->Type == CX3DImporter_NodeElement::ENET_MetaDouble) { if(((CX3DImporter_NodeElement_MetaDouble*)cur_meta)->Value.size() > 0) pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, (float)*(((CX3DImporter_NodeElement_MetaDouble*)cur_meta)->Value.begin())); } else if((*it)->Type == CX3DImporter_NodeElement::ENET_MetaFloat) { if(((CX3DImporter_NodeElement_MetaFloat*)cur_meta)->Value.size() > 0) pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, *(((CX3DImporter_NodeElement_MetaFloat*)cur_meta)->Value.begin())); } else if((*it)->Type == CX3DImporter_NodeElement::ENET_MetaInteger) { if(((CX3DImporter_NodeElement_MetaInteger*)cur_meta)->Value.size() > 0) pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, *(((CX3DImporter_NodeElement_MetaInteger*)cur_meta)->Value.begin())); } else if((*it)->Type == CX3DImporter_NodeElement::ENET_MetaString) { if(((CX3DImporter_NodeElement_MetaString*)cur_meta)->Value.size() > 0) { aiString tstr(((CX3DImporter_NodeElement_MetaString*)cur_meta)->Value.begin()->data()); pSceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx), cur_meta->Name, tstr); } } else { throw DeadlyImportError("Postprocess. Unknown metadata type."); }// if((*it)->Type == CX3DImporter_NodeElement::ENET_Meta*) else }// for(std::list<CX3DImporter_NodeElement*>::const_iterator it = meta_list.begin(); it != meta_list.end(); it++) }// if( !meta_list.empty() ) }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x468, %rsp # imm = 0x468 movq %rdx, 0x10(%rsp) leaq 0x28(%rsp), %r15 movq %r15, 0x8(%r15) movq %r15, (%r15) movq $0x0, 0x10(%r15) movq %r15, %rdx callq 0x4a8682 movq 0x28(%rsp), %r14 cmpq %r15, %r14 je 0x4ab131 movq 0x10(%rsp), %rax cmpq $0x0, 0x470(%rax) jne 0x4ab1c2 movq 0x38(%rsp), %rbx testl %ebx, %ebx je 0x4aaccd movl $0x18, %edi callq 0x1a5230 movq %rax, %r15 movl %ebx, %r13d movl %ebx, (%rax) movq %r13, %rax shlq $0xa, %rax leaq (%rax,%r13,4), %rbp movq %rbp, %rdi callq 0x1a57a0 movq %rax, %r12 addq %rax, %rbp movq %rax, %rbx movl $0x0, (%rbx) movb $0x0, 0x4(%rbx) leaq 0x5(%rbx), %rdi movl $0x3ff, %edx # imm = 0x3FF movl $0x1b, %esi callq 0x1a54e0 addq $0x404, %rbx # imm = 0x404 cmpq %rbp, %rbx jne 0x4aac7e movq %r12, 0x8(%r15) shlq $0x4, %r13 movq %r13, %rdi callq 0x1a57a0 movq %rax, %r12 movq %rax, %rdi xorl %esi, %esi movq %r13, %rdx callq 0x1a54e0 movq %r12, 0x10(%r15) jmp 0x4aacd0 xorl %r15d, %r15d movq 0x10(%rsp), %rax movq %r15, 0x470(%rax) xorl %r12d, %r12d leaq 0x125f46(%rip), %rdx # 0x5d0c2c movq 0x10(%r14), %rbx movl 0x8(%rbx), %eax decl %eax cmpl $0x5, %eax ja 0x4ab160 movslq (%rdx,%rax,4), %rax addq %rdx, %rax jmpq *%rax movq 0x90(%rbx), %r15 movq 0xa0(%rbx), %rax movl 0xa8(%rbx), %ecx subq %r15, %rax shlq $0x3, %rax addq %rcx, %rax je 0x4ab118 movq 0x10(%rsp), %rax movq 0x470(%rax), %rbp cmpl %r12d, (%rbp) jbe 0x4ab118 movq 0x58(%rbx), %rsi testq %rsi, %rsi je 0x4ab118 movl %r12d, %r13d cmpq $0x3ff, %rsi # imm = 0x3FF ja 0x4aad93 movq 0x8(%rbp), %rax movq %r13, %rcx shlq $0xa, %rcx leaq (%rcx,%r13,4), %rcx leaq (%rax,%rcx), %rdx movq %rdx, 0x8(%rsp) leaq (%rax,%rcx), %rdi addq $0x4, %rdi movl %esi, -0x4(%rdi) movq %rsi, %rax movq 0x50(%rbx), %rsi movq %rax, %rbx movq %rax, %rdx callq 0x1a5110 movq 0x8(%rsp), %rax movb $0x0, 0x4(%rbx,%rax) movq 0x10(%rbp), %rax shlq $0x4, %r13 movl $0x0, (%rax,%r13) movl $0x10, %edi callq 0x1a5230 movq %r15, (%rax) movq $0x1, 0x8(%rax) jmp 0x4ab04d cmpq $0x0, 0xa0(%rbx) je 0x4ab118 movq 0x90(%rbx), %rax movq 0x10(%rax), %rsi leaq 0x40(%rsp), %rdi leaq 0x1f(%rsp), %rdx callq 0x23ca1c movq 0x40(%rsp), %rbp movq 0x48(%rsp), %r13 testl $0xfffffc00, %r13d # imm = 0xFFFFFC00 movl $0x3ff, %eax # imm = 0x3FF cmovnel %eax, %r13d movl %r13d, 0x60(%rsp) leaq 0x64(%rsp), %rdi movq %rbp, %rsi movq %r13, %rdx callq 0x1a5110 movb $0x0, 0x64(%rsp,%r13) leaq 0x50(%rsp), %rax cmpq %rax, %rbp je 0x4aae34 movq 0x50(%rsp), %rsi incq %rsi movq %rbp, %rdi callq 0x1a5190 movq 0x10(%rsp), %rax movq 0x470(%rax), %rax cmpl %r12d, (%rax) jbe 0x4ab111 movq 0x58(%rbx), %rbp testq %rbp, %rbp je 0x4ab111 movl %r12d, %r15d cmpq $0x3ff, %rbp # imm = 0x3FF ja 0x4aaeaa movq %rax, 0x8(%rsp) movq 0x8(%rsp), %rax movq 0x8(%rax), %rax movq %r15, %rcx shlq $0xa, %rcx leaq (%rcx,%r15,4), %rcx leaq (%rax,%rcx), %rdx movq %rdx, 0x20(%rsp) leaq (%rax,%rcx), %rdi addq $0x4, %rdi movl %ebp, -0x4(%rdi) movq 0x50(%rbx), %rsi movq %rbp, %rdx callq 0x1a5110 movq 0x8(%rsp), %rax movq 0x20(%rsp), %rcx movb $0x0, 0x4(%rbp,%rcx) movq %rax, %rbx movq 0x10(%rax), %rax shlq $0x4, %r15 movl $0x5, (%rax,%r15) movl $0x404, %edi # imm = 0x404 callq 0x1a5230 movq %rax, %rbp movl $0x3ff, %eax # imm = 0x3FF cmpl %eax, %r13d cmovael %eax, %r13d movl %r13d, (%rbp) movq %rbp, %rdi addq $0x4, %rdi leaq 0x64(%rsp), %rsi movq %r13, %rdx callq 0x1a5110 movb $0x0, 0x4(%rbp,%r13) movq 0x10(%rbx), %rax movq %rbp, 0x8(%rax,%r15) jmp 0x4ab111 movq 0x90(%rbx), %r15 cmpq %r15, 0x98(%rbx) je 0x4ab118 movq 0x10(%rsp), %rax movq 0x470(%rax), %rbp cmpl %r12d, (%rbp) jbe 0x4ab118 movq 0x58(%rbx), %rsi testq %rsi, %rsi je 0x4ab118 movl %r12d, %r13d cmpq $0x3ff, %rsi # imm = 0x3FF ja 0x4aaf84 movq 0x8(%rbp), %rax movq %r13, %rcx shlq $0xa, %rcx leaq (%rcx,%r13,4), %rcx leaq (%rax,%rcx), %rdx movq %rdx, 0x8(%rsp) leaq (%rax,%rcx), %rdi addq $0x4, %rdi movl %esi, -0x4(%rdi) movq %rsi, %rax movq 0x50(%rbx), %rsi movq %rax, %rbx movq %rax, %rdx callq 0x1a5110 movq 0x8(%rsp), %rax movb $0x0, 0x4(%rbx,%rax) movq 0x10(%rbp), %rax shlq $0x4, %r13 movl $0x3, (%rax,%r13) movl $0x4, %edi callq 0x1a5230 movss (%r15), %xmm0 movss %xmm0, (%rax) jmp 0x4ab04d movq 0x90(%rbx), %r15 cmpq %r15, 0x98(%rbx) je 0x4ab118 movq 0x10(%rsp), %rax movq 0x470(%rax), %rbp cmpl %r12d, (%rbp) jbe 0x4ab118 movq 0x58(%rbx), %rsi testq %rsi, %rsi je 0x4ab118 movl %r12d, %r13d cmpq $0x3ff, %rsi # imm = 0x3FF ja 0x4ab02e movq 0x8(%rbp), %rax movq %r13, %rcx shlq $0xa, %rcx leaq (%rcx,%r13,4), %rcx leaq (%rax,%rcx), %rdx movq %rdx, 0x8(%rsp) leaq (%rax,%rcx), %rdi addq $0x4, %rdi movl %esi, -0x4(%rdi) movq %rsi, %rax movq 0x50(%rbx), %rsi movq %rax, %rbx movq %rax, %rdx callq 0x1a5110 movq 0x8(%rsp), %rax movb $0x0, 0x4(%rbx,%rax) movq 0x10(%rbp), %rax shlq $0x4, %r13 movl $0x1, (%rax,%r13) movl $0x4, %edi callq 0x1a5230 movl (%r15), %ecx movl %ecx, (%rax) movq 0x10(%rbp), %rcx movq %rax, 0x8(%rcx,%r13) jmp 0x4ab111 movq 0x90(%rbx), %rax cmpq %rax, 0x98(%rbx) je 0x4ab118 movq 0x10(%rsp), %rcx movq 0x470(%rcx), %r15 cmpl %r12d, (%r15) jbe 0x4ab118 movq 0x58(%rbx), %r13 testq %r13, %r13 je 0x4ab118 xorps %xmm0, %xmm0 cvtsd2ss (%rax), %xmm0 movss %xmm0, 0x8(%rsp) movl %r12d, %ebp cmpq $0x3ff, %r13 # imm = 0x3FF ja 0x4ab0e5 movq 0x8(%r15), %rax movq %rbp, %rcx shlq $0xa, %rcx leaq (%rcx,%rbp,4), %rcx leaq (%rax,%rcx), %rdx movq %rdx, 0x20(%rsp) leaq (%rax,%rcx), %rdi addq $0x4, %rdi movl %r13d, -0x4(%rdi) movq 0x50(%rbx), %rsi movq %r13, %rdx callq 0x1a5110 movq 0x20(%rsp), %rax movb $0x0, 0x4(%r13,%rax) movq 0x10(%r15), %rax shlq $0x4, %rbp movl $0x3, (%rax,%rbp) movl $0x4, %edi callq 0x1a5230 movss 0x8(%rsp), %xmm0 movss %xmm0, (%rax) movq 0x10(%r15), %rcx movq %rax, 0x8(%rcx,%rbp) leaq 0x125b14(%rip), %rdx # 0x5d0c2c movq (%r14), %r14 incq %r12 leaq 0x28(%rsp), %r15 cmpq %r15, %r14 jne 0x4aace6 movq 0x28(%rsp), %r14 cmpq %r15, %r14 je 0x4ab14e movq (%r14), %rbx movl $0x18, %esi movq %r14, %rdi callq 0x1a5190 movq %rbx, %r14 cmpq %r15, %rbx jne 0x4ab136 addq $0x468, %rsp # imm = 0x468 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %r15 leaq 0x70(%rsp), %rbx movq %rbx, -0x10(%rbx) leaq 0x125f2e(%rip), %rsi # 0x5d10ab leaq 0x125f4a(%rip), %rdx # 0x5d10ce leaq 0x60(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x60(%rsp), %rsi movq %r15, %rdi callq 0x1a53e0 leaq 0x232593(%rip), %rax # 0x6dd738 movq %rax, (%r15) xorl %ebp, %ebp leaq 0x23255f(%rip), %rsi # 0x6dd710 movq 0x300da8(%rip), %rdx # 0x7abf60 movq %r15, %rdi callq 0x1a5b00 jmp 0x4ab222 movl $0x10, %edi callq 0x1a5680 movq %rax, %r15 leaq 0x70(%rsp), %rbx movq %rbx, -0x10(%rbx) leaq 0xec5ba(%rip), %rsi # 0x597799 leaq 0xec5fe(%rip), %rdx # 0x5977e4 leaq 0x60(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x60(%rsp), %rsi movq %r15, %rdi callq 0x1a53e0 leaq 0x232531(%rip), %rax # 0x6dd738 movq %rax, (%r15) xorl %ebp, %ebp leaq 0x2324fd(%rip), %rsi # 0x6dd710 movq 0x300d46(%rip), %rdx # 0x7abf60 movq %r15, %rdi callq 0x1a5b00 jmp 0x4ab230 jmp 0x4ab251 jmp 0x4ab260 jmp 0x4ab260 jmp 0x4ab260 jmp 0x4ab260 jmp 0x4ab260 movq %rax, %r14 movq 0x60(%rsp), %rdi cmpq %rbx, %rdi je 0x4ab24a movq 0x70(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x4ab254 jmp 0x4ab263 movq %rax, %r14 movq %r15, %rdi callq 0x1a6080 jmp 0x4ab263 jmp 0x4ab260 movq %rax, %r14 movq 0x28(%rsp), %rdi leaq 0x28(%rsp), %r15 cmpq %r15, %rdi je 0x4ab287 movq (%rdi), %rbx movl $0x18, %esi callq 0x1a5190 movq %rbx, %rdi cmpq %r15, %rbx jne 0x4ab272 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Postprocess.cpp
Assimp::X3DImporter::ParseNode_Texturing_ImageTexture()
void X3DImporter::ParseNode_Texturing_ImageTexture() { std::string use, def; bool repeatS = true; bool repeatT = true; std::list<std::string> url; CX3DImporter_NodeElement* ne( nullptr ); MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECK_RET("repeatS", repeatS, XML_ReadNode_GetAttrVal_AsBool); MACRO_ATTRREAD_CHECK_RET("repeatT", repeatT, XML_ReadNode_GetAttrVal_AsBool); MACRO_ATTRREAD_CHECK_REF("url", url, XML_ReadNode_GetAttrVal_AsListS); MACRO_ATTRREAD_LOOPEND; // if "USE" defined then find already defined element. if(!use.empty()) { MACRO_USE_CHECKANDAPPLY(def, use, ENET_ImageTexture, ne); } else { // create and if needed - define new geometry object. ne = new CX3DImporter_NodeElement_ImageTexture(NodeElement_Cur); if(!def.empty()) ne->ID = def; ((CX3DImporter_NodeElement_ImageTexture*)ne)->RepeatS = repeatS; ((CX3DImporter_NodeElement_ImageTexture*)ne)->RepeatT = repeatT; // Attribute "url" can contain list of strings. But we need only one - first. if(!url.empty()) ((CX3DImporter_NodeElement_ImageTexture*)ne)->URL = url.front(); else ((CX3DImporter_NodeElement_ImageTexture*)ne)->URL = ""; // check for X3DMetadataObject childs. if(!mReader->isEmptyElement()) ParseNode_Metadata(ne, "ImageTexture"); else NodeElement_Cur->Child.push_back(ne);// add made object as child to current element NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph }// if(!use.empty()) else }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x98, %rsp movq %rdi, %rbx leaq 0x70(%rsp), %r12 movq %r12, -0x10(%r12) xorl %eax, %eax movq %rax, -0x8(%r12) movb %al, (%r12) leaq 0x50(%rsp), %r13 movq %r13, -0x10(%r13) movq %rax, -0x8(%r13) movb %al, (%r13) leaq 0x80(%rsp), %rcx movq %rcx, 0x8(%rcx) movq %rcx, (%rcx) movq %rax, 0x10(%rcx) movq %rax, 0x10(%rsp) movq 0x98(%rdi), %rdi movq (%rdi), %rax callq *0x20(%rax) movl %eax, %ebp testl %eax, %eax jle 0x4ad2ec xorl %r12d, %r12d movb $0x1, 0xe(%rsp) leaq 0x20(%rsp), %r13 movb $0x1, 0xd(%rsp) movl %ebp, 0x1c(%rsp) movq 0x98(%rbx), %rdi movq (%rdi), %rax movl %r12d, %esi callq *0x28(%rax) movq %r13, %rdi movq %rax, %rsi leaq 0xf(%rsp), %rdx callq 0x23ca1c movq %r13, %rdi leaq 0x125398(%rip), %rsi # 0x5d24fd callq 0x1a60c0 testl %eax, %eax je 0x4ad220 movq %r13, %rdi leaq 0xbe0ad(%rip), %rsi # 0x56b229 callq 0x1a60c0 testl %eax, %eax je 0x4ad23a movq %r13, %rdi leaq 0x1237a7(%rip), %rsi # 0x5d093a callq 0x1a60c0 testl %eax, %eax je 0x4ad275 movq %r13, %rdi leaq 0x12379b(%rip), %rsi # 0x5d0945 callq 0x1a60c0 testl %eax, %eax je 0x4ad275 movq %r13, %rdi leaq 0x12378d(%rip), %rsi # 0x5d094e callq 0x1a60c0 testl %eax, %eax je 0x4ad275 movq %r13, %rdi leaq 0x124045(%rip), %rsi # 0x5d121d callq 0x1a60c0 testl %eax, %eax je 0x4ad29f movq %r13, %rdi leaq 0x124036(%rip), %rsi # 0x5d1225 callq 0x1a60c0 testl %eax, %eax je 0x4ad2b0 movq %r13, %rdi leaq 0xeec0a(%rip), %rsi # 0x59be10 callq 0x1a60c0 testl %eax, %eax je 0x4ad2c1 movq %rbx, %rdi movq %r13, %rsi callq 0x498b92 jmp 0x4ad275 movq 0x98(%rbx), %rdi movq (%rdi), %rax movl %r12d, %esi callq *0x30(%rax) movq %rax, %r14 leaq 0x40(%rsp), %rbp jmp 0x4ad252 movq 0x98(%rbx), %rdi movq (%rdi), %rax movl %r12d, %esi callq *0x30(%rax) movq %rax, %r14 leaq 0x60(%rsp), %rbp movq 0x8(%rbp), %r15 movq %r14, %rdi callq 0x1a56a0 movq %rbp, %rdi xorl %esi, %esi movq %r15, %rdx movq %r14, %rcx movq %rax, %r8 callq 0x1a5830 movl 0x1c(%rsp), %ebp movq 0x20(%rsp), %rdi leaq 0x30(%rsp), %rax cmpq %rax, %rdi je 0x4ad291 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 incl %r12d cmpl %r12d, %ebp jne 0x4ad13b jmp 0x4ad2d6 movq %rbx, %rdi movl %r12d, %esi callq 0x499f12 movb %al, 0xe(%rsp) jmp 0x4ad275 movq %rbx, %rdi movl %r12d, %esi callq 0x499f12 movb %al, 0xd(%rsp) jmp 0x4ad275 movq %rbx, %rdi movl %r12d, %esi leaq 0x80(%rsp), %rdx callq 0x49b700 jmp 0x4ad275 andb $0x1, 0xe(%rsp) andb $0x1, 0xd(%rsp) leaq 0x70(%rsp), %r12 leaq 0x50(%rsp), %r13 jmp 0x4ad2f6 movb $0x1, 0xd(%rsp) movb $0x1, 0xe(%rsp) cmpq $0x0, 0x68(%rsp) je 0x4ad36d movq %rbx, %rdi callq 0x4997b6 cmpq $0x0, 0x48(%rsp) je 0x4ad316 movq %rbx, %rdi callq 0x4989dc leaq 0x60(%rsp), %rsi leaq 0x10(%rsp), %rcx movq %rbx, %rdi movl $0x27, %edx callq 0x498494 testb %al, %al jne 0x4ad33e leaq 0x60(%rsp), %rsi movq %rbx, %rdi callq 0x4994f4 movq 0x90(%rbx), %rbx movl $0x18, %edi callq 0x1a5230 leaq 0x38(%rbx), %rsi movq 0x10(%rsp), %rcx movq %rcx, 0x10(%rax) movq %rax, %rdi callq 0x1a5360 addq $0x48, %rbx jmp 0x4ad4d6 movl $0x78, %edi callq 0x1a5230 movq %rax, %r15 movq %rax, %r14 movq 0x90(%rbx), %rax movl $0x27, 0x8(%r15) leaq 0x20(%r15), %rcx movq %rcx, 0x10(%r15) xorl %ecx, %ecx movq %rcx, 0x18(%r15) movb %cl, 0x20(%r15) movq %rax, 0x30(%r15) leaq 0x38(%r15), %rax movq %rax, 0x40(%r15) movq %rax, 0x38(%r15) movq %rcx, 0x48(%r15) leaq 0x2f255f(%rip), %rax # 0x79f918 movq %rax, (%r15) leaq 0x68(%r15), %rax movq %rax, 0x58(%r15) movq %rcx, 0x60(%r15) movb %cl, 0x68(%r15) movq %r15, 0x10(%rsp) cmpq %rcx, 0x48(%rsp) je 0x4ad3e6 leaq 0x10(%r15), %rdi leaq 0x40(%rsp), %rsi callq 0x1a64a0 addq $0x58, %r15 movb 0xe(%rsp), %al movb %al, 0x50(%r14) movb 0xd(%rsp), %al movb %al, 0x51(%r14) movq 0x80(%rsp), %rsi leaq 0x80(%rsp), %rax cmpq %rax, %rsi je 0x4ad41d addq $0x10, %rsi movq %r15, %rdi callq 0x1a64a0 jmp 0x4ad435 movq 0x60(%r14), %rdx leaq 0xfb719(%rip), %rcx # 0x5a8b41 movq %r15, %rdi xorl %esi, %esi xorl %r8d, %r8d callq 0x1a5830 movq 0x98(%rbx), %rdi movq (%rdi), %rax callq *0x78(%rax) testb %al, %al je 0x4ad46d movq 0x90(%rbx), %r15 movl $0x18, %edi callq 0x1a5230 leaq 0x38(%r15), %rsi movq %r14, 0x10(%rax) movq %rax, %rdi callq 0x1a5360 incq 0x48(%r15) jmp 0x4ad4b5 leaq 0x30(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x9e148(%rip), %rsi # 0x54b5c5 leaq 0x9e14d(%rip), %rdx # 0x54b5d1 leaq 0x20(%rsp), %rdi callq 0x209290 leaq 0x20(%rsp), %rdx movq %rbx, %rdi movq %r14, %rsi callq 0x4a7412 movq 0x20(%rsp), %rdi cmpq %r15, %rdi je 0x4ad4b5 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movl $0x18, %edi callq 0x1a5230 leaq 0x78(%rbx), %rsi movq %r14, 0x10(%rax) movq %rax, %rdi callq 0x1a5360 addq $0x88, %rbx incq (%rbx) leaq 0x80(%rsp), %rdi callq 0x260d00 movq 0x40(%rsp), %rdi cmpq %r13, %rdi je 0x4ad4fd movq 0x50(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x60(%rsp), %rdi cmpq %r12, %rdi je 0x4ad514 movq 0x70(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x98, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq 0x20(%rsp), %rdi cmpq %r15, %rdi jne 0x4ad554 jmp 0x4ad561 jmp 0x4ad53d jmp 0x4ad53d jmp 0x4ad53d jmp 0x4ad53d movq %rax, %rbx jmp 0x4ad561 movq %rax, %rbx movq 0x20(%rsp), %rdi leaq 0x30(%rsp), %rax cmpq %rax, %rdi je 0x4ad561 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x80(%rsp), %rdi callq 0x260d00 movq 0x40(%rsp), %rdi leaq 0x50(%rsp), %rax cmpq %rax, %rdi je 0x4ad58a movq 0x50(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x60(%rsp), %rdi leaq 0x70(%rsp), %rax cmpq %rax, %rdi je 0x4ad5a6 movq 0x70(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Texturing.cpp
Assimp::FIShortValue::create(std::vector<short, std::allocator<short>>&&)
std::shared_ptr<FIShortValue> FIShortValue::create(std::vector<int16_t> &&value) { return std::make_shared<FIShortValueImpl>(std::move(value)); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movl $0x58, %edi callq 0x1a5230 movq %rax, %r15 movabsq $0x100000001, %rax # imm = 0x100000001 movq %rax, 0x8(%r15) leaq 0x2f1e16(%rip), %rax # 0x7a0168 movq %rax, (%r15) leaq 0x10(%r15), %r12 leaq 0x18(%r15), %rdi xorps %xmm0, %xmm0 movups %xmm0, 0x18(%r15) xorl %eax, %eax movq %rax, 0x28(%r15) leaq 0x2f1e46(%rip), %rcx # 0x7a01b8 movq %rcx, 0x10(%r15) leaq 0x40(%r15), %rcx movq %rcx, 0x30(%r15) movq %rax, 0x38(%r15) movb %al, 0x40(%r15) movb %al, 0x50(%r15) movq %r14, %rsi callq 0x4b6cce movq %r12, (%rbx) movq %r15, 0x8(%rbx) movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FIDoubleValue::create(std::vector<double, std::allocator<double>>&&)
std::shared_ptr<FIDoubleValue> FIDoubleValue::create(std::vector<double> &&value) { return std::make_shared<FIDoubleValueImpl>(std::move(value)); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movl $0x58, %edi callq 0x1a5230 movq %rax, %r15 movabsq $0x100000001, %rax # imm = 0x100000001 movq %rax, 0x8(%r15) leaq 0x2f1f88(%rip), %rax # 0x7a0530 movq %rax, (%r15) leaq 0x10(%r15), %r12 leaq 0x18(%r15), %rdi xorps %xmm0, %xmm0 movups %xmm0, 0x18(%r15) xorl %eax, %eax movq %rax, 0x28(%r15) leaq 0x2f1fb8(%rip), %rcx # 0x7a0580 movq %rcx, 0x10(%r15) leaq 0x40(%r15), %rcx movq %rcx, 0x30(%r15) movq %rax, 0x38(%r15) movb %al, 0x40(%r15) movb %al, 0x50(%r15) movq %r14, %rsi callq 0x4b7ab8 movq %r12, (%rbx) movq %r15, 0x8(%rbx) movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FICDATAValue::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
std::shared_ptr<FICDATAValue> FICDATAValue::create(std::string &&value) { return std::make_shared<FICDATAValueImpl>(std::move(value)); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movl $0x38, %edi callq 0x1a5230 movq %rax, %r15 movabsq $0x100000001, %rax # imm = 0x100000001 movq %rax, 0x8(%r15) leaq 0x2f1fdc(%rip), %rax # 0x7a0690 movq %rax, (%r15) leaq 0x10(%r15), %r12 leaq 0x18(%r15), %rdi leaq 0x28(%r15), %rax movq %rax, 0x18(%r15) movq $0x0, 0x20(%r15) movb $0x0, 0x28(%r15) leaq 0x2f2005(%rip), %rax # 0x7a06e0 movq %rax, 0x10(%r15) movq %rbx, %rsi callq 0x1a58d0 movq %r12, (%r14) movq %r15, 0x8(%r14) movq %r14, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FIBase64Decoder::decode(unsigned char const*, unsigned long)
virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ { return FIBase64Value::create(std::vector<uint8_t>(data, data + len)); }
pushq %r14 pushq %rbx subq $0x38, %rsp movq %rdi, %rbx leaq (%rcx,%rdx), %rax leaq 0x8(%rsp), %r14 leaq 0x7(%rsp), %rcx movq %r14, %rdi movq %rdx, %rsi movq %rax, %rdx callq 0x4b7f06 leaq 0x20(%rsp), %rdi movq %r14, %rsi callq 0x4ae29c movaps 0x20(%rsp), %xmm0 movups %xmm0, (%rbx) movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x4aecd2 movq 0x18(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rax addq $0x38, %rsp popq %rbx popq %r14 retq movq %rax, %rbx movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x4aecf7 movq 0x18(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FIShortDecoder::decode(unsigned char const*, unsigned long)
virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ { if (len & 1) { throw DeadlyImportError(parseErrorMessage); } std::vector<int16_t> value; size_t numShorts = len / 2; value.reserve(numShorts); for (size_t i = 0; i < numShorts; ++i) { int16_t v = (data[0] << 8) | data[1]; value.push_back(v); data += 2; } return FIShortValue::create(std::move(value)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rcx, %r12 testb $0x1, %r12b jne 0x4aedce movq %rdx, %r14 movq %rdi, %rbx xorps %xmm0, %xmm0 movq %rsp, %rdi movaps %xmm0, (%rdi) movq $0x0, 0x10(%rdi) movq %r12, %r15 shrq %r15 movq %r15, %rsi callq 0x4b3f58 testq %r12, %r12 je 0x4aed91 xorl %ebp, %ebp movq %rsp, %r12 leaq 0x20(%rsp), %r13 movzwl (%r14,%rbp,2), %eax rolw $0x8, %ax movw %ax, 0x20(%rsp) movq 0x8(%rsp), %rsi cmpq 0x10(%rsp), %rsi je 0x4aed7e movw %ax, (%rsi) addq $0x2, 0x8(%rsp) jmp 0x4aed89 movq %r12, %rdi movq %r13, %rdx callq 0x4b40b2 incq %rbp cmpq %rbp, %r15 jne 0x4aed59 leaq 0x20(%rsp), %rdi movq %rsp, %rsi callq 0x4ae322 movaps 0x20(%rsp), %xmm0 movups %xmm0, (%rbx) movq (%rsp), %rdi testq %rdi, %rdi je 0x4aedbc movq 0x10(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rax addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x32d2e6(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x49643a leaq 0x22e91f(%rip), %rsi # 0x6dd710 movq 0x2fd168(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 jmp 0x4aee2a jmp 0x4aee11 jmp 0x4aee11 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x4aee2a movq 0x10(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FIDoubleDecoder::decode(unsigned char const*, unsigned long)
virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ { if (len & 7) { throw DeadlyImportError(parseErrorMessage); } std::vector<double> value; size_t numDoubles = len / 8; value.reserve(numDoubles); for (size_t i = 0; i < numDoubles; ++i) { long long b0 = data[0], b1 = data[1], b2 = data[2], b3 = data[3], b4 = data[4], b5 = data[5], b6 = data[6], b7 = data[7]; long long v = (b0 << 56) | (b1 << 48) | (b2 << 40) | (b3 << 32) | (b4 << 24) | (b5 << 16) | (b6 << 8) | b7; double f; memcpy(&f, &v, 8); value.push_back(f); data += 8; } return FIDoubleValue::create(std::move(value)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rcx, %r12 testb $0x7, %r12b jne 0x4af3c9 movq %rdx, %r14 movq %rdi, %rbx xorps %xmm0, %xmm0 movq %rsp, %rdi movaps %xmm0, (%rdi) movq $0x0, 0x10(%rdi) movq %r12, %r15 shrq $0x3, %r15 movq %r15, %rsi callq 0x419924 testq %r12, %r12 je 0x4af38c xorl %ebp, %ebp movq %rsp, %r12 leaq 0x20(%rsp), %r13 movq (%r14,%rbp,8), %rax bswapq %rax movq %rax, 0x20(%rsp) movq 0x8(%rsp), %rsi cmpq 0x10(%rsp), %rsi je 0x4af379 movq %rax, (%rsi) addq $0x8, 0x8(%rsp) jmp 0x4af384 movq %r12, %rdi movq %r13, %rdx callq 0x4b7fe0 incq %rbp cmpq %rbp, %r15 jne 0x4af356 leaq 0x20(%rsp), %rdi movq %rsp, %rsi callq 0x4ae578 movaps 0x20(%rsp), %xmm0 movups %xmm0, (%rbx) movq (%rsp), %rdi testq %rdi, %rdi je 0x4af3b7 movq 0x10(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rax addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x32cceb(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x49643a leaq 0x22e324(%rip), %rsi # 0x6dd710 movq 0x2fcb6d(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 jmp 0x4af425 jmp 0x4af40c jmp 0x4af40c movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x4af425 movq 0x10(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::CFIReaderImpl::parseElement()
void parseElement() { // C.3 attributes.clear(); uint8_t b = *dataP; bool hasAttributes = (b & 0x40) != 0; // C.3.3 if ((b & 0x3f) == 0x38) { // C.3.4.1 // Parse namespaces ++dataP; for (;;) { if (dataEnd - dataP < 1) { throw DeadlyImportError(parseErrorMessage); } b = *dataP++; if (b == 0xf0) { // C.3.4.3 break; } if ((b & 0xfc) != 0xcc) { // C.3.4.2 throw DeadlyImportError(parseErrorMessage); } // C.12 Attribute attr; attr.qname.prefix = "xmlns"; attr.qname.name = b & 0x02 ? parseIdentifyingStringOrIndex(vocabulary.prefixTable) : std::string(); attr.qname.uri = b & 0x01 ? parseIdentifyingStringOrIndex(vocabulary.namespaceNameTable) : std::string(); attr.name = attr.qname.name.empty() ? "xmlns" : "xmlns:" + attr.qname.name; attr.value = FIStringValue::create(std::string(attr.qname.uri)); attributes.push_back(attr); } if ((dataEnd - dataP < 1) || (*dataP & 0xc0)) { throw DeadlyImportError(parseErrorMessage); } } // Parse Element name (C.3.5) const QName &elemName = parseQualifiedNameOrIndex3(vocabulary.elementNameTable); nodeName = elemName.prefix.empty() ? elemName.name : elemName.prefix + ':' + elemName.name; if (hasAttributes) { for (;;) { if (dataEnd - dataP < 1) { throw DeadlyImportError(parseErrorMessage); } b = *dataP; if (b < 0x80) { // C.3.6.1 // C.4 Attribute attr; attr.qname = parseQualifiedNameOrIndex2(vocabulary.attributeNameTable); attr.name = attr.qname.prefix.empty() ? attr.qname.name : attr.qname.prefix + ':' + attr.qname.name; if (dataEnd - dataP < 1) { throw DeadlyImportError(parseErrorMessage); } attr.value = parseNonIdentifyingStringOrIndex1(vocabulary.attributeValueTable); attributes.push_back(attr); } else { if ((b & 0xf0) != 0xf0) { // C.3.6.2 throw DeadlyImportError(parseErrorMessage); } emptyElement = b == 0xff; // C.3.6.2, C.3.8 ++dataP; break; } } } else { if (dataEnd - dataP < 1) { throw DeadlyImportError(parseErrorMessage); } b = *dataP; switch (b) { case 0xff: terminatorPending = true; // Intentionally fall through case 0xf0: emptyElement = true; ++dataP; break; default: emptyElement = false; } } if (!emptyElement) { elementStack.push(nodeName); } currentNodeType = irr::io::EXN_ELEMENT; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x118, %rsp # imm = 0x118 movq %rdi, %rbx addq $0x148, %rdi # imm = 0x148 movq 0x148(%rbx), %rsi movq %rdi, 0x110(%rsp) callq 0x4b4c38 movq 0x10(%rbx), %rdx movzbl (%rdx), %ebp movl %ebp, %eax andl $0x3f, %eax cmpl $0x38, %eax jne 0x4b1b0b movl %ebp, 0xcc(%rsp) leaq 0x1(%rdx), %rax movq %rax, 0x10(%rbx) movq 0x18(%rbx), %rcx movq %rcx, %rsi subq %rax, %rsi testq %rsi, %rsi jle 0x4b2049 leaq 0x2(%rdx), %rsi movq %rsi, 0x10(%rbx) movb 0x1(%rdx), %r14b cmpb $-0x10, %r14b je 0x4b1aec leaq 0x30(%rsp), %r12 leaq 0x50(%rsp), %r15 leaq 0x70(%rsp), %rbp leaq 0x58(%rbx), %rax movq %rax, 0xb8(%rsp) leaq 0x10(%rsp), %r13 leaq 0x70(%rbx), %rax movq %rax, 0xb0(%rsp) movzbl %r14b, %eax andl $-0x4, %eax cmpl $0xcc, %eax jne 0x4b2067 movq %r12, 0x20(%rsp) xorl %ecx, %ecx movq %rcx, 0x28(%rsp) movb %cl, 0x30(%rsp) movq %r15, 0x40(%rsp) movq %rcx, 0x48(%rsp) movb %cl, 0x50(%rsp) movq %rbp, 0x60(%rsp) movq %rcx, 0x68(%rsp) movb %cl, 0x70(%rsp) leaq 0x90(%rsp), %rax movq %rax, 0x80(%rsp) movq %rcx, 0x88(%rsp) movb %cl, 0x90(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x70(%r12) movl $0x5, %r8d leaq 0x20(%rsp), %rdi xorl %esi, %esi xorl %edx, %edx leaq 0x11fd0d(%rip), %rcx # 0x5d1557 callq 0x1a5830 testb $0x2, %r14b jne 0x4b1869 movq %r13, (%rsp) movq $0x0, 0x8(%rsp) movb $0x0, 0x10(%rsp) jmp 0x4b188f movq %rbx, %rdi movq 0xb8(%rsp), %rsi callq 0x4b22c0 movq %r13, (%rsp) movq (%rax), %rsi movq 0x8(%rax), %rdx addq %rsi, %rdx movq %rsp, %rdi callq 0x20ac60 leaq 0x60(%rsp), %rdi movq %rsp, %rsi callq 0x1a64a0 movq (%rsp), %rdi cmpq %r13, %rdi je 0x4b18b2 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 testb $0x1, %r14b jne 0x4b18cc movq %r13, (%rsp) movq $0x0, 0x8(%rsp) movb $0x0, 0x10(%rsp) jmp 0x4b18f2 movq %rbx, %rdi movq 0xb0(%rsp), %rsi callq 0x4b22c0 movq %r13, (%rsp) movq (%rax), %rsi movq 0x8(%rax), %rdx addq %rsi, %rdx movq %rsp, %rdi callq 0x20ac60 leaq 0x40(%rsp), %rdi movq %rsp, %rsi callq 0x1a64a0 movq (%rsp), %rdi cmpq %r13, %rdi je 0x4b1915 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 cmpq $0x0, 0x68(%rsp) je 0x4b1936 movq %rsp, %r14 movq %r14, %rdi leaq 0x11fc33(%rip), %rsi # 0x5d155d leaq 0x60(%rsp), %rdx callq 0x23ca59 jmp 0x4b1953 movq %r13, (%rsp) movq %rsp, %r14 movq %r14, %rdi leaq 0x11fc10(%rip), %rsi # 0x5d1557 leaq 0x11fc0e(%rip), %rdx # 0x5d155c callq 0x209290 leaq 0x80(%rsp), %rdi movq %r14, %rsi callq 0x1a58d0 movq (%rsp), %rdi cmpq %r13, %rdi je 0x4b1979 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq %r13, (%rsp) movq 0x40(%rsp), %rsi movq 0x48(%rsp), %rdx addq %rsi, %rdx movq %rsp, %rdi callq 0x20ac60 movl $0x38, %edi callq 0x1a5230 movq %rax, %r14 movabsq $0x100000001, %rax # imm = 0x100000001 movq %rax, 0x8(%r14) leaq 0x2ee554(%rip), %rax # 0x79ff08 movq %rax, (%r14) leaq 0x10(%r14), %rax movq %rax, 0xc0(%rsp) leaq 0x18(%r14), %rdi movq %r14, %rax addq $0x28, %rax movq %rax, 0x18(%r14) movq $0x0, 0x20(%r14) movb $0x0, 0x28(%r14) leaq 0x2ee572(%rip), %rax # 0x79ff58 movq %rax, 0x10(%r14) movq %rsp, %rsi callq 0x1a58d0 movq 0xc0(%rsp), %rax movq %rax, 0xa0(%rsp) movq 0xa8(%rsp), %rdi movq %r14, 0xa8(%rsp) testq %rdi, %rdi je 0x4b1a1c callq 0x280464 movq (%rsp), %rdi cmpq %r13, %rdi je 0x4b1a32 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x110(%rsp), %rdi leaq 0x20(%rsp), %rsi callq 0x4b46f2 movq 0xa8(%rsp), %rdi testq %rdi, %rdi je 0x4b1a56 callq 0x280464 movq 0x80(%rsp), %rdi leaq 0x90(%rsp), %rax cmpq %rax, %rdi je 0x4b1a7b movq 0x90(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x60(%rsp), %rdi cmpq %rbp, %rdi je 0x4b1a92 movq 0x70(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x40(%rsp), %rdi cmpq %r15, %rdi je 0x4b1aa9 movq 0x50(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x20(%rsp), %rdi cmpq %r12, %rdi je 0x4b1ac0 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x10(%rbx), %rax movq 0x18(%rbx), %rcx movq %rcx, %rdx subq %rax, %rdx testq %rdx, %rdx jle 0x4b2049 leaq 0x1(%rax), %rdx movq %rdx, 0x10(%rbx) movb (%rax), %r14b cmpb $-0x10, %r14b jne 0x4b17ce incq %rax subq %rax, %rcx testq %rcx, %rcx movl 0xcc(%rsp), %ebp jle 0x4b2099 cmpb $0x40, (%rax) jae 0x4b2099 leaq 0x118(%rbx), %rsi movq %rbx, %rdi callq 0x4b4722 movq %rax, %r14 movq 0x8(%rax), %r12 testq %r12, %r12 je 0x4b1b91 leaq 0x10(%rsp), %r13 movq %r13, -0x10(%r13) movq (%r14), %rsi leaq (%rsi,%r12), %rdx movq %rsp, %r15 movq %r15, %rdi callq 0x20ac60 movq 0x8(%r15), %rsi movl $0x1, %ecx movq %r15, %rdi xorl %edx, %edx movl $0x3a, %r8d callq 0x1a59a0 movq 0x40(%r14), %rsi movq 0x48(%r14), %rdx movq %rsp, %rdi callq 0x1a5d30 leaq 0x30(%rsp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rsi je 0x4b1bb1 movq %rsi, 0x20(%rsp) movq (%rcx), %rdx movq %rdx, 0x30(%rsp) jmp 0x4b1bb7 leaq 0x30(%rsp), %rax movq %rax, -0x10(%rax) movq 0x40(%r14), %rsi movq 0x48(%r14), %rdx addq %rsi, %rdx leaq 0x20(%rsp), %rdi callq 0x20ac60 jmp 0x4b1bcf movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq 0x8(%rax), %rdx movq %rdx, 0x28(%rsp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x1b0(%rbx), %r14 leaq 0x20(%rsp), %rsi movq %r14, %rdi callq 0x1a64a0 leaq 0x30(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4b1bfe movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 testq %r12, %r12 je 0x4b1c1e leaq 0x10(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4b1c1e movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x10(%rbx), %rax movq 0x18(%rbx), %rcx subq %rax, %rcx testb $0x40, %bpl jne 0x4b1c63 testq %rcx, %rcx jle 0x4b20b7 movzbl (%rax), %ecx cmpl $0xf0, %ecx je 0x4b1c53 cmpl $0xff, %ecx jne 0x4b1fe1 movb $0x1, 0x26(%rbx) movb $0x1, 0x24(%rbx) incq %rax movq %rax, 0x10(%rbx) jmp 0x4b1ff4 movq %r14, 0xb0(%rsp) testq %rcx, %rcx jle 0x4b1f9d leaq 0x50(%rsp), %r12 leaq 0x130(%rbx), %rcx movq %rcx, 0xc0(%rsp) leaq 0x100(%rsp), %r15 leaq 0xd0(%rbx), %rcx movq %rcx, 0xb8(%rsp) leaq 0xf0(%rsp), %r13 movb (%rax), %cl testb %cl, %cl js 0x4b1fbe leaq 0x30(%rsp), %rax movq %rax, 0x20(%rsp) xorl %ecx, %ecx movq %rcx, 0x28(%rsp) movb %cl, 0x30(%rsp) movq %r12, %r14 movq %r12, 0x40(%rsp) movq %rcx, 0x48(%rsp) movb %cl, 0x50(%rsp) leaq 0x70(%rsp), %rax movq %rax, 0x60(%rsp) movq %rcx, 0x68(%rsp) movb %cl, 0x70(%rsp) leaq 0x90(%rsp), %rax movq %rax, 0x80(%rsp) movq %rcx, 0x88(%rsp) movb %cl, 0x90(%rsp) leaq 0x40(%rsp), %rax xorps %xmm0, %xmm0 movups %xmm0, 0x60(%rax) movq %rbx, %rdi movq 0xc0(%rsp), %rsi callq 0x4b49ac movq %rax, %r12 leaq 0x20(%rsp), %rdi movq %rax, %rsi callq 0x1a64a0 leaq 0x20(%r12), %rsi leaq 0x40(%rsp), %rdi callq 0x1a64a0 addq $0x40, %r12 leaq 0x60(%rsp), %rdi movq %r12, %rsi callq 0x1a64a0 movq 0x28(%rsp), %r12 testq %r12, %r12 je 0x4b1df0 movq %rbx, %rbp movq %r15, %rbx leaq 0xe0(%rsp), %rax movq %rax, 0xd0(%rsp) movq 0x20(%rsp), %rsi leaq (%rsi,%r12), %rdx leaq 0xd0(%rsp), %r15 movq %r15, %rdi callq 0x20ac60 movq 0xd8(%rsp), %rsi movl $0x1, %ecx movq %r15, %rdi xorl %edx, %edx movl $0x3a, %r8d callq 0x1a59a0 movq 0x60(%rsp), %rsi movq 0x68(%rsp), %rdx movq %r15, %rdi callq 0x1a5d30 movq %rbx, %r15 movq %rbx, 0xf0(%rsp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x4b1e0f movq %rdx, 0xf0(%rsp) movq (%rcx), %rdx movq %rdx, 0x100(%rsp) jmp 0x4b1e16 movq %r15, 0xf0(%rsp) movq 0x60(%rsp), %rsi movq 0x68(%rsp), %rdx addq %rsi, %rdx movq %r13, %rdi callq 0x20ac60 jmp 0x4b1e34 movups (%rcx), %xmm0 movups %xmm0, (%r15) movq %rbp, %rbx movq 0x8(%rax), %rdx movq %rdx, 0xf8(%rsp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x80(%rsp), %rdi movq %r13, %rsi callq 0x1a58d0 movq 0xf0(%rsp), %rdi cmpq %r15, %rdi je 0x4b1e61 movq 0x100(%rsp), %rsi incq %rsi callq 0x1a5190 testq %r12, %r12 je 0x4b1e8b movq 0xd0(%rsp), %rdi leaq 0xe0(%rsp), %rax cmpq %rax, %rdi je 0x4b1e8b movq 0xe0(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x18(%rbx), %rax subq 0x10(%rbx), %rax testq %rax, %rax jle 0x4b200d movq %r13, %rdi movq %rbx, %rsi movq 0xb8(%rsp), %rdx callq 0x4b23d2 movaps 0xf0(%rsp), %xmm0 xorps %xmm1, %xmm1 movaps %xmm1, 0xf0(%rsp) movq 0xa8(%rsp), %rdi movups %xmm0, 0xa0(%rsp) testq %rdi, %rdi je 0x4b1eee callq 0x280464 movq 0xf8(%rsp), %rdi testq %rdi, %rdi je 0x4b1eee callq 0x280464 movq 0x110(%rsp), %rdi leaq 0x20(%rsp), %rsi callq 0x4b46f2 movq 0xa8(%rsp), %rdi testq %rdi, %rdi je 0x4b1f12 callq 0x280464 movq 0x80(%rsp), %rdi leaq 0x90(%rsp), %rax cmpq %rax, %rdi movq %r14, %r12 je 0x4b1f3a movq 0x90(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x60(%rsp), %rdi leaq 0x70(%rsp), %rax cmpq %rax, %rdi je 0x4b1f56 movq 0x70(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x40(%rsp), %rdi cmpq %r12, %rdi je 0x4b1f6d movq 0x50(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x20(%rsp), %rdi leaq 0x30(%rsp), %rax cmpq %rax, %rdi je 0x4b1f89 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x10(%rbx), %rax movq 0x18(%rbx), %rcx subq %rax, %rcx testq %rcx, %rcx jg 0x4b1ca7 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x32a117(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x49643a jmp 0x4b2083 cmpb $-0x11, %cl jbe 0x4b20d5 incq %rax cmpb $-0x1, %cl sete 0x24(%rbx) movq %rax, 0x10(%rbx) movq 0xb0(%rsp), %r14 jne 0x4b1fe5 jmp 0x4b1ff4 movb $0x0, 0x24(%rbx) leaq 0x160(%rbx), %rdi movq %r14, %rsi callq 0x4b5874 movl $0x1, 0x20(%rbx) addq $0x118, %rsp # imm = 0x118 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x32a0a7(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x1a53e0 leaq 0x22b708(%rip), %rax # 0x6dd738 movq %rax, (%r14) leaq 0x22b6d6(%rip), %rsi # 0x6dd710 movq 0x2f9f1f(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x32a06b(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x49643a jmp 0x4b2083 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x32a04d(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x49643a leaq 0x22b686(%rip), %rsi # 0x6dd710 movq 0x2f9ecf(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x32a01b(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x49643a jmp 0x4b2083 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x329ffd(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x49643a jmp 0x4b2083 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x329fdf(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x49643a jmp 0x4b2083 jmp 0x4b2173 jmp 0x4b2173 jmp 0x4b2173 movq %rax, %rbx jmp 0x4b2136 movq %rax, %rbx movq (%rsp), %rdi cmpq %r13, %rdi jne 0x4b2148 jmp 0x4b21dc movq %rax, %rbx leaq 0x30(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4b212d movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 testq %r12, %r12 je 0x4b21dc leaq 0x10(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4b21dc movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x4b21dc jmp 0x4b21cf jmp 0x4b2173 jmp 0x4b2173 jmp 0x4b21cf jmp 0x4b21cf jmp 0x4b21cf movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 jmp 0x4b21d2 movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 jmp 0x4b21dc jmp 0x4b21cf jmp 0x4b218a jmp 0x4b21cf jmp 0x4b218a jmp 0x4b21cf movq %rax, %rbx movq (%rsp), %rdi cmpq %r13, %rdi je 0x4b21d2 movq 0x10(%rsp), %rsi jmp 0x4b21bf jmp 0x4b219f movq %rax, %rbx movq 0xd0(%rsp), %rdi leaq 0xe0(%rsp), %rax cmpq %rax, %rdi je 0x4b21d2 movq 0xe0(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x4b21d2 jmp 0x4b21cf jmp 0x4b21cf jmp 0x4b21cf movq %rax, %rbx leaq 0x20(%rsp), %rdi callq 0x4b04e8 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::CFIReaderImpl::parseSequenceLen()
size_t parseSequenceLen() { // C.21 if (dataEnd - dataP > 0) { uint8_t b = *dataP++; if (b < 0x80) { // 0....... (C.21.2) return b; } else if ((b & 0xf0) == 0x80) { // 1000.... ........ ........ (C.21.3) if (dataEnd - dataP > 1) { size_t result = (((b & 0x0f) << 16) | (dataP[0] << 8) | dataP[1]) + 0x80; dataP += 2; return result; } } } throw DeadlyImportError(parseErrorMessage); }
pushq %r14 pushq %rbx pushq %rax movq 0x10(%rdi), %rcx movq 0x18(%rdi), %rdx movq %rdx, %rax subq %rcx, %rax testq %rax, %rax jle 0x4b253a leaq 0x1(%rcx), %rsi movq %rsi, 0x10(%rdi) movzbl (%rcx), %eax testb %al, %al js 0x4b24f6 movl %eax, %eax jmp 0x4b2532 movl %eax, %r8d andl $-0x10, %r8d cmpl $0x80, %r8d jne 0x4b253a subq %rsi, %rdx cmpq $0x2, %rdx jl 0x4b253a andl $0xf, %eax shll $0x10, %eax movzbl 0x1(%rcx), %edx shll $0x8, %edx movzbl 0x2(%rcx), %esi orl %eax, %esi leal (%rdx,%rsi), %eax addl $0x80, %eax addq $0x3, %rcx movq %rcx, 0x10(%rdi) addq $0x8, %rsp popq %rbx popq %r14 retq movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x329b7a(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x49643a leaq 0x22b1b3(%rip), %rsi # 0x6dd710 movq 0x2f99fc(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::CFIReaderImpl::parseNameSurrogate()
QName parseNameSurrogate() { // C.16 if (dataEnd - dataP < 1) { throw DeadlyImportError(parseErrorMessage); } uint8_t b = *dataP++; if (b & 0xfc) { // Padding '000000' C.2.5.5 throw DeadlyImportError(parseErrorMessage); } QName result; size_t index; if (b & 0x02) { // prefix (C.16.3) if ((dataEnd - dataP < 1) || (*dataP & 0x80)) { throw DeadlyImportError(parseErrorMessage); } index = parseInt2(); if (index >= vocabulary.prefixTable.size()) { throw DeadlyImportError(parseErrorMessage); } result.prefix = vocabulary.prefixTable[index]; } if (b & 0x01) { // namespace-name (C.16.4) if ((dataEnd - dataP < 1) || (*dataP & 0x80)) { throw DeadlyImportError(parseErrorMessage); } index = parseInt2(); if (index >= vocabulary.namespaceNameTable.size()) { throw DeadlyImportError(parseErrorMessage); } result.uri = vocabulary.namespaceNameTable[index]; } // local-name if ((dataEnd - dataP < 1) || (*dataP & 0x80)) { throw DeadlyImportError(parseErrorMessage); } index = parseInt2(); if (index >= vocabulary.localNameTable.size()) { throw DeadlyImportError(parseErrorMessage); } result.name = vocabulary.localNameTable[index]; return result; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq 0x10(%rsi), %rdx movq 0x18(%rsi), %rcx movq %rcx, %rax subq %rdx, %rax testq %rax, %rax jle 0x4b2b04 movq %rsi, %r14 leaq 0x1(%rdx), %rax movq %rax, 0x10(%rsi) movb (%rdx), %bpl cmpb $0x4, %bpl jae 0x4b2b22 movq %rdi, %rbx leaq 0x10(%rdi), %rdx movq %rdx, (%rdi) xorl %edx, %edx movq %rdx, 0x8(%rdi) movb %dl, 0x10(%rdi) leaq 0x30(%rdi), %rsi movq %rsi, 0x20(%rdi) movq %rdx, 0x28(%rdi) movb %dl, 0x30(%rdi) leaq 0x50(%rdi), %rsi movq %rsi, 0x40(%rdi) movq %rdx, 0x48(%rdi) movb %dl, 0x50(%rdi) cmpb $0x2, %bpl jb 0x4b2a3f subq %rax, %rcx testq %rcx, %rcx jle 0x4b2b54 cmpb $0x0, (%rax) js 0x4b2b54 movq %r14, %rdi callq 0x4b4592 movq 0x58(%r14), %rsi movq 0x60(%r14), %rcx subq %rsi, %rcx sarq $0x5, %rcx cmpq %rcx, %rax jae 0x4b2bae shlq $0x5, %rax addq %rax, %rsi movq %rbx, %rdi callq 0x1a64a0 movq 0x10(%r14), %rax movq 0x18(%r14), %rcx testb $0x1, %bpl je 0x4b2a92 subq %rax, %rcx testq %rcx, %rcx jle 0x4b2b72 cmpb $0x0, (%rax) js 0x4b2b72 movq %r14, %rdi callq 0x4b4592 movq 0x70(%r14), %rsi movq 0x78(%r14), %rcx subq %rsi, %rcx sarq $0x5, %rcx cmpq %rcx, %rax jae 0x4b2bcc leaq 0x20(%rbx), %rdi shlq $0x5, %rax addq %rax, %rsi callq 0x1a64a0 movq 0x10(%r14), %rax movq 0x18(%r14), %rcx subq %rax, %rcx testq %rcx, %rcx jle 0x4b2ae3 cmpb $0x0, (%rax) js 0x4b2ae3 movq %r14, %rdi callq 0x4b4592 movq 0x88(%r14), %rsi movq 0x90(%r14), %rcx subq %rsi, %rcx sarq $0x5, %rcx cmpq %rcx, %rax jae 0x4b2b90 leaq 0x40(%rbx), %rdi shlq $0x5, %rax addq %rax, %rsi callq 0x1a64a0 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x3295d1(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x1a53e0 jmp 0x4b2be8 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x3295b0(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x49643a jmp 0x4b2b3e movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x329592(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x49643a leaq 0x22abcb(%rip), %rsi # 0x6dd710 movq 0x2f9414(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x329560(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x1a53e0 jmp 0x4b2be8 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x329542(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x1a53e0 jmp 0x4b2be8 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x329524(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x1a53e0 jmp 0x4b2be8 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x329506(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x1a53e0 jmp 0x4b2be8 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x3294e8(%rip), %rsi # 0x7dc0c8 movq %rax, %rdi callq 0x1a53e0 leaq 0x22ab49(%rip), %rax # 0x6dd738 movq %rax, (%r14) leaq 0x22ab17(%rip), %rsi # 0x6dd710 movq 0x2f9360(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x4b2c21 jmp 0x4b2c21 jmp 0x4b2c21 jmp 0x4b2c21 jmp 0x4b2c21 jmp 0x4b2c14 movq %rax, %r15 movq %rbx, %rdi callq 0x1a6080 jmp 0x4b2c39 movq %rax, %r15 movq %r14, %rdi callq 0x1a6080 jmp 0x4b2c31 movq %rax, %r15 movq %rbx, %rdi callq 0x4b0286 movq %r15, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::CFIReaderImpl::QName::QName(Assimp::FIQName const&)
inline QName(const FIQName &qname): prefix(qname.prefix ? qname.prefix : ""), uri(qname.uri ? qname.uri : ""), name(qname.name) {}
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movq 0x8(%rsi), %r15 testq %r15, %r15 leaq 0xf5b0e(%rip), %rbp # 0x5a8b41 cmoveq %rbp, %r15 leaq 0x10(%rdi), %r13 movq %r13, (%rdi) movq %r15, %rdi callq 0x1a56a0 leaq (%rax,%r15), %rdx movq %rbx, %rdi movq %r15, %rsi callq 0x209290 leaq 0x20(%rbx), %r15 movq 0x10(%r14), %r12 testq %r12, %r12 cmoveq %rbp, %r12 leaq 0x30(%rbx), %rbp movq %rbp, 0x20(%rbx) movq %r12, %rdi callq 0x1a56a0 leaq (%rax,%r12), %rdx movq %r15, %rdi movq %r12, %rsi callq 0x209290 leaq 0x40(%rbx), %rdi movq (%r14), %rsi leaq 0x7(%rsp), %rdx callq 0x23ca1c addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq (%r15), %rdi cmpq %rbp, %rdi je 0x4b30bf movq (%rbp), %rsi incq %rsi callq 0x1a5190 jmp 0x4b30bf movq %rax, %r14 movq (%rbx), %rdi cmpq %r13, %rdi je 0x4b30d3 movq (%r13), %rsi incq %rsi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FIHexValueImpl::toString[abi:cxx11]() const
virtual const std::string &toString() const /*override*/ { if (!strValueValid) { strValueValid = true; std::ostringstream os; os << std::hex << std::uppercase << std::setfill('0'); std::for_each(value.begin(), value.end(), [&](uint8_t c) { os << std::setw(2) << static_cast<int>(c); }); strValue = os.str(); } return strValue; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x198, %rsp # imm = 0x198 movq %rdi, %rbx cmpb $0x0, 0x40(%rdi) jne 0x4b6672 movb $0x1, 0x40(%rbx) leaq 0x20(%rsp), %r14 movq %r14, %rdi callq 0x1a6170 movq (%r14), %rax movq -0x18(%rax), %rax movl 0x38(%rsp,%rax), %ecx andl $-0x4b, %ecx orl $0x8, %ecx movl %ecx, 0x38(%rsp,%rax) movq (%r14), %rax movq -0x18(%rax), %rax orl $0x4000, 0x38(%rsp,%rax) # imm = 0x4000 movq (%r14), %rax movq -0x18(%rax), %rax leaq (%rsp,%rax), %r14 addq $0x20, %r14 cmpb $0x0, 0xe1(%r14) jne 0x4b65de movq %r14, %rdi movl $0x20, %esi callq 0x1a6320 movb $0x1, 0xe1(%r14) movb $0x30, 0xe0(%r14) movq 0x8(%rbx), %r15 movq 0x10(%rbx), %r12 cmpq %r12, %r15 je 0x4b661e leaq 0x20(%rsp), %r14 movzbl (%r15), %esi movq 0x20(%rsp), %rax movq -0x18(%rax), %rax movq $0x2, 0x30(%rsp,%rax) movq %r14, %rdi callq 0x1a5510 incq %r15 cmpq %r12, %r15 jne 0x4b65f8 leaq 0x28(%rsp), %rsi movq %rsp, %rdi callq 0x1a5690 leaq 0x20(%rbx), %rdi movq %rsp, %r14 movq %r14, %rsi callq 0x1a58d0 movq (%r14), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi je 0x4b6654 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x2f5935(%rip), %rsi # 0x7abf90 leaq 0x20(%rsp), %rdi callq 0x1a5d00 leaq 0x90(%rsp), %rdi callq 0x1a5ca0 addq $0x20, %rbx movq %rbx, %rax addq $0x198, %rsp # imm = 0x198 popq %rbx popq %r12 popq %r14 popq %r15 retq jmp 0x4b668c jmp 0x4b668c movq %rax, %rbx movq 0x2f58fa(%rip), %rsi # 0x7abf90 leaq 0x20(%rsp), %rdi callq 0x1a5d00 leaq 0x90(%rsp), %rdi callq 0x1a5ca0 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FIHexValueImpl::~FIHexValueImpl()
inline FIHexValueImpl(std::vector<uint8_t> &&value_): strValueValid(false) { value = std::move(value_); }
pushq %rbx movq %rdi, %rbx leaq 0x2e991f(%rip), %rax # 0x7a0028 movq %rax, (%rdi) movq 0x20(%rdi), %rdi leaq 0x30(%rbx), %rax cmpq %rax, %rdi je 0x4b6724 movq (%rax), %rsi incq %rsi callq 0x1a5190 leaq 0x2e996d(%rip), %rax # 0x7a0098 movq %rax, (%rbx) movq 0x8(%rbx), %rdi testq %rdi, %rdi je 0x4b6743 movq 0x18(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movl $0x48, %esi movq %rbx, %rdi popq %rbx jmp 0x1a5190 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FIShortValueImpl::toString[abi:cxx11]() const
virtual const std::string &toString() const /*override*/ { if (!strValueValid) { strValueValid = true; std::ostringstream os; int n = 0; std::for_each(value.begin(), value.end(), [&](int16_t s) { if (++n > 1) os << ' '; os << s; }); strValue = os.str(); } return strValue; }
pushq %r14 pushq %rbx subq $0x1a8, %rsp # imm = 0x1A8 movq %rdi, %rbx cmpb $0x0, 0x40(%rdi) jne 0x4b6bd1 movb $0x1, 0x40(%rbx) leaq 0x30(%rsp), %r14 movq %r14, %rdi callq 0x1a6170 leaq 0xc(%rsp), %rdx movl $0x0, (%rdx) movq 0x8(%rbx), %rdi movq 0x10(%rbx), %rsi movq %r14, %rcx callq 0x4b6d0d leaq 0x38(%rsp), %rsi leaq 0x10(%rsp), %rdi callq 0x1a5690 leaq 0x20(%rbx), %rdi leaq 0x10(%rsp), %r14 movq %r14, %rsi callq 0x1a58d0 movq (%r14), %rdi leaq 0x20(%rsp), %rax cmpq %rax, %rdi je 0x4b6bb3 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x2f53d6(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 addq $0x20, %rbx movq %rbx, %rax addq $0x1a8, %rsp # imm = 0x1A8 popq %rbx popq %r14 retq jmp 0x4b6be5 movq %rax, %rbx movq 0x2f53a1(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FIIntValueImpl::toString[abi:cxx11]() const
virtual const std::string &toString() const /*override*/ { if (!strValueValid) { strValueValid = true; std::ostringstream os; int n = 0; std::for_each(value.begin(), value.end(), [&](int32_t i) { if (++n > 1) os << ' '; os << i; }); strValue = os.str(); } return strValue; }
pushq %r14 pushq %rbx subq $0x1a8, %rsp # imm = 0x1A8 movq %rdi, %rbx cmpb $0x0, 0x40(%rdi) jne 0x4b6e75 movb $0x1, 0x40(%rbx) leaq 0x30(%rsp), %r14 movq %r14, %rdi callq 0x1a6170 leaq 0xc(%rsp), %rdx movl $0x0, (%rdx) movq 0x8(%rbx), %rdi movq 0x10(%rbx), %rsi movq %r14, %rcx callq 0x4b6fb1 leaq 0x38(%rsp), %rsi leaq 0x10(%rsp), %rdi callq 0x1a5690 leaq 0x20(%rbx), %rdi leaq 0x10(%rsp), %r14 movq %r14, %rsi callq 0x1a58d0 movq (%r14), %rdi leaq 0x20(%rsp), %rax cmpq %rax, %rdi je 0x4b6e57 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x2f5132(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 addq $0x20, %rbx movq %rbx, %rax addq $0x1a8, %rsp # imm = 0x1A8 popq %rbx popq %r14 retq jmp 0x4b6e89 movq %rax, %rbx movq 0x2f50fd(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FIBoolValueImpl::toString[abi:cxx11]() const
virtual const std::string &toString() const /*override*/ { if (!strValueValid) { strValueValid = true; std::ostringstream os; os << std::boolalpha; int n = 0; std::for_each(value.begin(), value.end(), [&](bool b) { if (++n > 1) os << ' '; os << b; }); strValue = os.str(); } return strValue; }
pushq %r14 pushq %rbx subq $0x1a8, %rsp # imm = 0x1A8 movq %rdi, %rbx cmpb $0x0, 0x50(%rdi) jne 0x4b7469 movb $0x1, 0x50(%rbx) leaq 0x30(%rsp), %r14 movq %r14, %rdi callq 0x1a6170 movq (%r14), %rax movq -0x18(%rax), %rax orl $0x1, 0x48(%rsp,%rax) leaq 0xc(%rsp), %r8 movl $0x0, (%r8) movq 0x8(%rbx), %rdi movq 0x18(%rbx), %rdx movl 0x20(%rbx), %ecx xorl %esi, %esi movq %r14, %r9 callq 0x4b755a leaq 0x38(%rsp), %rsi leaq 0x10(%rsp), %rdi callq 0x1a5690 leaq 0x30(%rbx), %rdi leaq 0x10(%rsp), %r14 movq %r14, %rsi callq 0x1a58d0 movq (%r14), %rdi leaq 0x20(%rsp), %rax cmpq %rax, %rdi je 0x4b744b movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x2f4b3e(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 addq $0x30, %rbx movq %rbx, %rax addq $0x1a8, %rsp # imm = 0x1A8 popq %rbx popq %r14 retq jmp 0x4b747d movq %rax, %rbx movq 0x2f4b09(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FIDoubleValueImpl::toString[abi:cxx11]() const
virtual const std::string &toString() const /*override*/ { if (!strValueValid) { strValueValid = true; std::ostringstream os; int n = 0; std::for_each(value.begin(), value.end(), [&](double d) { if (++n > 1) os << ' '; os << d; }); strValue = os.str(); } return strValue; }
pushq %r14 pushq %rbx subq $0x1a8, %rsp # imm = 0x1A8 movq %rdi, %rbx cmpb $0x0, 0x40(%rdi) jne 0x4b79bb movb $0x1, 0x40(%rbx) leaq 0x30(%rsp), %r14 movq %r14, %rdi callq 0x1a6170 leaq 0xc(%rsp), %rdx movl $0x0, (%rdx) movq 0x8(%rbx), %rdi movq 0x10(%rbx), %rsi movq %r14, %rcx callq 0x4b7af7 leaq 0x38(%rsp), %rsi leaq 0x10(%rsp), %rdi callq 0x1a5690 leaq 0x20(%rbx), %rdi leaq 0x10(%rsp), %r14 movq %r14, %rsi callq 0x1a58d0 movq (%r14), %rdi leaq 0x20(%rsp), %rax cmpq %rax, %rdi je 0x4b799d movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x2f45ec(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 addq $0x20, %rbx movq %rbx, %rax addq $0x1a8, %rsp # imm = 0x1A8 popq %rbx popq %r14 retq jmp 0x4b79cf movq %rax, %rbx movq 0x2f45b7(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
Assimp::FIDoubleValueImpl::~FIDoubleValueImpl()
inline FIDoubleValueImpl(std::vector<double> &&value_): strValueValid(false) { value = std::move(value_); }
pushq %rbx movq %rdi, %rbx leaq 0x2e8b35(%rip), %rax # 0x7a0580 movq %rax, (%rdi) movq 0x20(%rdi), %rdi leaq 0x30(%rbx), %rax cmpq %rax, %rdi je 0x4b7a66 movq (%rax), %rsi incq %rsi callq 0x1a5190 leaq 0x2e8b53(%rip), %rax # 0x7a05c0 movq %rax, (%rbx) movq 0x8(%rbx), %rdi testq %rdi, %rdi je 0x4b7a85 movq 0x18(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movl $0x48, %esi movq %rbx, %rdi popq %rbx jmp 0x1a5190 nop
/hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
GenericValue(const std::basic_string<Ch>& s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); }
subq $0x18, %rsp xorps %xmm0, %xmm0 movups %xmm0, (%rdi) movq (%rsi), %rax movl 0x8(%rsi), %ecx testq %rax, %rax setne %sil leaq 0x118d8d(%rip), %r8 # 0x5d7dc1 cmovneq %rax, %r8 movq %r8, 0x8(%rsp) movl %ecx, 0x10(%rsp) testl %ecx, %ecx sete %al orb %sil, %al je 0x4bf05a leaq 0x8(%rsp), %rsi callq 0x4bf0d4 addq $0x18, %rsp retq leaq 0x1151dc(%rip), %rdi # 0x5d423d leaq 0x114953(%rip), %rsi # 0x5d39bb leaq 0x1151e4(%rip), %rcx # 0x5d4253 movl $0x13b, %edx # imm = 0x13B callq 0x1a5270 nop
/hbina[P]fatuous/thirdparty/assimp/code/../contrib/rapidjson/include/rapidjson/document.h
glTF::Buffer::GetURI[abi:cxx11]()
std::string GetURI() { return std::string(this->id) + ".bin"; }
pushq %r15 pushq %r14 pushq %rbx subq $0x20, %rsp movq %rdi, %rbx leaq 0x10(%rsp), %r15 movq %r15, -0x10(%r15) movq 0x8(%rsi), %rax movq 0x10(%rsi), %rdx addq %rax, %rdx movq %rsp, %r14 movq %r14, %rdi movq %rax, %rsi callq 0x20ac60 leaq 0x1138b4(%rip), %rsi # 0x5d42d3 movq %r14, %rdi callq 0x1a5ba0 leaq 0x10(%rbx), %rdx movq %rdx, (%rbx) movq (%rax), %rsi movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rsi je 0x4c0a49 movq %rsi, (%rbx) movq (%rcx), %rdx movq %rdx, 0x10(%rbx) jmp 0x4c0a4f movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq 0x8(%rax), %rdx movq %rdx, 0x8(%rbx) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq (%rsp), %rdi cmpq %r15, %rdi je 0x4c0a7c movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rax addq $0x20, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %rbx movq (%rsp), %rdi cmpq %r15, %rdi je 0x4c0aa2 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/glTF/glTFAsset.h
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<glTF::SamplerMagFilter>, rapidjson::internal::IsGenericValue<glTF::SamplerMagFilter>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>&>::Type rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::AddMember<glTF::SamplerMagFilter>(rapidjson::GenericStringRef<char>, glTF::SamplerMagFilter, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
AddMember(StringRefType name, T value, Allocator& allocator) { GenericValue n(name); return AddMember(n, value, allocator); }
subq $0x28, %rsp movl 0x8(%rsi), %eax xorps %xmm0, %xmm0 movabsq $0x405000000000000, %r8 # imm = 0x405000000000000 orq (%rsi), %r8 movq %rsp, %rsi movaps %xmm0, (%rsi) movq %r8, 0x8(%rsi) movl %eax, (%rsi) leaq 0x18(%rsp), %rax movq $0x0, 0x8(%rax) movslq %edx, %rdx movq %rdx, (%rax) testl %edx, %edx movl $0x1f6, %edx # imm = 0x1F6 movl $0xb6, %r8d cmovnsl %edx, %r8d movw %r8w, 0xe(%rax) movq %rax, %rdx callq 0x4bedaa addq $0x28, %rsp retq nop
/hbina[P]fatuous/thirdparty/assimp/code/../contrib/rapidjson/include/rapidjson/document.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericValue(char const*, unsigned int)
GenericValue(const Ch* s, SizeType length) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(StringRef(s, length)); }
xorps %xmm0, %xmm0 movups %xmm0, (%rdi) testq %rsi, %rsi setne %al testl %edx, %edx sete %cl orb %al, %cl je 0x4c8d13 testq %rsi, %rsi leaq 0x10f0c6(%rip), %rax # 0x5d7dc1 cmovneq %rsi, %rax movabsq $0x405000000000000, %rcx # imm = 0x405000000000000 orq %rax, %rcx movq %rcx, 0x8(%rdi) movl %edx, (%rdi) retq pushq %rax leaq 0x10b522(%rip), %rdi # 0x5d423d leaq 0x10ac99(%rip), %rsi # 0x5d39bb leaq 0x10b52a(%rip), %rcx # 0x5d4253 movl $0x13b, %edx # imm = 0x13B callq 0x1a5270 nop
/hbina[P]fatuous/thirdparty/assimp/code/../contrib/rapidjson/include/rapidjson/document.h
rapidjson::internal::Stack<rapidjson::CrtAllocator>::ShrinkToFit()
void ShrinkToFit() { if (Empty()) { // If the stack is empty, completely deallocate the memory. Allocator::Free(stack_); stack_ = 0; stackTop_ = 0; stackEnd_ = 0; } else Resize(GetSize()); }
pushq %rbx movq %rdi, %rbx movq 0x10(%rdi), %rdi movq 0x18(%rbx), %rsi subq %rdi, %rsi je 0x4c8fc6 movq %rbx, %rdi popq %rbx jmp 0x4c886c addq $0x10, %rbx callq 0x1a52c0 xorps %xmm0, %xmm0 movups %xmm0, (%rbx) movq $0x0, 0x10(%rbx) popq %rbx retq nop
/hbina[P]fatuous/thirdparty/assimp/code/../contrib/rapidjson/include/rapidjson/internal/stack.h
o3dgc::SC3DMCDecoder<unsigned short>::SC3DMCDecoder()
SC3DMCDecoder(void) { m_iterator = 0; m_streamSize = 0; m_quantFloatArray = 0; m_quantFloatArraySize = 0; m_normals = 0; m_normalsSize = 0; m_streamType = O3DGC_STREAM_TYPE_UNKOWN; }
pushq %rbx movq %rdi, %rbx addq $0x10, %rdi movl $0xc28, %edx # imm = 0xC28 xorl %esi, %esi callq 0x1a54e0 movl $0x2, 0x103c(%rbx) movl $0x1, 0x1038(%rbx) movq $0xe, 0x20(%rbx) movq $0x8, 0x28(%rbx) movabsq $0x600000005, %rax # imm = 0x600000005 movq %rax, 0x830(%rbx) movl $0x20e, %eax # imm = 0x20E movaps 0xb6dc1(%rip), %xmm0 # 0x58ac90 movups %xmm0, (%rbx,%rax,4) addq $0x4, %rax cmpq $0x30e, %rax # imm = 0x30E jne 0x4d3ecf leaq 0xc38(%rbx), %rdi movl $0x400, %edx # imm = 0x400 xorl %esi, %esi callq 0x1a54e0 leaq 0x1040(%rbx), %rdi callq 0x4d4fec xorps %xmm0, %xmm0 movups %xmm0, (%rbx) addq $0x11d8, %rbx # imm = 0x11D8 movl $0x2074, %edx # imm = 0x2074 movq %rbx, %rdi xorl %esi, %esi popq %rbx jmp 0x1a54e0 nop
/hbina[P]fatuous/thirdparty/assimp/code/../contrib/Open3DGC/o3dgcSC3DMCDecoder.h
o3dgc::AdjacencyInfo::AllocateNeighborsArray()
O3DGCErrorCode AllocateNeighborsArray() { for(long i = 1; i < m_numElements; ++i) { m_numNeighbors[i] += m_numNeighbors[i-1]; } if (m_numNeighbors[m_numElements-1] > m_neighborsSize) { delete [] m_neighbors; m_neighborsSize = m_numNeighbors[m_numElements-1]; m_neighbors = new long [m_neighborsSize]; } return O3DGC_OK; }
pushq %rbx movq %rdi, %rbx movq 0x10(%rdi), %rcx cmpq $0x2, %rcx jl 0x4d6ef4 movl $0x1, %eax movq 0x20(%rbx), %rcx movq -0x8(%rcx,%rax,8), %rdx addq %rdx, (%rcx,%rax,8) incq %rax movq 0x10(%rbx), %rcx cmpq %rcx, %rax jl 0x4d6edb movq 0x20(%rbx), %rax movq -0x8(%rax,%rcx,8), %rax cmpq (%rbx), %rax jle 0x4d6f3f movq 0x18(%rbx), %rdi testq %rdi, %rdi je 0x4d6f1d callq 0x1a5610 movq 0x10(%rbx), %rax movq 0x20(%rbx), %rcx movq -0x8(%rcx,%rax,8), %rax movq %rax, (%rbx) movq %rax, %rcx shrq $0x3d, %rcx shlq $0x3, %rax xorl %edi, %edi negq %rcx sbbq %rdi, %rdi orq %rax, %rdi callq 0x1a57a0 movq %rax, 0x18(%rbx) xorl %eax, %eax popq %rbx retq nop
/hbina[P]fatuous/thirdparty/assimp/code/../contrib/Open3DGC/o3dgcAdjacencyInfo.h
o3dgc::AdjacencyInfo::Begin(long) const
long Begin(long element) const { assert(element < m_numElements); assert(element >= 0); return (element>0)?m_numNeighbors[element-1]:0; }
pushq %rax cmpq %rsi, 0x10(%rdi) jle 0x4d775b testq %rsi, %rsi js 0x4d777a je 0x4d7757 movq 0x20(%rdi), %rax movq -0x8(%rax,%rsi,8), %rax jmp 0x4d7759 xorl %eax, %eax popq %rcx retq leaq 0xff94c(%rip), %rdi # 0x5d70ae leaq 0xff95d(%rip), %rsi # 0x5d70c6 leaq 0xff9df(%rip), %rcx # 0x5d714f movl $0x7b, %edx callq 0x1a5270 leaq 0xff9fb(%rip), %rdi # 0x5d717c leaq 0xff93e(%rip), %rsi # 0x5d70c6 leaq 0xff9c0(%rip), %rcx # 0x5d714f movl $0x7c, %edx callq 0x1a5270 nop
/hbina[P]fatuous/thirdparty/assimp/code/../contrib/Open3DGC/o3dgcAdjacencyInfo.h
o3dgc::Arithmetic_Codec::ExpGolombDecode(int, o3dgc::Static_Bit_Model&, o3dgc::Adaptive_Bit_Model&)
unsigned ExpGolombDecode(int k, Static_Bit_Model & bModel0, Adaptive_Bit_Model & bModel1) { unsigned int l; int symbol = 0; int binary_symbol = 0; do { l=decode(bModel1); if (l==1) { symbol += (1<<k); k++; } } while (l!=0); while (k--) //next binary part if (decode(bModel0)==1) { binary_symbol |= (1<<k); } return (unsigned int) (symbol+binary_symbol); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rcx, %r12 movq %rdx, %rbx movq %rdi, %r14 xorl %ebp, %ebp xorl %r13d, %r13d movl %esi, %r15d movq %r14, %rdi movq %r12, %rsi callq 0x512668 movl $0x1, %edx movl %r15d, %ecx shll %cl, %edx xorl %esi, %esi cmpl $0x1, %eax cmovnel %ebp, %edx sete %sil addl %r15d, %esi addl %edx, %r13d testl %eax, %eax jne 0x4d7c41 testl %esi, %esi je 0x4d7cac xorl %ecx, %ecx cmpl $0x1, %eax sete %cl addl %ecx, %r15d decl %r15d xorl %r12d, %r12d xorl %ebp, %ebp movq %r14, %rdi movq %rbx, %rsi callq 0x51250e movl $0x1, %edx movl %r15d, %ecx shll %cl, %edx cmpl $0x1, %eax cmovnel %r12d, %edx orl %edx, %ebp addl $-0x1, %r15d jb 0x4d7c86 jmp 0x4d7cae xorl %ebp, %ebp addl %r13d, %ebp movl %ebp, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/hbina[P]fatuous/thirdparty/assimp/code/../contrib/Open3DGC/o3dgcArithmeticCodec.h
Assimp::glTF2Importer::ImportMaterials(glTF2::Asset&)
void glTF2Importer::ImportMaterials(glTF2::Asset& r) { const unsigned int numImportedMaterials = unsigned(r.materials.Size()); Material defaultMaterial; mScene->mNumMaterials = numImportedMaterials + 1; mScene->mMaterials = new aiMaterial*[mScene->mNumMaterials]; mScene->mMaterials[numImportedMaterials] = ImportMaterial(embeddedTexIdxs, r, defaultMaterial); for (unsigned int i = 0; i < numImportedMaterials; ++i) { mScene->mMaterials[i] = ImportMaterial(embeddedTexIdxs, r, r.materials[i]); } }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x190, %rsp # imm = 0x190 movq %rsi, %rbx movq %rdi, %r14 movq 0x5b0(%rsi), %r12 subq 0x5a8(%rsi), %r12 shrq $0x3, %r12 leaq 0x8(%rsp), %rdi callq 0x4e1c90 leal 0x1(%r12), %eax movq 0xa8(%r14), %rcx movl %eax, 0x20(%rcx) movq 0xa8(%r14), %r15 movl 0x20(%r15), %edi shlq $0x3, %rdi callq 0x1a57a0 movq %rax, 0x28(%r15) leaq 0x90(%r14), %r15 leaq 0x8(%rsp), %rdx movq %r15, %rdi movq %rbx, %rsi callq 0x4da123 movq 0xa8(%r14), %rcx movq 0x28(%rcx), %rcx movl %r12d, %edx movq %rax, (%rcx,%rdx,8) testl %r12d, %r12d je 0x4da0c2 movl %r12d, %r12d xorl %r13d, %r13d movq 0x5a8(%rbx), %rax movq (%rax,%r13,8), %rdx movq %r15, %rdi movq %rbx, %rsi callq 0x4da123 movq 0xa8(%r14), %rcx movq 0x28(%rcx), %rcx movq %rax, (%rcx,%r13,8) incq %r13 cmpq %r13, %r12 jne 0x4da095 leaq 0x2d0a17(%rip), %rax # 0x7aaae0 leaq 0x118(%rsp), %rcx movq %rax, -0x110(%rcx) movq -0x10(%rcx), %rdi cmpq %rcx, %rdi je 0x4da0f1 movq 0x118(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x8(%rsp), %rdi callq 0x4f727e addq $0x190, %rsp # imm = 0x190 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq jmp 0x4da10e movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x4e1dfa movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/glTF2/glTF2Importer.cpp
CreateNodeAnim(glTF2::Asset&, glTF2::Node&, AnimationSamplers&)
aiNodeAnim* CreateNodeAnim(glTF2::Asset& r, Node& node, AnimationSamplers& samplers) { aiNodeAnim* anim = new aiNodeAnim(); anim->mNodeName = GetNodeName(node); static const float kMillisecondsFromSeconds = 1000.f; if (samplers.translation) { float* times = nullptr; samplers.translation->input->ExtractData(times); aiVector3D* values = nullptr; samplers.translation->output->ExtractData(values); anim->mNumPositionKeys = static_cast<uint32_t>(samplers.translation->input->count); anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys]; for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) { anim->mPositionKeys[i].mTime = times[i] * kMillisecondsFromSeconds; anim->mPositionKeys[i].mValue = values[i]; } delete[] times; delete[] values; } else if (node.translation.isPresent) { anim->mNumPositionKeys = 1; anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys]; anim->mPositionKeys->mTime = 0.f; anim->mPositionKeys->mValue.x = node.translation.value[0]; anim->mPositionKeys->mValue.y = node.translation.value[1]; anim->mPositionKeys->mValue.z = node.translation.value[2]; } if (samplers.rotation) { float* times = nullptr; samplers.rotation->input->ExtractData(times); aiQuaternion* values = nullptr; samplers.rotation->output->ExtractData(values); anim->mNumRotationKeys = static_cast<uint32_t>(samplers.rotation->input->count); anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys]; for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) { anim->mRotationKeys[i].mTime = times[i] * kMillisecondsFromSeconds; anim->mRotationKeys[i].mValue.x = values[i].w; anim->mRotationKeys[i].mValue.y = values[i].x; anim->mRotationKeys[i].mValue.z = values[i].y; anim->mRotationKeys[i].mValue.w = values[i].z; } delete[] times; delete[] values; } else if (node.rotation.isPresent) { anim->mNumRotationKeys = 1; anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys]; anim->mRotationKeys->mTime = 0.f; anim->mRotationKeys->mValue.x = node.rotation.value[0]; anim->mRotationKeys->mValue.y = node.rotation.value[1]; anim->mRotationKeys->mValue.z = node.rotation.value[2]; anim->mRotationKeys->mValue.w = node.rotation.value[3]; } if (samplers.scale) { float* times = nullptr; samplers.scale->input->ExtractData(times); aiVector3D* values = nullptr; samplers.scale->output->ExtractData(values); anim->mNumScalingKeys = static_cast<uint32_t>(samplers.scale->input->count); anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys]; for (unsigned int i = 0; i < anim->mNumScalingKeys; ++i) { anim->mScalingKeys[i].mTime = times[i] * kMillisecondsFromSeconds; anim->mScalingKeys[i].mValue = values[i]; } delete[] times; delete[] values; } else if (node.scale.isPresent) { anim->mNumScalingKeys = 1; anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys]; anim->mScalingKeys->mTime = 0.f; anim->mScalingKeys->mValue.x = node.scale.value[0]; anim->mScalingKeys->mValue.y = node.scale.value[1]; anim->mScalingKeys->mValue.z = node.scale.value[2]; } return anim; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rdx, %r15 movq %rsi, %r12 movl $0x438, %edi # imm = 0x438 callq 0x1a5230 movq %rax, %r14 movq %rax, 0x10(%rsp) xorl %ebx, %ebx movl %ebx, (%rax) movb $0x0, 0x4(%rax) leaq 0x5(%rax), %rdi movl $0x3ff, %edx # imm = 0x3FF movl $0x1b, %esi callq 0x1a54e0 movq $0x0, 0x418(%r14) movl %ebx, 0x420(%r14) xorps %xmm0, %xmm0 movups %xmm0, 0x404(%r14) movups %xmm0, 0x428(%r14) xorl %eax, %eax cmpq $0x0, 0x38(%r12) setne %al shll $0x5, %eax leaq 0x28(%rsp), %rbx movq %rbx, -0x10(%rbx) movq 0x10(%r12,%rax), %rsi movq 0x18(%r12,%rax), %rdx addq %rsi, %rdx leaq 0x18(%rsp), %rbp movq %rbp, %rdi callq 0x20ac60 movq (%rbp), %r13 movq 0x8(%rbp), %rbp cmpq $0x3ff, %rbp # imm = 0x3FF ja 0x4de538 leaq 0x4(%r14), %rdi movq %r14, %rbx movq %r15, %r14 movq %r12, %r15 movq 0x10(%rsp), %r12 movl %ebp, (%r12) movq %r13, %rsi movq %rbp, %rdx callq 0x1a5110 movb $0x0, 0x4(%r12,%rbp) movq %r15, %r12 movq %r14, %r15 movq %rbx, %r14 leaq 0x28(%rsp), %rbx cmpq %rbx, %r13 je 0x4de54d movq 0x28(%rsp), %rsi incq %rsi movq %r13, %rdi callq 0x1a5190 movq (%r15), %rax testq %rax, %rax je 0x4de659 leaq 0x404(%r14), %r13 xorl %ebx, %ebx leaq 0x18(%rsp), %rsi movq %rbx, (%rsi) movq (%rax), %rcx movl 0x8(%rax), %eax movq (%rcx), %rcx movq (%rcx,%rax,8), %rdi callq 0x4e2452 leaq 0x8(%rsp), %rsi movq %rbx, (%rsi) movq (%r15), %rax movq 0x10(%rax), %rcx movl 0x18(%rax), %eax movq (%rcx), %rcx movq (%rcx,%rax,8), %rdi callq 0x4e1e30 movq (%r15), %rax movq (%rax), %rcx movl 0x8(%rax), %eax movq (%rcx), %rcx movq (%rcx,%rax,8), %rax movq 0x70(%rax), %rbx movl %ebx, %ebp movl %ebx, (%r13) leaq (,%rbp,8), %rax leaq (%rax,%rax,2), %r13 movq %r13, %rdi callq 0x1a57a0 testq %rbp, %rbp je 0x4de5e7 xorl %ecx, %ecx xorps %xmm0, %xmm0 movups %xmm0, (%rax,%rcx) movl $0x0, 0x10(%rax,%rcx) addq $0x18, %rcx cmpq %rcx, %r13 jne 0x4de5d2 movq 0x10(%rsp), %rcx movq %rax, 0x408(%rcx) movq 0x18(%rsp), %rdi testl %ebx, %ebx je 0x4de6ab movq 0x8(%rsp), %rcx addq $0x8, %rax shlq $0x2, %rbp leaq (,%rbp,2), %rdx addq %rbp, %rdx xorl %esi, %esi movss 0x7d062(%rip), %xmm0 # 0x55b684 movq %rdi, %r8 movss (%r8), %xmm1 mulss %xmm0, %xmm1 cvtss2sd %xmm1, %xmm1 movsd %xmm1, -0x8(%rax,%rsi,2) movq (%rcx,%rsi), %r9 movq %r9, (%rax,%rsi,2) movl 0x8(%rcx,%rsi), %r9d movl %r9d, 0x8(%rax,%rsi,2) addq $0x4, %r8 addq $0xc, %rsi cmpq %rsi, %rdx jne 0x4de625 jmp 0x4de6b0 cmpb $0x1, 0xd0(%r12) movq 0x10(%rsp), %rbp jne 0x4de6c9 movl $0x1, 0x404(%rbp) movl $0x18, %edi callq 0x1a57a0 movq %rax, 0x408(%rbp) movq $0x0, (%rax) movsd 0xc4(%r12), %xmm0 movsd %xmm0, 0x8(%rax) movss 0xcc(%r12), %xmm0 movss %xmm0, 0x10(%rax) jmp 0x4de6c9 testq %rdi, %rdi je 0x4de6b5 callq 0x1a5610 movq 0x8(%rsp), %rdi testq %rdi, %rdi movq 0x10(%rsp), %rbp je 0x4de6c9 callq 0x1a5610 movq 0x8(%r15), %rax testq %rax, %rax je 0x4de7e9 xorl %ebx, %ebx leaq 0x18(%rsp), %rsi movq %rbx, (%rsi) movq (%rax), %rcx movl 0x8(%rax), %eax movq (%rcx), %rcx movq (%rcx,%rax,8), %rdi callq 0x4e2452 leaq 0x8(%rsp), %rsi movq %rbx, (%rsi) movq 0x8(%r15), %rax movq 0x10(%rax), %rcx movl 0x18(%rax), %eax movq (%rcx), %rcx movq (%rcx,%rax,8), %rdi callq 0x4e2614 movq 0x8(%r15), %rax movq (%rax), %rcx movl 0x8(%rax), %eax movq (%rcx), %rcx movq (%rcx,%rax,8), %rax movq 0x70(%rax), %rbx movl %ebx, %r13d movl %ebx, 0x410(%rbp) leaq (,%r13,8), %rax leaq (%rax,%rax,2), %rdi callq 0x1a57a0 testq %r13, %r13 je 0x4de773 leaq (,%r13,2), %rcx addq %r13, %rcx leaq (%rax,%rcx,8), %rcx movss 0x7ce54(%rip), %xmm0 # 0x55b5b0 movq %rax, %rdx movq $0x0, (%rdx) movups %xmm0, 0x8(%rdx) addq $0x18, %rdx cmpq %rcx, %rdx jne 0x4de75f movq %rax, 0x418(%rbp) movq 0x18(%rsp), %rdi testl %ebx, %ebx je 0x4de829 movq 0x8(%rsp), %rcx addq $0x14, %rax shlq $0x2, %r13 xorl %edx, %edx movss 0x7cee6(%rip), %xmm0 # 0x55b684 movss (%rdi,%rdx), %xmm1 mulss %xmm0, %xmm1 cvtss2sd %xmm1, %xmm1 movsd %xmm1, -0x14(%rax) movss (%rcx,%rdx,4), %xmm1 movss %xmm1, -0x8(%rax) movss 0x4(%rcx,%rdx,4), %xmm1 movss %xmm1, -0x4(%rax) movss 0x8(%rcx,%rdx,4), %xmm1 movss %xmm1, (%rax) movss 0xc(%rcx,%rdx,4), %xmm1 movss %xmm1, -0xc(%rax) addq $0x4, %rdx addq $0x18, %rax cmpq %rdx, %r13 jne 0x4de79e jmp 0x4de82e cmpb $0x1, 0xe4(%r12) jne 0x4de842 movl $0x1, 0x410(%rbp) movl $0x18, %edi callq 0x1a57a0 movq %rax, 0x418(%rbp) movq $0x0, (%rax) movups 0xd4(%r12), %xmm0 shufps $0x93, %xmm0, %xmm0 # xmm0 = xmm0[3,0,1,2] movups %xmm0, 0x8(%rax) jmp 0x4de842 testq %rdi, %rdi je 0x4de833 callq 0x1a5610 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x4de842 callq 0x1a5610 movq 0x10(%r15), %rax testq %rax, %rax je 0x4de944 addq $0x428, %r14 # imm = 0x428 xorl %ebx, %ebx leaq 0x18(%rsp), %rsi movq %rbx, (%rsi) movq (%rax), %rcx movl 0x8(%rax), %eax movq (%rcx), %rcx movq (%rcx,%rax,8), %rdi callq 0x4e2452 leaq 0x8(%rsp), %rsi movq %rbx, (%rsi) movq 0x10(%r15), %rax movq 0x10(%rax), %rcx movl 0x18(%rax), %eax movq (%rcx), %rcx movq (%rcx,%rax,8), %rdi callq 0x4e1e30 movq 0x10(%r15), %rax movq (%rax), %rcx movl 0x8(%rax), %eax movq (%rcx), %rcx movq (%rcx,%rax,8), %rax movq 0x70(%rax), %rbx movl %ebx, %r12d movl %ebx, 0x420(%rbp) leaq (,%r12,8), %rax leaq (%rax,%rax,2), %r15 movq %r15, %rdi callq 0x1a57a0 testq %r12, %r12 je 0x4de8e2 xorl %ecx, %ecx xorps %xmm0, %xmm0 movups %xmm0, (%rax,%rcx) movl $0x0, 0x10(%rax,%rcx) addq $0x18, %rcx cmpq %rcx, %r15 jne 0x4de8cd movq %rax, (%r14) movq 0x18(%rsp), %rdi testl %ebx, %ebx je 0x4de991 movq 0x8(%rsp), %rcx addq $0x8, %rax shlq $0x2, %r12 leaq (%r12,%r12,2), %rdx xorl %esi, %esi movss 0x7cd77(%rip), %xmm0 # 0x55b684 movq %rdi, %r8 movss (%r8), %xmm1 mulss %xmm0, %xmm1 cvtss2sd %xmm1, %xmm1 movsd %xmm1, -0x8(%rax,%rsi,2) movq (%rcx,%rsi), %r9 movq %r9, (%rax,%rsi,2) movl 0x8(%rcx,%rsi), %r9d movl %r9d, 0x8(%rax,%rsi,2) addq $0x4, %r8 addq $0xc, %rsi cmpq %rsi, %rdx jne 0x4de910 jmp 0x4de996 cmpb $0x1, 0xf4(%r12) jne 0x4de9aa movl $0x1, 0x420(%rbp) movl $0x18, %edi callq 0x1a57a0 movq %rax, 0x428(%rbp) movq $0x0, (%rax) movsd 0xe8(%r12), %xmm0 movsd %xmm0, 0x8(%rax) movss 0xf0(%r12), %xmm0 movss %xmm0, 0x10(%rax) jmp 0x4de9aa testq %rdi, %rdi je 0x4de99b callq 0x1a5610 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x4de9aa callq 0x1a5610 movq %rbp, %rax addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/hbina[P]fatuous/thirdparty/assimp/code/glTF2/glTF2Importer.cpp
glTF2::Buffer::SEncodedRegion::~SEncodedRegion()
~SEncodedRegion() { delete[] DecodedData; }
pushq %rbx movq %rdi, %rbx movq 0x10(%rdi), %rdi testq %rdi, %rdi je 0x4dfa06 callq 0x1a5610 movq 0x20(%rbx), %rdi addq $0x30, %rbx cmpq %rbx, %rdi je 0x4dfa1f movq (%rbx), %rsi incq %rsi popq %rbx jmp 0x1a5190 popq %rbx retq nop
/hbina[P]fatuous/thirdparty/assimp/code/glTF2/glTF2Asset.h
glTF2::Object::~Object()
virtual ~Object() {}
pushq %rbx movq %rdi, %rbx leaq 0x2b304f(%rip), %rax # 0x7aa2d8 movq %rax, (%rdi) movq 0x30(%rdi), %rdi leaq 0x40(%rbx), %rax cmpq %rax, %rdi je 0x4f72a4 movq (%rax), %rsi incq %rsi callq 0x1a5190 movq 0x10(%rbx), %rdi addq $0x20, %rbx cmpq %rbx, %rdi je 0x4f72bd movq (%rbx), %rsi incq %rsi popq %rbx jmp 0x1a5190 popq %rbx retq nop
/hbina[P]fatuous/thirdparty/assimp/code/glTF2/glTF2Asset.h
Assimp::D3MFImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*)
void D3MFImporter::InternReadFile( const std::string &filename, aiScene *pScene, IOSystem *pIOHandler ) { D3MF::D3MFOpcPackage opcPackage(pIOHandler, filename); std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(opcPackage.RootStream())); std::unique_ptr<D3MF::XmlReader> xmlReader(irr::io::createIrrXMLReader(xmlStream.get())); D3MF::XmlSerializer xmlSerializer(xmlReader.get()); xmlSerializer.ImportXml(pScene); }
pushq %r15 pushq %r14 pushq %rbx subq $0xa0, %rsp movq %rdx, %r14 movq %rsi, %rdx movq %rsp, %rdi movq %rcx, %rsi callq 0x4fafac movl $0x30, %edi callq 0x1a5230 movq %rax, %rbx movq %rsp, %rdi callq 0x4fb7a2 movq %rbx, %rdi movq %rax, %rsi callq 0x270a22 movq %rbx, %rdi callq 0x543499 movq %rax, %r15 xorps %xmm0, %xmm0 leaq 0x68(%rsp), %rax movaps %xmm0, -0x28(%rax) movaps %xmm0, -0x38(%rax) movaps %xmm0, -0x48(%rax) movaps %xmm0, -0x58(%rax) xorl %ecx, %ecx movq %rcx, -0x18(%rax) movl $0x5f5e0ff, -0x10(%rax) # imm = 0x5F5E0FF movaps %xmm0, -0x8(%rax) movq %rcx, 0x8(%rax) movq %rax, 0x10(%rax) movq %rax, 0x18(%rax) movq %rcx, 0x20(%rax) movq %r15, 0x28(%rax) leaq 0x10(%rsp), %rdi movq %r14, %rsi callq 0x4f93a6 leaq 0x10(%rsp), %rdi callq 0x4f98e2 testq %r15, %r15 je 0x4f9338 movq (%r15), %rax movq %r15, %rdi callq *0x8(%rax) movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) movq %rsp, %rdi callq 0x4fb770 addq $0xa0, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 leaq 0x10(%rsp), %rdi callq 0x4f98e2 testq %r15, %r15 je 0x4f9376 movq (%r15), %rax movq %r15, %rdi callq *0x8(%rax) jmp 0x4f9376 movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x4f9396 movq %rax, %r14 jmp 0x4f9396 movq %rax, %r14 movl $0x30, %esi movq %rbx, %rdi callq 0x1a5190 movq %rsp, %rdi callq 0x4fb770 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/3MF/D3MFImporter.cpp
Assimp::D3MF::XmlSerializer::~XmlSerializer()
~XmlSerializer() { // empty }
pushq %rbx movq %rdi, %rbx addq $0x50, %rdi callq 0x31af3c movq 0x30(%rbx), %rdi testq %rdi, %rdi je 0x4f9904 movq 0x40(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x18(%rbx), %rdi testq %rdi, %rdi je 0x4f9919 movq 0x28(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq %rbx, %rdi popq %rbx jmp 0x4faf7a
/hbina[P]fatuous/thirdparty/assimp/code/3MF/D3MFImporter.cpp
Assimp::D3MF::XmlSerializer::ReadObject(aiScene*)
aiNode* ReadObject(aiScene* scene) { std::unique_ptr<aiNode> node(new aiNode()); std::vector<unsigned long> meshIds; const char *attrib( nullptr ); std::string name, type; attrib = xmlReader->getAttributeValue( D3MF::XmlTag::id.c_str() ); if ( nullptr != attrib ) { name = attrib; } attrib = xmlReader->getAttributeValue( D3MF::XmlTag::type.c_str() ); if ( nullptr != attrib ) { type = attrib; } node->mParent = scene->mRootNode; node->mName.Set(name); size_t meshIdx = mMeshes.size(); while(ReadToEndElement(D3MF::XmlTag::object)) { if(xmlReader->getNodeName() == D3MF::XmlTag::mesh) { auto mesh = ReadMesh(); mesh->mName.Set(name); mMeshes.push_back(mesh); meshIds.push_back(static_cast<unsigned long>(meshIdx)); ++meshIdx; } } node->mNumMeshes = static_cast<unsigned int>(meshIds.size()); node->mMeshes = new unsigned int[node->mNumMeshes]; std::copy(meshIds.begin(), meshIds.end(), node->mMeshes); return node.release(); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x88, %rsp movq %rsi, %r14 movq %rdi, %rbx movl $0x478, %edi # imm = 0x478 callq 0x1a5230 movq %rax, %r15 movq %rax, %rdi callq 0x2402f8 movq %r15, 0x8(%rsp) xorl %eax, %eax movq %rax, 0x20(%rsp) xorps %xmm0, %xmm0 movaps %xmm0, 0x10(%rsp) leaq 0x50(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0x78(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) movq 0x80(%rbx), %rdi movq 0x2e284c(%rip), %rsi # 0x7dc3c8 movq (%rdi), %rax callq *0x38(%rax) movq %rax, %r15 testq %rax, %rax je 0x4f9baf leaq 0x40(%rsp), %r12 movq 0x8(%r12), %r13 movq %r15, %rdi callq 0x1a56a0 movq %r12, %rdi xorl %esi, %esi movq %r13, %rdx movq %r15, %rcx movq %rax, %r8 callq 0x1a5830 movq 0x80(%rbx), %rdi movq 0x2e288b(%rip), %rsi # 0x7dc448 movq (%rdi), %rax callq *0x38(%rax) movq %rax, %r15 testq %rax, %rax je 0x4f9bf0 leaq 0x68(%rsp), %r12 movq 0x8(%r12), %r13 movq %r15, %rdi callq 0x1a56a0 movq %r12, %rdi xorl %esi, %esi movq %r13, %rdx movq %r15, %rcx movq %rax, %r8 callq 0x1a5830 movq 0x8(%r14), %rax movq 0x8(%rsp), %r15 movq %rax, 0x448(%r15) movq 0x48(%rsp), %r14 cmpq $0x3ff, %r14 # imm = 0x3FF ja 0x4f9c28 movl %r14d, (%r15) leaq 0x4(%r15), %rdi movq 0x40(%rsp), %rsi movq %r14, %rdx callq 0x1a5110 movb $0x0, 0x4(%r15,%r14) leaq 0x18(%rbx), %rax movq %rax, 0x60(%rsp) movq 0x20(%rbx), %r14 subq 0x18(%rbx), %r14 sarq $0x3, %r14 leaq 0x2e2604(%rip), %r15 # 0x7dc248 leaq 0x2e261d(%rip), %r12 # 0x7dc268 movq %rbx, %rdi movq %r15, %rsi callq 0x4f9922 testb %al, %al je 0x4f9d0d movq 0x80(%rbx), %rdi movq (%rdi), %rax callq *0x68(%rax) movq %r12, %rdi movq %rax, %rsi callq 0x1a60c0 testl %eax, %eax jne 0x4f9c4b movq %rbx, %rdi callq 0x4fa142 movq %rax, %rbp movq %rax, 0x38(%rsp) movq 0x48(%rsp), %r13 cmpq $0x3ff, %r13 # imm = 0x3FF ja 0x4f9cbf movl %r13d, 0xec(%rbp) movq %rbp, %rdi addq $0xf0, %rdi movq 0x40(%rsp), %rsi movq %r13, %rdx callq 0x1a5110 movb $0x0, 0xf0(%rbp,%r13) movq 0x20(%rbx), %rsi cmpq 0x28(%rbx), %rsi je 0x4f9ce2 movq 0x38(%rsp), %rax movq %rax, (%rsi) addq $0x8, 0x20(%rbx) leaq 0x10(%rsp), %rdi leaq 0x30(%rsp), %rsi jmp 0x4f9cfb movq 0x60(%rsp), %rdi leaq 0x38(%rsp), %rdx callq 0x250da2 leaq 0x10(%rsp), %rdi leaq 0x30(%rsp), %rsi movq %r14, 0x30(%rsp) callq 0x2adad8 incq %r14 jmp 0x4f9c4b movq 0x10(%rsp), %r14 movq 0x18(%rsp), %rax subq %r14, %rax movq %rax, %r15 sarq $0x3, %r15 movq 0x8(%rsp), %rbx movl %r15d, 0x460(%rbx) shrq %rax movabsq $0x3fffffffc, %rdi # imm = 0x3FFFFFFFC andq %rax, %rdi callq 0x1a57a0 movq %rax, 0x468(%rbx) testq %r15, %r15 jle 0x4f9d67 incq %r15 xorl %ecx, %ecx movl (%r14,%rcx,2), %edx movl %edx, (%rax,%rcx) decq %r15 addq $0x4, %rcx cmpq $0x1, %r15 ja 0x4f9d53 movq $0x0, 0x8(%rsp) movq 0x68(%rsp), %rdi leaq 0x78(%rsp), %rax cmpq %rax, %rdi je 0x4f9d8c movq 0x78(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x40(%rsp), %rdi leaq 0x50(%rsp), %rax cmpq %rax, %rdi je 0x4f9da8 movq 0x50(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x4f9dbf movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 leaq 0x8(%rsp), %rdi callq 0x29cec2 movq %rbx, %rax addq $0x88, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x4f9df8 jmp 0x4f9df8 movq %rax, %rbx movl $0x478, %esi # imm = 0x478 movq %r15, %rdi callq 0x1a5190 jmp 0x4f9e54 jmp 0x4f9df8 jmp 0x4f9df8 movq %rax, %rbx movq 0x68(%rsp), %rdi leaq 0x78(%rsp), %rax cmpq %rax, %rdi je 0x4f9e17 movq 0x78(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x40(%rsp), %rdi leaq 0x50(%rsp), %rax cmpq %rax, %rdi je 0x4f9e33 movq 0x50(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x4f9e4a movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 leaq 0x8(%rsp), %rdi callq 0x29cec2 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/3MF/D3MFImporter.cpp
Assimp::D3MF::XmlSerializer::ReadVertex()
aiVector3D ReadVertex() { aiVector3D vertex; vertex.x = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::x.c_str()), nullptr); vertex.y = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::y.c_str()), nullptr); vertex.z = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::z.c_str()), nullptr); return vertex; }
pushq %rbx subq $0x20, %rsp movq %rdi, %rbx movq 0x80(%rdi), %rdi movq 0x2e1d00(%rip), %rsi # 0x7dc308 movq (%rdi), %rax callq *0x38(%rax) xorps %xmm0, %xmm0 movaps %xmm0, (%rsp) testq %rax, %rax je 0x4fa626 movq %rax, %rdi callq 0x1a5f00 cvtsd2ss %xmm0, %xmm0 movaps %xmm0, 0x10(%rsp) movq 0x80(%rbx), %rdi movq 0x2e1cef(%rip), %rsi # 0x7dc328 movq (%rdi), %rax callq *0x38(%rax) testq %rax, %rax je 0x4fa654 movq %rax, %rdi callq 0x1a5f00 cvtsd2ss %xmm0, %xmm0 movaps %xmm0, (%rsp) movq 0x80(%rbx), %rdi movq 0x2e1ce6(%rip), %rsi # 0x7dc348 movq (%rdi), %rax callq *0x38(%rax) testq %rax, %rax je 0x4fa67b movq %rax, %rdi callq 0x1a5f00 cvtsd2ss %xmm0, %xmm1 jmp 0x4fa67e xorps %xmm1, %xmm1 movaps 0x10(%rsp), %xmm0 unpcklps (%rsp), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1] addq $0x20, %rsp popq %rbx retq nop
/hbina[P]fatuous/thirdparty/assimp/code/3MF/D3MFImporter.cpp
Assimp::MMDImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*)
void MMDImporter::InternReadFile(const std::string &file, aiScene *pScene, IOSystem * /*pIOHandler*/) { // Read file by istream std::filebuf fb; if (!fb.open(file, std::ios::in | std::ios::binary)) { throw DeadlyImportError("Failed to open file " + file + "."); } std::istream fileStream(&fb); // Get the file-size and validate it, throwing an exception when fails fileStream.seekg(0, fileStream.end); size_t fileSize = static_cast<size_t>(fileStream.tellg()); fileStream.seekg(0, fileStream.beg); if (fileSize < sizeof(pmx::PmxModel)) { throw DeadlyImportError(file + " is too small."); } pmx::PmxModel model; model.Read(&fileStream); CreateDataFromImport(&model, pScene); }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x340, %rsp # imm = 0x340 movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 leaq 0x250(%rsp), %r12 movq %r12, %rdi callq 0x1a5f70 movq (%r15), %rsi movq %r12, %rdi movl $0xc, %edx callq 0x1a61a0 testq %rax, %rax je 0x4fc136 leaq 0x138(%rsp), %rdi leaq 0x250(%rsp), %rsi callq 0x1a5d90 leaq 0x138(%rsp), %rdi xorl %esi, %esi movl $0x2, %edx callq 0x1a5550 leaq 0x138(%rsp), %rdi callq 0x1a51d0 movq %rax, %r12 leaq 0x138(%rsp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x1a5550 cmpq $0x12f, %r12 # imm = 0x12F jbe 0x4fc18f xorl %eax, %eax leaq 0x28(%rsp), %rcx movl %eax, -0x20(%rcx) movq %rax, -0x1c(%rcx) movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0x48(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0x68(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) leaq 0x88(%rsp), %rcx movq %rcx, -0x10(%rcx) movq %rax, -0x8(%rcx) movb %al, (%rcx) movl %eax, 0x10(%rcx) movq %rax, 0x18(%rcx) movl %eax, 0x20(%rcx) movq %rax, 0x28(%rcx) movl %eax, 0x30(%rcx) movq %rax, 0x38(%rcx) movl %eax, 0x40(%rcx) movq %rax, 0x48(%rcx) movl %eax, 0x50(%rcx) movq %rax, 0x58(%rcx) movl %eax, 0x60(%rcx) movq %rax, 0x68(%rcx) movl %eax, 0x70(%rcx) movq %rax, 0x78(%rcx) movl %eax, 0x80(%rcx) movq %rax, 0x88(%rcx) movl %eax, 0x90(%rcx) movq %rax, 0x98(%rcx) movl %eax, 0xa0(%rcx) movq %rax, 0xa8(%rcx) leaq 0x8(%rsp), %rdi leaq 0x138(%rsp), %rsi callq 0x4ff9d2 leaq 0x8(%rsp), %rsi movq %r14, %rdi movq %rbx, %rdx callq 0x4fc34a leaq 0x8(%rsp), %rdi callq 0x4fd560 movq 0x2afe4b(%rip), %rax # 0x7abf38 movq (%rax), %rcx movq 0x8(%rax), %rax leaq 0x148(%rsp), %rdi movq %rcx, -0x10(%rdi) movq -0x18(%rcx), %rcx movq %rax, 0x138(%rsp,%rcx) movq $0x0, -0x8(%rdi) callq 0x1a5ca0 leaq 0x250(%rsp), %rdi callq 0x1a5b20 addq $0x340, %rsp # imm = 0x340 popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x9ed6a(%rip), %rsi # 0x59aeb4 leaq 0x138(%rsp), %rdi movq %r15, %rdx callq 0x23ca59 leaq 0x9edbd(%rip), %rsi # 0x59af1e leaq 0x138(%rsp), %rdi callq 0x1a5ba0 leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x4fc1e4 movups (%rcx), %xmm0 movups %xmm0, (%r15) jmp 0x4fc1f1 movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0xa56d0(%rip), %rdx # 0x5a1873 leaq 0x8(%rsp), %rdi movq %r15, %rsi callq 0x43447d movb $0x1, %bpl leaq 0x8(%rsp), %rsi movq %r14, %rdi callq 0x1a53e0 leaq 0x1e1571(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x1e153d(%rip), %rsi # 0x6dd710 movq 0x2afd86(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x4fc23a movq %rdx, 0x8(%rsp) movq (%rcx), %rdx movq %rdx, 0x18(%rsp) movq 0x8(%rax), %rdx leaq 0x8(%rsp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movb $0x1, %bpl movq %r14, %rdi callq 0x1a53e0 leaq 0x1e1519(%rip), %rax # 0x6dd738 movq %rax, (%r14) xorl %ebp, %ebp leaq 0x1e14e5(%rip), %rsi # 0x6dd710 movq 0x2afd2e(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 movq %rax, %rbx movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x4fc254 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x148(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4fc275 movq 0x148(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x4fc2da jmp 0x4fc334 movq %rax, %rbx leaq 0x148(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4fc2da movq 0x148(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x4fc2da movq %rax, %rbx leaq 0x18(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x4fc2c3 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x4fc2cd jmp 0x4fc301 movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 jmp 0x4fc301 movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 jmp 0x4fc334 jmp 0x4fc2e8 jmp 0x4fc2e8 movq %rax, %rbx jmp 0x4fc301 jmp 0x4fc2ef movq %rax, %rbx jmp 0x4fc334 movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x4fd560 movq 0x2afc30(%rip), %rax # 0x7abf38 movq (%rax), %rcx movq 0x8(%rax), %rax leaq 0x148(%rsp), %rdi movq %rcx, -0x10(%rdi) movq -0x18(%rcx), %rcx movq %rax, 0x138(%rsp,%rcx) movq $0x0, -0x8(%rdi) callq 0x1a5ca0 leaq 0x250(%rsp), %rdi callq 0x1a5b20 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDImporter.cpp
pmx::PmxMorphMaterialOffset::Read(std::istream*, pmx::PmxSetting*)
void PmxMorphMaterialOffset::Read(std::istream *stream, PmxSetting *setting) { this->material_index = ReadIndex(stream, setting->material_index_size); stream->read((char*) &this->offset_operation, sizeof(uint8_t)); stream->read((char*)this->diffuse, sizeof(float) * 4); stream->read((char*)this->specular, sizeof(float) * 3); stream->read((char*) &this->specularity, sizeof(float)); stream->read((char*)this->ambient, sizeof(float) * 3); stream->read((char*)this->edge_color, sizeof(float) * 4); stream->read((char*) &this->edge_size, sizeof(float)); stream->read((char*)this->texture_argb, sizeof(float) * 4); stream->read((char*)this->sphere_texture_argb, sizeof(float) * 4); stream->read((char*)this->toon_texture_argb, sizeof(float) * 4); }
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movzbl 0x4(%rdx), %esi movq %rbx, %rdi callq 0x4fdff8 movl %eax, 0x8(%r14) leaq 0xc(%r14), %rsi movl $0x1, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x10(%r14), %rsi movl $0x10, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x20(%r14), %rsi movl $0xc, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x2c(%r14), %rsi movl $0x4, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x30(%r14), %rsi movl $0xc, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x3c(%r14), %rsi movl $0x10, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x4c(%r14), %rsi movl $0x4, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x50(%r14), %rsi movl $0x10, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x60(%r14), %rsi movl $0x10, %edx movq %rbx, %rdi callq 0x1a57e0 addq $0x70, %r14 movl $0x10, %edx movq %rbx, %rdi movq %r14, %rsi addq $0x8, %rsp popq %rbx popq %r14 jmp 0x1a57e0
/hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDPmxParser.cpp
pmx::PmxJointParam::Read(std::istream*, pmx::PmxSetting*)
void PmxJointParam::Read(std::istream *stream, PmxSetting *setting) { this->rigid_body1 = ReadIndex(stream, setting->rigidbody_index_size); this->rigid_body2 = ReadIndex(stream, setting->rigidbody_index_size); stream->read((char*) this->position, sizeof(float) * 3); stream->read((char*) this->orientaiton, sizeof(float) * 3); stream->read((char*) this->move_limitation_min, sizeof(float) * 3); stream->read((char*) this->move_limitation_max, sizeof(float) * 3); stream->read((char*) this->rotation_limitation_min, sizeof(float) * 3); stream->read((char*) this->rotation_limitation_max, sizeof(float) * 3); stream->read((char*) this->spring_move_coefficient, sizeof(float) * 3); stream->read((char*) this->spring_rotation_coefficient, sizeof(float) * 3); }
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 movzbl 0x7(%rdx), %esi movq %rbx, %rdi callq 0x4fdff8 movl %eax, (%r14) movzbl 0x7(%r15), %esi movq %rbx, %rdi callq 0x4fdff8 movl %eax, 0x4(%r14) leaq 0x8(%r14), %rsi movl $0xc, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x14(%r14), %rsi movl $0xc, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x20(%r14), %rsi movl $0xc, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x2c(%r14), %rsi movl $0xc, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x38(%r14), %rsi movl $0xc, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x44(%r14), %rsi movl $0xc, %edx movq %rbx, %rdi callq 0x1a57e0 leaq 0x50(%r14), %rsi movl $0xc, %edx movq %rbx, %rdi callq 0x1a57e0 addq $0x5c, %r14 movl $0xc, %edx movq %rbx, %rdi movq %r14, %rsi popq %rbx popq %r14 popq %r15 jmp 0x1a57e0
/hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDPmxParser.cpp
pmx::PmxModel::Init()
void PmxModel::Init() { this->version = 0.0f; this->model_name.clear(); this->model_english_name.clear(); this->model_comment.clear(); this->model_english_comment.clear(); this->vertex_count = 0; this->vertices = nullptr; this->index_count = 0; this->indices = nullptr; this->texture_count = 0; this->textures = nullptr; this->material_count = 0; this->materials = nullptr; this->bone_count = 0; this->bones = nullptr; this->morph_count = 0; this->morphs = nullptr; this->frame_count = 0; this->frames = nullptr; this->rigid_body_count = 0; this->rigid_bodies = nullptr; this->joint_count = 0; this->joints = nullptr; this->soft_body_count = 0; this->soft_bodies = nullptr; }
pushq %rbx movq %rdi, %rbx xorl %eax, %eax movl %eax, (%rdi) movq %rax, 0x18(%rdi) movq 0x10(%rdi), %rcx movb %al, (%rcx) movq %rax, 0x38(%rdi) movq 0x30(%rdi), %rcx movb %al, (%rcx) movq %rax, 0x58(%rdi) movq 0x50(%rdi), %rcx movb %al, (%rcx) movq %rax, 0x78(%rdi) movq 0x70(%rdi), %rcx movb %al, (%rcx) movl %eax, 0x90(%rdi) movq 0x98(%rdi), %rsi movq %rax, 0x98(%rdi) testq %rsi, %rsi je 0x4ff83d leaq 0x98(%rbx), %rdi callq 0x4fdd1a movl $0x0, 0xa0(%rbx) movq 0xa8(%rbx), %rdi movq $0x0, 0xa8(%rbx) testq %rdi, %rdi je 0x4ff863 callq 0x1a5610 movl $0x0, 0xb0(%rbx) movq 0xb8(%rbx), %rsi movq $0x0, 0xb8(%rbx) testq %rsi, %rsi je 0x4ff890 leaq 0xb8(%rbx), %rdi callq 0x4fdcb4 movl $0x0, 0xc0(%rbx) movq 0xc8(%rbx), %rsi movq $0x0, 0xc8(%rbx) testq %rsi, %rsi je 0x4ff8bd leaq 0xc8(%rbx), %rdi callq 0x4fdbfa movl $0x0, 0xd0(%rbx) movq 0xd8(%rbx), %rsi movq $0x0, 0xd8(%rbx) testq %rsi, %rsi je 0x4ff8ea leaq 0xd8(%rbx), %rdi callq 0x4fdb4a movl $0x0, 0xe0(%rbx) movq 0xe8(%rbx), %rsi movq $0x0, 0xe8(%rbx) testq %rsi, %rsi je 0x4ff917 leaq 0xe8(%rbx), %rdi callq 0x4fda24 movl $0x0, 0xf0(%rbx) movq 0xf8(%rbx), %rsi movq $0x0, 0xf8(%rbx) testq %rsi, %rsi je 0x4ff944 leaq 0xf8(%rbx), %rdi callq 0x4fd97c movl $0x0, 0x100(%rbx) movq 0x108(%rbx), %rsi movq $0x0, 0x108(%rbx) testq %rsi, %rsi je 0x4ff971 leaq 0x108(%rbx), %rdi callq 0x4fd8e8 movl $0x0, 0x110(%rbx) movq 0x118(%rbx), %rsi movq $0x0, 0x118(%rbx) testq %rsi, %rsi je 0x4ff99e leaq 0x118(%rbx), %rdi callq 0x4fd85a movl $0x0, 0x120(%rbx) movq 0x128(%rbx), %rsi movq $0x0, 0x128(%rbx) testq %rsi, %rsi je 0x4ff9cf addq $0x128, %rbx # imm = 0x128 movq %rbx, %rdi popq %rbx jmp 0x4fd788 popq %rbx retq nop
/hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDPmxParser.cpp
pmx::PmxModel::Read(std::istream*)
void PmxModel::Read(std::istream *stream) { char magic[4]; stream->read((char*) magic, sizeof(char) * 4); if (magic[0] != 0x50 || magic[1] != 0x4d || magic[2] != 0x58 || magic[3] != 0x20) { std::cerr << "invalid magic number." << std::endl; throw DeadlyImportError("MMD: invalid magic number."); } stream->read((char*) &version, sizeof(float)); if (version != 2.0f && version != 2.1f) { std::cerr << "this is not ver2.0 or ver2.1 but " << version << "." << std::endl; throw DeadlyImportError("MMD: this is not ver2.0 or ver2.1 but " + to_string(version)); } this->setting.Read(stream); this->model_name = ReadString(stream, setting.encoding); this->model_english_name = ReadString(stream, setting.encoding); this->model_comment = ReadString(stream, setting.encoding); this->model_english_comment = ReadString(stream, setting.encoding); // read vertices stream->read((char*) &vertex_count, sizeof(int)); this->vertices = mmd::make_unique<PmxVertex []>(vertex_count); for (int i = 0; i < vertex_count; i++) { vertices[i].Read(stream, &setting); } // read indices stream->read((char*) &index_count, sizeof(int)); this->indices = mmd::make_unique<int []>(index_count); for (int i = 0; i < index_count; i++) { this->indices[i] = ReadIndex(stream, setting.vertex_index_size); } // read texture names stream->read((char*) &texture_count, sizeof(int)); this->textures = mmd::make_unique<std::string []>(texture_count); for (int i = 0; i < texture_count; i++) { this->textures[i] = ReadString(stream, setting.encoding); } // read materials stream->read((char*) &material_count, sizeof(int)); this->materials = mmd::make_unique<PmxMaterial []>(material_count); for (int i = 0; i < material_count; i++) { this->materials[i].Read(stream, &setting); } // read bones stream->read((char*) &this->bone_count, sizeof(int)); this->bones = mmd::make_unique<PmxBone []>(this->bone_count); for (int i = 0; i < this->bone_count; i++) { this->bones[i].Read(stream, &setting); } // read morphs stream->read((char*) &this->morph_count, sizeof(int)); this->morphs = mmd::make_unique<PmxMorph []>(this->morph_count); for (int i = 0; i < this->morph_count; i++) { this->morphs[i].Read(stream, &setting); } // read display frames stream->read((char*) &this->frame_count, sizeof(int)); this->frames = mmd::make_unique<PmxFrame []>(this->frame_count); for (int i = 0; i < this->frame_count; i++) { this->frames[i].Read(stream, &setting); } // read rigid bodies stream->read((char*) &this->rigid_body_count, sizeof(int)); this->rigid_bodies = mmd::make_unique<PmxRigidBody []>(this->rigid_body_count); for (int i = 0; i < this->rigid_body_count; i++) { this->rigid_bodies[i].Read(stream, &setting); } // read joints stream->read((char*) &this->joint_count, sizeof(int)); this->joints = mmd::make_unique<PmxJoint []>(this->joint_count); for (int i = 0; i < this->joint_count; i++) { this->joints[i].Read(stream, &setting); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rsi, %rbx movq %rdi, %r14 leaq 0x34(%rsp), %r15 movl $0x4, %edx movq %rsi, %rdi movq %r15, %rsi callq 0x1a57e0 cmpl $0x20584d50, (%r15) # imm = 0x20584D50 jne 0x500102 movl $0x4, %edx movq %rbx, %rdi movq %r14, %rsi callq 0x1a57e0 movss (%r14), %xmm0 ucomiss 0x5bbe0(%rip), %xmm0 # 0x55b604 jne 0x4ffa28 jnp 0x4ffa3b ucomiss 0xda591(%rip), %xmm0 # 0x5d9fc0 jne 0x500186 jp 0x500186 leaq 0x4(%r14), %r15 movq %r15, %rdi movq %rbx, %rsi callq 0x4fe1c4 movzbl 0x4(%r14), %edx movq %rsp, %r12 movq %r12, %rdi movq %rbx, %rsi callq 0x4fe06d leaq 0x10(%r14), %rdi movq %r12, %rsi callq 0x1a58d0 movq (%r12), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi je 0x4ffa84 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movzbl 0x4(%r14), %edx movq %rsp, %r12 movq %r12, %rdi movq %rbx, %rsi callq 0x4fe06d leaq 0x30(%r14), %rdi movq %r12, %rsi callq 0x1a58d0 movq (%r12), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi je 0x4ffabe movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movzbl 0x4(%r14), %edx movq %rsp, %r12 movq %r12, %rdi movq %rbx, %rsi callq 0x4fe06d leaq 0x50(%r14), %rdi movq %r12, %rsi callq 0x1a58d0 movq (%r12), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi je 0x4ffaf8 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movzbl 0x4(%r14), %edx movq %rsp, %r12 movq %r12, %rdi movq %rbx, %rsi callq 0x4fe06d leaq 0x70(%r14), %rdi movq %r12, %rsi callq 0x1a58d0 movq (%r12), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi je 0x4ffb32 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x90(%r14), %r12 movl $0x4, %edx movq %rbx, %rdi movq %r12, %rsi callq 0x1a57e0 movslq 0x90(%r14), %rsi movq %rsp, %rbp movq %rbp, %rdi callq 0x5004b4 leaq 0x98(%r14), %r13 movq (%rbp), %rax movq $0x0, (%rbp) movq 0x98(%r14), %rsi movq %r14, 0x20(%rsp) movq %rax, 0x98(%r14) testq %rsi, %rsi je 0x4ffb9f movq %r13, %rdi callq 0x4fdd1a movq (%rsp), %rsi testq %rsi, %rsi je 0x4ffb9f movq %rsp, %rdi callq 0x4fdd1a cmpl $0x0, (%r12) jle 0x4ffbcd xorl %r14d, %r14d xorl %ebp, %ebp movq (%r13), %rdi addq %r14, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x4fe560 incq %rbp movslq (%r12), %rax addq $0x78, %r14 cmpq %rax, %rbp jl 0x4ffbab movq 0x20(%rsp), %r12 leaq 0xa0(%r12), %rsi movl $0x4, %edx movq %rbx, %rdi movq %rsi, 0x28(%rsp) callq 0x1a57e0 movslq 0xa0(%r12), %r14 leaq (,%r14,4), %rax testq %r14, %r14 movq $-0x1, %r13 cmovnsq %rax, %r13 movq %r13, %rdi callq 0x1a57a0 movq %rax, %rbp movq %rax, %rdi xorl %esi, %esi movq %r13, %rdx callq 0x1a54e0 movq 0xa8(%r12), %rdi movq %rbp, 0xa8(%r12) testq %rdi, %rdi je 0x4ffc44 callq 0x1a5610 movq 0x28(%rsp), %rax movl (%rax), %r14d testl %r14d, %r14d jle 0x4ffc76 xorl %r14d, %r14d movzbl 0x6(%r12), %esi movq %rbx, %rdi callq 0x4fdff8 movq 0xa8(%r12), %rcx movl %eax, (%rcx,%r14,4) incq %r14 movslq 0xa0(%r12), %rax cmpq %rax, %r14 jl 0x4ffc4c leaq 0xb0(%r12), %rsi movl $0x4, %edx movq %rbx, %rdi movq %rsi, 0x28(%rsp) callq 0x1a57e0 movslq 0xb0(%r12), %rsi movq %rsp, %rbp movq %rbp, %rdi callq 0x500547 leaq 0xb8(%r12), %r13 movq (%rbp), %rax movq $0x0, (%rbp) movq 0xb8(%r12), %rsi movq %rax, 0xb8(%r12) testq %rsi, %rsi je 0x4ffce5 movq %r13, %rdi callq 0x4fdcb4 movq (%rsp), %rsi testq %rsi, %rsi je 0x4ffce5 movq %rsp, %rdi callq 0x4fdcb4 movq 0x28(%rsp), %rax cmpl $0x0, (%rax) jle 0x4ffd45 xorl %r14d, %r14d movq %rsp, %rbp xorl %r12d, %r12d movzbl (%r15), %edx movq %rbp, %rdi movq %rbx, %rsi callq 0x4fe06d movq (%r13), %rdi addq %r14, %rdi movq %rbp, %rsi callq 0x1a58d0 movq (%rsp), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi je 0x4ffd31 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 incq %r12 movq 0x28(%rsp), %rax movslq (%rax), %rax addq $0x20, %r14 cmpq %rax, %r12 jl 0x4ffcf8 movq 0x20(%rsp), %r14 leaq 0xc0(%r14), %r12 movl $0x4, %edx movq %rbx, %rdi movq %r12, %rsi callq 0x1a57e0 movslq 0xc0(%r14), %rsi movq %rsp, %rbp movq %rbp, %rdi callq 0x5005a9 leaq 0xc8(%r14), %r13 movq (%rbp), %rax movq $0x0, (%rbp) movq 0xc8(%r14), %rsi movq %rax, 0xc8(%r14) testq %rsi, %rsi je 0x4ffdb2 movq %r13, %rdi callq 0x4fdbfa movq (%rsp), %rsi testq %rsi, %rsi je 0x4ffdb2 movq %rsp, %rdi callq 0x4fdbfa cmpl $0x0, (%r12) jle 0x4ffde3 xorl %r14d, %r14d xorl %ebp, %ebp movq (%r13), %rdi addq %r14, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x4fe700 incq %rbp movslq (%r12), %rax addq $0xc0, %r14 cmpq %rax, %rbp jl 0x4ffdbe movq 0x20(%rsp), %r14 leaq 0xd0(%r14), %r12 movl $0x4, %edx movq %rbx, %rdi movq %r12, %rsi callq 0x1a57e0 movslq 0xd0(%r14), %rsi movq %rsp, %rbp movq %rbp, %rdi callq 0x50067c leaq 0xd8(%r14), %r13 movq (%rbp), %rax movq $0x0, (%rbp) movq 0xd8(%r14), %rsi movq %rax, 0xd8(%r14) testq %rsi, %rsi je 0x4ffe50 movq %r13, %rdi callq 0x4fdb4a movq (%rsp), %rsi testq %rsi, %rsi je 0x4ffe50 movq %rsp, %rdi callq 0x4fdb4a cmpl $0x0, (%r12) jle 0x4ffe81 xorl %r14d, %r14d xorl %ebp, %ebp movq (%r13), %rdi addq %r14, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x4fe93e incq %rbp movslq (%r12), %rax addq $0xb0, %r14 cmpq %rax, %rbp jl 0x4ffe5c movq 0x20(%rsp), %r14 leaq 0xe0(%r14), %r12 movl $0x4, %edx movq %rbx, %rdi movq %r12, %rsi callq 0x1a57e0 movslq 0xe0(%r14), %rsi movq %rsp, %rbp movq %rbp, %rdi callq 0x50071e leaq 0xe8(%r14), %r13 movq (%rbp), %rax movq $0x0, (%rbp) movq 0xe8(%r14), %rsi movq %rax, 0xe8(%r14) testq %rsi, %rsi je 0x4ffeee movq %r13, %rdi callq 0x4fda24 movq (%rsp), %rsi testq %rsi, %rsi je 0x4ffeee movq %rsp, %rdi callq 0x4fda24 cmpl $0x0, (%r12) jle 0x4fff1c xorl %r14d, %r14d xorl %ebp, %ebp movq (%r13), %rdi addq %r14, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x4fedee incq %rbp movslq (%r12), %rax subq $-0x80, %r14 cmpq %rax, %rbp jl 0x4ffefa movq 0x20(%rsp), %r14 leaq 0xf0(%r14), %r12 movl $0x4, %edx movq %rbx, %rdi movq %r12, %rsi callq 0x1a57e0 movslq 0xf0(%r14), %rsi movq %rsp, %rbp movq %rbp, %rdi callq 0x50079f leaq 0xf8(%r14), %r13 movq (%rbp), %rax movq $0x0, (%rbp) movq 0xf8(%r14), %rsi movq %rax, 0xf8(%r14) testq %rsi, %rsi je 0x4fff89 movq %r13, %rdi callq 0x4fd97c movq (%rsp), %rsi testq %rsi, %rsi je 0x4fff89 movq %rsp, %rdi callq 0x4fd97c cmpl $0x0, (%r12) jle 0x4fffb7 xorl %r14d, %r14d xorl %ebp, %ebp movq (%r13), %rdi addq %r14, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x4ff28c incq %rbp movslq (%r12), %rax addq $0x50, %r14 cmpq %rax, %rbp jl 0x4fff95 movq 0x20(%rsp), %r14 leaq 0x100(%r14), %r12 movl $0x4, %edx movq %rbx, %rdi movq %r12, %rsi callq 0x1a57e0 movslq 0x100(%r14), %rsi movq %rsp, %rbp movq %rbp, %rdi callq 0x500829 leaq 0x108(%r14), %r13 movq (%rbp), %rax movq $0x0, (%rbp) movq 0x108(%r14), %rsi movq %rax, 0x108(%r14) testq %rsi, %rsi je 0x500024 movq %r13, %rdi callq 0x4fd8e8 movq (%rsp), %rsi testq %rsi, %rsi je 0x500024 movq %rsp, %rdi callq 0x4fd8e8 cmpl $0x0, (%r12) jle 0x500055 xorl %r14d, %r14d xorl %ebp, %ebp movq (%r13), %rdi addq %r14, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x4ff3e4 incq %rbp movslq (%r12), %rax addq $0x88, %r14 cmpq %rax, %rbp jl 0x500030 movq 0x20(%rsp), %r14 leaq 0x110(%r14), %r12 movl $0x4, %edx movq %rbx, %rdi movq %r12, %rsi callq 0x1a57e0 movslq 0x110(%r14), %rsi movq %rsp, %rbp movq %rbp, %rdi callq 0x5008db leaq 0x118(%r14), %r13 movq (%rbp), %rax movq $0x0, (%rbp) movq 0x118(%r14), %rsi movq %rax, 0x118(%r14) testq %rsi, %rsi je 0x5000c2 movq %r13, %rdi callq 0x4fd85a movq (%rsp), %rsi testq %rsi, %rsi je 0x5000c2 movq %rsp, %rdi callq 0x4fd85a cmpl $0x0, (%r12) jle 0x5000f3 xorl %r14d, %r14d xorl %ebp, %ebp movq (%r13), %rdi addq %r14, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x4ff614 incq %rbp movslq (%r12), %rax addq $0xb0, %r14 cmpq %rax, %rbp jl 0x5000ce addq $0x58, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq 0x2abecf(%rip), %rbx # 0x7abfd8 leaq 0xd9f18(%rip), %rsi # 0x5da028 movl $0x15, %edx movq %rbx, %rdi callq 0x1a61e0 movq %rbx, %rdi callq 0x1a6250 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x10(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0xd9ee1(%rip), %rsi # 0x5da023 leaq 0xd9ef4(%rip), %rdx # 0x5da03d movq %rsp, %rdi callq 0x209290 movb $0x1, %bpl movq %rsp, %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x1dd5d2(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x1dd59e(%rip), %rsi # 0x6dd710 movq 0x2abde7(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 jmp 0x500230 movq 0x2abe4b(%rip), %rbx # 0x7abfd8 leaq 0xd9eaf(%rip), %rsi # 0x5da043 movl $0x21, %edx movq %rbx, %rdi callq 0x1a61e0 xorps %xmm0, %xmm0 cvtss2sd (%r14), %xmm0 movq %rbx, %rdi callq 0x1a5df0 movq %rax, %rbx leaq 0x9ad63(%rip), %rsi # 0x59af1e movl $0x1, %edx movq %rax, %rdi callq 0x1a61e0 movq %rbx, %rdi callq 0x1a6250 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx movss (%r14), %xmm0 leaq 0x38(%rsp), %rdi callq 0x500421 leaq 0xd9e4b(%rip), %rsi # 0x5da03e movq %rsp, %rdi leaq 0x38(%rsp), %rdx callq 0x2beb54 movb $0x1, %bpl movq %rsp, %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x1dd523(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x1dd4ef(%rip), %rsi # 0x6dd710 movq 0x2abd38(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 leaq 0x10(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x50024e movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x48(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x50029e movq 0x48(%rsp), %rsi jmp 0x500296 movq %rax, %r14 leaq 0x48(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x5002a8 movq 0x48(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x5002a8 jmp 0x5002a5 movq %rax, %r14 movq (%rsp), %rdi cmpq %r15, %rdi je 0x50029e movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x5002a8 jmp 0x5002b0 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDPmxParser.cpp
mmd::_Unique_if<pmx::PmxRigidBody []>::_Unknown_bound mmd::make_unique<pmx::PmxRigidBody []>(unsigned long)
typename _Unique_if<T>::_Unknown_bound make_unique(size_t n) { typedef typename std::remove_extent<T>::type U; return std::unique_ptr<T>(new U[n]()); }
pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movl $0x88, %ecx movq %rsi, %rax mulq %rcx seto %dl addq $0x8, %rax movq $-0x1, %rcx cmovbq %rcx, %rax movq %rdi, %rbx testb %dl, %dl cmoveq %rax, %rcx movq %rcx, %rdi callq 0x1a57a0 movq %r14, (%rax) leaq 0x8(%rax), %rcx testq %r14, %r14 je 0x5008cd addq $0x38, %rax movq %r14, %rdx shlq $0x7, %rdx leaq (%rdx,%r14,8), %rdx xorl %esi, %esi xorps %xmm0, %xmm0 leaq -0x20(%rax), %rdi movq %rdi, -0x30(%rax) movq %rsi, -0x28(%rax) movb %sil, -0x20(%rax) movq %rax, -0x10(%rax) movq %rsi, -0x8(%rax) movb %sil, (%rax) movl $0x0, 0x10(%rax) movb %sil, 0x14(%rax) movw $0x0, 0x16(%rax) movb %sil, 0x18(%rax) movups %xmm0, 0x1c(%rax) movups %xmm0, 0x2c(%rax) movups %xmm0, 0x3c(%rax) movups %xmm0, 0x45(%rax) addq $0x88, %rax addq $-0x88, %rdx jne 0x50087e movq %rcx, (%rbx) movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 retq
/hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDCpp14.h
p2t::InScanArea(p2t::Point const&, p2t::Point const&, p2t::Point const&, p2t::Point const&)
bool InScanArea(const Point& pa, const Point& pb, const Point& pc, const Point& pd) { double oadb = (pa.x - pb.x)*(pd.y - pb.y) - (pd.x - pb.x)*(pa.y - pb.y); if (oadb >= -EPSILON) { return false; } double oadc = (pa.x - pc.x)*(pd.y - pc.y) - (pd.x - pc.x)*(pa.y - pc.y); if (oadc <= EPSILON) { return false; } return true; }
movsd (%rdi), %xmm2 movsd 0x8(%rdi), %xmm0 movsd (%rsi), %xmm4 movsd 0x8(%rsi), %xmm5 movapd %xmm2, %xmm6 subsd %xmm4, %xmm6 movsd (%rcx), %xmm3 movsd 0x8(%rcx), %xmm1 movapd %xmm1, %xmm7 subsd %xmm5, %xmm7 mulsd %xmm6, %xmm7 movapd %xmm3, %xmm6 subsd %xmm4, %xmm6 movapd %xmm0, %xmm4 subsd %xmm5, %xmm4 mulsd %xmm6, %xmm4 subsd %xmm4, %xmm7 ucomisd 0xd8f9a(%rip), %xmm7 # 0x5da0d0 jae 0x50116d movsd (%rdx), %xmm4 movsd 0x8(%rdx), %xmm5 subsd %xmm4, %xmm2 subsd %xmm5, %xmm1 mulsd %xmm2, %xmm1 subsd %xmm4, %xmm3 subsd %xmm5, %xmm0 mulsd %xmm3, %xmm0 subsd %xmm0, %xmm1 movsd 0xc51eb(%rip), %xmm0 # 0x5c6350 ucomisd %xmm1, %xmm0 setb %al retq xorl %eax, %eax retq
/hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/sweep/../common/utils.h
p2t::Sweep::FlipEdgeEvent(p2t::SweepContext&, p2t::Point&, p2t::Point&, p2t::Triangle*, p2t::Point&)
void Sweep::FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* t, Point& p) { Triangle& ot = t->NeighborAcross(p); Point& op = *ot.OppositePoint(*t, p); if (InScanArea(p, *t->PointCCW(p), *t->PointCW(p), op)) { // Lets rotate shared edge one vertex CW RotateTrianglePair(*t, p, ot, op); tcx.MapTriangleToNodes(*t); tcx.MapTriangleToNodes(ot); if (p == eq && op == ep) { if (eq == *tcx.edge_event.constrained_edge->q && ep == *tcx.edge_event.constrained_edge->p) { t->MarkConstrainedEdge(&ep, &eq); ot.MarkConstrainedEdge(&ep, &eq); Legalize(tcx, *t); Legalize(tcx, ot); } else { // XXX: I think one of the triangles should be legalized here? } } else { Orientation o = Orient2d(eq, op, ep); t = &NextFlipTriangle(tcx, (int)o, *t, ot, p, op); FlipEdgeEvent(tcx, ep, eq, t, p); } } else { Point& newP = NextFlipPoint(ep, eq, ot, op); FlipScanEdgeEvent(tcx, ep, eq, *t, ot, newP); EdgeEvent(tcx, ep, eq, t, p); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %r9, %r15 movq %r8, %r14 movq %rcx, 0x20(%rsp) movq %rdx, 0x10(%rsp) movq %rsi, %rbx movq %rdi, 0x18(%rsp) movq %r14, %rdi movq %r15, %rsi callq 0x543186 movq %rax, %rbp movq %rax, %rdi movq %r14, %rsi movq %r15, %rdx callq 0x542e32 movq %rax, %r12 movq %r14, %rdi movq %r15, %rsi callq 0x54301a movq %rax, %r13 movq %r14, %rdi movq %r15, %rsi callq 0x542e4e movq %r15, %rdi movq %r13, %rsi movq %rax, %rdx movq %r12, %rcx callq 0x5010e7 testb %al, %al je 0x5019fe movq %r14, %rsi movq %r15, %rdx movq %rbp, %rcx movq %r12, %r8 callq 0x502020 movq %rbx, %rdi movq %r14, %rsi callq 0x5035fc movq %rbx, %rdi movq %rbp, %rsi callq 0x5035fc movsd (%r15), %xmm0 movq 0x20(%rsp), %rax movupd (%rax), %xmm1 ucomisd %xmm1, %xmm0 movq 0x10(%rsp), %rax movsd (%rax), %xmm0 jne 0x501982 jp 0x501982 movsd 0x8(%r15), %xmm2 movapd %xmm1, %xmm4 unpckhpd %xmm1, %xmm4 # xmm4 = xmm4[1],xmm1[1] ucomisd %xmm4, %xmm2 jne 0x501982 jp 0x501982 movupd (%r12), %xmm3 ucomisd %xmm0, %xmm3 movq 0x10(%rsp), %rax movsd 0x8(%rax), %xmm2 jne 0x501992 jp 0x501992 movapd %xmm3, %xmm5 unpckhpd %xmm3, %xmm5 # xmm5 = xmm5[1],xmm3[1] ucomisd %xmm2, %xmm5 jne 0x501992 jp 0x501992 jmp 0x501a5f movq 0x10(%rsp), %rax movsd 0x8(%rax), %xmm2 movupd (%r12), %xmm3 unpcklpd %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0] subpd %xmm0, %xmm1 shufpd $0x1, %xmm1, %xmm1 # xmm1 = xmm1[1,0] subpd %xmm0, %xmm3 mulpd %xmm1, %xmm3 movapd %xmm3, %xmm0 unpckhpd %xmm3, %xmm0 # xmm0 = xmm0[1],xmm3[1] subsd %xmm3, %xmm0 xorl %edx, %edx ucomisd 0x8abcb(%rip), %xmm0 # 0x58c588 andpd 0x5ec1b(%rip), %xmm0 # 0x5605e0 seta %dl movsd 0xc4980(%rip), %xmm1 # 0x5c6350 ucomisd %xmm0, %xmm1 movl $0x2, %eax cmoval %eax, %edx movq %r12, (%rsp) movq 0x18(%rsp), %rdi movq %rbx, %rsi movq %r14, %rcx movq %rbp, %r8 movq %r15, %r9 callq 0x502ac6 movq %rax, %r14 jmp 0x5018a8 movq 0x10(%rsp), %rsi movq 0x20(%rsp), %r13 movq %r13, %rdx movq %rbp, %rcx movq %r12, %r8 callq 0x502b26 movq %rax, (%rsp) movq 0x18(%rsp), %r12 movq %r12, %rdi movq %rbx, %rsi movq 0x10(%rsp), %rdx movq %r13, %rcx movq %r14, %r8 movq %rbp, %r9 callq 0x502bf4 movq %r12, %rdi movq %rbx, %rsi movq 0x10(%rsp), %rdx movq %r13, %rcx movq %r14, %r8 movq %r15, %r9 addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x5016c8 movq 0x40(%rbx), %rax movq 0x8(%rax), %rcx ucomisd (%rcx), %xmm1 jne 0x501ae1 jp 0x501ae1 ucomisd 0x8(%rcx), %xmm4 jne 0x501ae1 jp 0x501ae1 movq (%rax), %rax ucomisd (%rax), %xmm0 jne 0x501ae1 jp 0x501ae1 ucomisd 0x8(%rax), %xmm2 jne 0x501ae1 jp 0x501ae1 movq %r14, %rdi movq 0x10(%rsp), %r12 movq %r12, %rsi movq 0x20(%rsp), %r15 movq %r15, %rdx callq 0x542fbe movq %rbp, %rdi movq %r12, %rsi movq %r15, %rdx callq 0x542fbe movq 0x18(%rsp), %r15 movq %r15, %rdi movq %rbx, %rsi movq %r14, %rdx callq 0x501af0 movq %r15, %rdi movq %rbx, %rsi movq %rbp, %rdx addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x501af0 addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/sweep/sweep.cc
p2t::Sweep::AngleExceedsPlus90DegreesOrIsNegative(p2t::Point const*, p2t::Point const*, p2t::Point const*) const
bool Sweep::AngleExceedsPlus90DegreesOrIsNegative(const Point* origin, const Point* pa, const Point* pb) const { const double angle = Angle(origin, pa, pb); return (angle > PI_div2) || (angle < 0); }
pushq %rax movsd (%rsi), %xmm0 movsd 0x8(%rsi), %xmm2 movsd (%rdx), %xmm3 movsd 0x8(%rdx), %xmm4 subsd %xmm0, %xmm3 subsd %xmm2, %xmm4 movsd (%rcx), %xmm1 movsd 0x8(%rcx), %xmm5 subsd %xmm0, %xmm1 subsd %xmm2, %xmm5 movapd %xmm1, %xmm2 mulsd %xmm4, %xmm2 mulsd %xmm3, %xmm1 movapd %xmm3, %xmm0 mulsd %xmm5, %xmm0 subsd %xmm2, %xmm0 mulsd %xmm4, %xmm5 addsd %xmm5, %xmm1 callq 0x1a5490 xorpd %xmm1, %xmm1 movsd 0xd825b(%rip), %xmm2 # 0x5da0e0 cmpltpd %xmm0, %xmm2 cmpltpd %xmm1, %xmm0 orpd %xmm2, %xmm0 movd %xmm0, %eax andb $0x1, %al popq %rcx retq nop
/hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/sweep/sweep.cc